pekko/akka-remote/src/main/java/akka/remote/RemoteProtocol.java

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

package akka.remote;

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),
    HEARTBEAT(2, 3),
    ;
    
    public static final int CONNECT_VALUE = 1;
    public static final int SHUTDOWN_VALUE = 2;
    public static final int HEARTBEAT_VALUE = 3;
    
    
    public final int getNumber() { return value; }
    
    public static CommandType valueOf(int value) {
      switch (value) {
        case 1: return CONNECT;
        case 2: return SHUTDOWN;
        case 3: return HEARTBEAT;
        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.RemoteProtocol.getDescriptor().getEnumTypes().get(0);
    }
    
    private static final CommandType[] VALUES = {
      CONNECT, SHUTDOWN, HEARTBEAT, 
    };
    
    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;
    }
    
    // @@protoc_insertion_point(enum_scope:CommandType)
  }
  
  public interface AkkaRemoteProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // optional .RemoteMessageProtocol message = 1;
    boolean hasMessage();
    akka.remote.RemoteProtocol.RemoteMessageProtocol getMessage();
    akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder();
    
    // optional .RemoteControlProtocol instruction = 2;
    boolean hasInstruction();
    akka.remote.RemoteProtocol.RemoteControlProtocol getInstruction();
    akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder();
  }
  public static final class AkkaRemoteProtocol extends
      com.google.protobuf.GeneratedMessage
      implements AkkaRemoteProtocolOrBuilder {
    // Use AkkaRemoteProtocol.newBuilder() to construct.
    private AkkaRemoteProtocol(Builder builder) {
      super(builder);
    }
    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.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // optional .RemoteMessageProtocol message = 1;
    public static final int MESSAGE_FIELD_NUMBER = 1;
    private akka.remote.RemoteProtocol.RemoteMessageProtocol message_;
    public boolean hasMessage() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public akka.remote.RemoteProtocol.RemoteMessageProtocol getMessage() {
      return message_;
    }
    public akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder() {
      return message_;
    }
    
    // optional .RemoteControlProtocol instruction = 2;
    public static final int INSTRUCTION_FIELD_NUMBER = 2;
    private akka.remote.RemoteProtocol.RemoteControlProtocol instruction_;
    public boolean hasInstruction() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public akka.remote.RemoteProtocol.RemoteControlProtocol getInstruction() {
      return instruction_;
    }
    public akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder() {
      return instruction_;
    }
    
    private void initFields() {
      message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
      instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (hasMessage()) {
        if (!getMessage().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasInstruction()) {
        if (!getInstruction().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeMessage(1, message_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeMessage(2, instruction_);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, message_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, instruction_);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.AkkaRemoteProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.AkkaRemoteProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.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.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.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.AkkaRemoteProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.AkkaRemoteProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.AkkaRemoteProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getMessageFieldBuilder();
          getInstructionFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        if (messageBuilder_ == null) {
          message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
        } else {
          messageBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000001);
        if (instructionBuilder_ == null) {
          instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
        } else {
          instructionBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.AkkaRemoteProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.AkkaRemoteProtocol build() {
        akka.remote.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.AkkaRemoteProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.AkkaRemoteProtocol buildPartial() {
        akka.remote.RemoteProtocol.AkkaRemoteProtocol result = new akka.remote.RemoteProtocol.AkkaRemoteProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        if (messageBuilder_ == null) {
          result.message_ = message_;
        } else {
          result.message_ = messageBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        if (instructionBuilder_ == null) {
          result.instruction_ = instruction_;
        } else {
          result.instruction_ = instructionBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.AkkaRemoteProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.AkkaRemoteProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.AkkaRemoteProtocol other) {
        if (other == akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance()) return this;
        if (other.hasMessage()) {
          mergeMessage(other.getMessage());
        }
        if (other.hasInstruction()) {
          mergeInstruction(other.getInstruction());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (hasMessage()) {
          if (!getMessage().isInitialized()) {
            
            return false;
          }
        }
        if (hasInstruction()) {
          if (!getInstruction().isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder();
              if (hasMessage()) {
                subBuilder.mergeFrom(getMessage());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setMessage(subBuilder.buildPartial());
              break;
            }
            case 18: {
              akka.remote.RemoteProtocol.RemoteControlProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder();
              if (hasInstruction()) {
                subBuilder.mergeFrom(getInstruction());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setInstruction(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // optional .RemoteMessageProtocol message = 1;
      private akka.remote.RemoteProtocol.RemoteMessageProtocol message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> messageBuilder_;
      public boolean hasMessage() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public akka.remote.RemoteProtocol.RemoteMessageProtocol getMessage() {
        if (messageBuilder_ == null) {
          return message_;
        } else {
          return messageBuilder_.getMessage();
        }
      }
      public Builder setMessage(akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
        if (messageBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          message_ = value;
          onChanged();
        } else {
          messageBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder setMessage(
          akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
        if (messageBuilder_ == null) {
          message_ = builderForValue.build();
          onChanged();
        } else {
          messageBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder mergeMessage(akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
        if (messageBuilder_ == null) {
          if (((bitField0_ & 0x00000001) == 0x00000001) &&
              message_ != akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) {
            message_ =
              akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder(message_).mergeFrom(value).buildPartial();
          } else {
            message_ = value;
          }
          onChanged();
        } else {
          messageBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder clearMessage() {
        if (messageBuilder_ == null) {
          message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
          onChanged();
        } else {
          messageBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000001);
        return this;
      }
      public akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder getMessageBuilder() {
        bitField0_ |= 0x00000001;
        onChanged();
        return getMessageFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder() {
        if (messageBuilder_ != null) {
          return messageBuilder_.getMessageOrBuilder();
        } else {
          return message_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
          getMessageFieldBuilder() {
        if (messageBuilder_ == null) {
          messageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder>(
                  message_,
                  getParentForChildren(),
                  isClean());
          message_ = null;
        }
        return messageBuilder_;
      }
      
      // optional .RemoteControlProtocol instruction = 2;
      private akka.remote.RemoteProtocol.RemoteControlProtocol instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder> instructionBuilder_;
      public boolean hasInstruction() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public akka.remote.RemoteProtocol.RemoteControlProtocol getInstruction() {
        if (instructionBuilder_ == null) {
          return instruction_;
        } else {
          return instructionBuilder_.getMessage();
        }
      }
      public Builder setInstruction(akka.remote.RemoteProtocol.RemoteControlProtocol value) {
        if (instructionBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          instruction_ = value;
          onChanged();
        } else {
          instructionBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder setInstruction(
          akka.remote.RemoteProtocol.RemoteControlProtocol.Builder builderForValue) {
        if (instructionBuilder_ == null) {
          instruction_ = builderForValue.build();
          onChanged();
        } else {
          instructionBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder mergeInstruction(akka.remote.RemoteProtocol.RemoteControlProtocol value) {
        if (instructionBuilder_ == null) {
          if (((bitField0_ & 0x00000002) == 0x00000002) &&
              instruction_ != akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) {
            instruction_ =
              akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder(instruction_).mergeFrom(value).buildPartial();
          } else {
            instruction_ = value;
          }
          onChanged();
        } else {
          instructionBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder clearInstruction() {
        if (instructionBuilder_ == null) {
          instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
          onChanged();
        } else {
          instructionBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        return this;
      }
      public akka.remote.RemoteProtocol.RemoteControlProtocol.Builder getInstructionBuilder() {
        bitField0_ |= 0x00000002;
        onChanged();
        return getInstructionFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder() {
        if (instructionBuilder_ != null) {
          return instructionBuilder_.getMessageOrBuilder();
        } else {
          return instruction_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder> 
          getInstructionFieldBuilder() {
        if (instructionBuilder_ == null) {
          instructionBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder>(
                  instruction_,
                  getParentForChildren(),
                  isClean());
          instruction_ = null;
        }
        return instructionBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:AkkaRemoteProtocol)
    }
    
    static {
      defaultInstance = new AkkaRemoteProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:AkkaRemoteProtocol)
  }
  
  public interface RemoteMessageProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required .ActorRefProtocol recipient = 1;
    boolean hasRecipient();
    akka.remote.RemoteProtocol.ActorRefProtocol getRecipient();
    akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder();
    
    // required .MessageProtocol message = 2;
    boolean hasMessage();
    akka.remote.RemoteProtocol.MessageProtocol getMessage();
    akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder();
    
    // optional .ActorRefProtocol sender = 4;
    boolean hasSender();
    akka.remote.RemoteProtocol.ActorRefProtocol getSender();
    akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder();
    
    // repeated .MetadataEntryProtocol metadata = 5;
    java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> 
        getMetadataList();
    akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index);
    int getMetadataCount();
    java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
        getMetadataOrBuilderList();
    akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
        int index);
  }
  public static final class RemoteMessageProtocol extends
      com.google.protobuf.GeneratedMessage
      implements RemoteMessageProtocolOrBuilder {
    // Use RemoteMessageProtocol.newBuilder() to construct.
    private RemoteMessageProtocol(Builder builder) {
      super(builder);
    }
    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.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required .ActorRefProtocol recipient = 1;
    public static final int RECIPIENT_FIELD_NUMBER = 1;
    private akka.remote.RemoteProtocol.ActorRefProtocol recipient_;
    public boolean hasRecipient() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public akka.remote.RemoteProtocol.ActorRefProtocol getRecipient() {
      return recipient_;
    }
    public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder() {
      return recipient_;
    }
    
    // required .MessageProtocol message = 2;
    public static final int MESSAGE_FIELD_NUMBER = 2;
    private akka.remote.RemoteProtocol.MessageProtocol message_;
    public boolean hasMessage() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public akka.remote.RemoteProtocol.MessageProtocol getMessage() {
      return message_;
    }
    public akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
      return message_;
    }
    
    // optional .ActorRefProtocol sender = 4;
    public static final int SENDER_FIELD_NUMBER = 4;
    private akka.remote.RemoteProtocol.ActorRefProtocol sender_;
    public boolean hasSender() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public akka.remote.RemoteProtocol.ActorRefProtocol getSender() {
      return sender_;
    }
    public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder() {
      return sender_;
    }
    
    // repeated .MetadataEntryProtocol metadata = 5;
    public static final int METADATA_FIELD_NUMBER = 5;
    private java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> metadata_;
    public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
      return metadata_;
    }
    public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
        getMetadataOrBuilderList() {
      return metadata_;
    }
    public int getMetadataCount() {
      return metadata_.size();
    }
    public akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
      return metadata_.get(index);
    }
    public akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
        int index) {
      return metadata_.get(index);
    }
    
    private void initFields() {
      recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
      sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      metadata_ = java.util.Collections.emptyList();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasRecipient()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!hasMessage()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!getRecipient().isInitialized()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!getMessage().isInitialized()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (hasSender()) {
        if (!getSender().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      for (int i = 0; i < getMetadataCount(); i++) {
        if (!getMetadata(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeMessage(1, recipient_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeMessage(2, message_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeMessage(4, sender_);
      }
      for (int i = 0; i < metadata_.size(); i++) {
        output.writeMessage(5, metadata_.get(i));
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, recipient_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, message_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(4, sender_);
      }
      for (int i = 0; i < metadata_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(5, metadata_.get(i));
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.RemoteMessageProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.RemoteMessageProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.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.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.RemoteProtocol.RemoteMessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.RemoteMessageProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getRecipientFieldBuilder();
          getMessageFieldBuilder();
          getSenderFieldBuilder();
          getMetadataFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        if (recipientBuilder_ == null) {
          recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
        } else {
          recipientBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000001);
        if (messageBuilder_ == null) {
          message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
        } else {
          messageBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        if (senderBuilder_ == null) {
          sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
        } else {
          senderBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        if (metadataBuilder_ == null) {
          metadata_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000008);
        } else {
          metadataBuilder_.clear();
        }
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.RemoteMessageProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.RemoteMessageProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.RemoteMessageProtocol build() {
        akka.remote.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.RemoteMessageProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.RemoteMessageProtocol buildPartial() {
        akka.remote.RemoteProtocol.RemoteMessageProtocol result = new akka.remote.RemoteProtocol.RemoteMessageProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        if (recipientBuilder_ == null) {
          result.recipient_ = recipient_;
        } else {
          result.recipient_ = recipientBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        if (messageBuilder_ == null) {
          result.message_ = message_;
        } else {
          result.message_ = messageBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        if (senderBuilder_ == null) {
          result.sender_ = sender_;
        } else {
          result.sender_ = senderBuilder_.build();
        }
        if (metadataBuilder_ == null) {
          if (((bitField0_ & 0x00000008) == 0x00000008)) {
            metadata_ = java.util.Collections.unmodifiableList(metadata_);
            bitField0_ = (bitField0_ & ~0x00000008);
          }
          result.metadata_ = metadata_;
        } else {
          result.metadata_ = metadataBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.RemoteMessageProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.RemoteMessageProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteMessageProtocol other) {
        if (other == akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) return this;
        if (other.hasRecipient()) {
          mergeRecipient(other.getRecipient());
        }
        if (other.hasMessage()) {
          mergeMessage(other.getMessage());
        }
        if (other.hasSender()) {
          mergeSender(other.getSender());
        }
        if (metadataBuilder_ == null) {
          if (!other.metadata_.isEmpty()) {
            if (metadata_.isEmpty()) {
              metadata_ = other.metadata_;
              bitField0_ = (bitField0_ & ~0x00000008);
            } else {
              ensureMetadataIsMutable();
              metadata_.addAll(other.metadata_);
            }
            onChanged();
          }
        } else {
          if (!other.metadata_.isEmpty()) {
            if (metadataBuilder_.isEmpty()) {
              metadataBuilder_.dispose();
              metadataBuilder_ = null;
              metadata_ = other.metadata_;
              bitField0_ = (bitField0_ & ~0x00000008);
              metadataBuilder_ = 
                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                   getMetadataFieldBuilder() : null;
            } else {
              metadataBuilder_.addAllMessages(other.metadata_);
            }
          }
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasRecipient()) {
          
          return false;
        }
        if (!hasMessage()) {
          
          return false;
        }
        if (!getRecipient().isInitialized()) {
          
          return false;
        }
        if (!getMessage().isInitialized()) {
          
          return false;
        }
        if (hasSender()) {
          if (!getSender().isInitialized()) {
            
            return false;
          }
        }
        for (int i = 0; i < getMetadataCount(); i++) {
          if (!getMetadata(i).isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.RemoteProtocol.ActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder();
              if (hasRecipient()) {
                subBuilder.mergeFrom(getRecipient());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setRecipient(subBuilder.buildPartial());
              break;
            }
            case 18: {
              akka.remote.RemoteProtocol.MessageProtocol.Builder subBuilder = akka.remote.RemoteProtocol.MessageProtocol.newBuilder();
              if (hasMessage()) {
                subBuilder.mergeFrom(getMessage());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setMessage(subBuilder.buildPartial());
              break;
            }
            case 34: {
              akka.remote.RemoteProtocol.ActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder();
              if (hasSender()) {
                subBuilder.mergeFrom(getSender());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setSender(subBuilder.buildPartial());
              break;
            }
            case 42: {
              akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder subBuilder = akka.remote.RemoteProtocol.MetadataEntryProtocol.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addMetadata(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required .ActorRefProtocol recipient = 1;
      private akka.remote.RemoteProtocol.ActorRefProtocol recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> recipientBuilder_;
      public boolean hasRecipient() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol getRecipient() {
        if (recipientBuilder_ == null) {
          return recipient_;
        } else {
          return recipientBuilder_.getMessage();
        }
      }
      public Builder setRecipient(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (recipientBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          recipient_ = value;
          onChanged();
        } else {
          recipientBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder setRecipient(
          akka.remote.RemoteProtocol.ActorRefProtocol.Builder builderForValue) {
        if (recipientBuilder_ == null) {
          recipient_ = builderForValue.build();
          onChanged();
        } else {
          recipientBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder mergeRecipient(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (recipientBuilder_ == null) {
          if (((bitField0_ & 0x00000001) == 0x00000001) &&
              recipient_ != akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance()) {
            recipient_ =
              akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder(recipient_).mergeFrom(value).buildPartial();
          } else {
            recipient_ = value;
          }
          onChanged();
        } else {
          recipientBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder clearRecipient() {
        if (recipientBuilder_ == null) {
          recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
          onChanged();
        } else {
          recipientBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000001);
        return this;
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol.Builder getRecipientBuilder() {
        bitField0_ |= 0x00000001;
        onChanged();
        return getRecipientFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder() {
        if (recipientBuilder_ != null) {
          return recipientBuilder_.getMessageOrBuilder();
        } else {
          return recipient_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> 
          getRecipientFieldBuilder() {
        if (recipientBuilder_ == null) {
          recipientBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder>(
                  recipient_,
                  getParentForChildren(),
                  isClean());
          recipient_ = null;
        }
        return recipientBuilder_;
      }
      
      // required .MessageProtocol message = 2;
      private akka.remote.RemoteProtocol.MessageProtocol message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder> messageBuilder_;
      public boolean hasMessage() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public akka.remote.RemoteProtocol.MessageProtocol getMessage() {
        if (messageBuilder_ == null) {
          return message_;
        } else {
          return messageBuilder_.getMessage();
        }
      }
      public Builder setMessage(akka.remote.RemoteProtocol.MessageProtocol value) {
        if (messageBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          message_ = value;
          onChanged();
        } else {
          messageBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder setMessage(
          akka.remote.RemoteProtocol.MessageProtocol.Builder builderForValue) {
        if (messageBuilder_ == null) {
          message_ = builderForValue.build();
          onChanged();
        } else {
          messageBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder mergeMessage(akka.remote.RemoteProtocol.MessageProtocol value) {
        if (messageBuilder_ == null) {
          if (((bitField0_ & 0x00000002) == 0x00000002) &&
              message_ != akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance()) {
            message_ =
              akka.remote.RemoteProtocol.MessageProtocol.newBuilder(message_).mergeFrom(value).buildPartial();
          } else {
            message_ = value;
          }
          onChanged();
        } else {
          messageBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder clearMessage() {
        if (messageBuilder_ == null) {
          message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
          onChanged();
        } else {
          messageBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        return this;
      }
      public akka.remote.RemoteProtocol.MessageProtocol.Builder getMessageBuilder() {
        bitField0_ |= 0x00000002;
        onChanged();
        return getMessageFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
        if (messageBuilder_ != null) {
          return messageBuilder_.getMessageOrBuilder();
        } else {
          return message_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder> 
          getMessageFieldBuilder() {
        if (messageBuilder_ == null) {
          messageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder>(
                  message_,
                  getParentForChildren(),
                  isClean());
          message_ = null;
        }
        return messageBuilder_;
      }
      
      // optional .ActorRefProtocol sender = 4;
      private akka.remote.RemoteProtocol.ActorRefProtocol sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> senderBuilder_;
      public boolean hasSender() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol getSender() {
        if (senderBuilder_ == null) {
          return sender_;
        } else {
          return senderBuilder_.getMessage();
        }
      }
      public Builder setSender(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (senderBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          sender_ = value;
          onChanged();
        } else {
          senderBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder setSender(
          akka.remote.RemoteProtocol.ActorRefProtocol.Builder builderForValue) {
        if (senderBuilder_ == null) {
          sender_ = builderForValue.build();
          onChanged();
        } else {
          senderBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder mergeSender(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (senderBuilder_ == null) {
          if (((bitField0_ & 0x00000004) == 0x00000004) &&
              sender_ != akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance()) {
            sender_ =
              akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder(sender_).mergeFrom(value).buildPartial();
          } else {
            sender_ = value;
          }
          onChanged();
        } else {
          senderBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder clearSender() {
        if (senderBuilder_ == null) {
          sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
          onChanged();
        } else {
          senderBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol.Builder getSenderBuilder() {
        bitField0_ |= 0x00000004;
        onChanged();
        return getSenderFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder() {
        if (senderBuilder_ != null) {
          return senderBuilder_.getMessageOrBuilder();
        } else {
          return sender_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> 
          getSenderFieldBuilder() {
        if (senderBuilder_ == null) {
          senderBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder>(
                  sender_,
                  getParentForChildren(),
                  isClean());
          sender_ = null;
        }
        return senderBuilder_;
      }
      
      // repeated .MetadataEntryProtocol metadata = 5;
      private java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> metadata_ =
        java.util.Collections.emptyList();
      private void ensureMetadataIsMutable() {
        if (!((bitField0_ & 0x00000008) == 0x00000008)) {
          metadata_ = new java.util.ArrayList<akka.remote.RemoteProtocol.MetadataEntryProtocol>(metadata_);
          bitField0_ |= 0x00000008;
         }
      }
      
      private com.google.protobuf.RepeatedFieldBuilder<
          akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> metadataBuilder_;
      
      public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
        if (metadataBuilder_ == null) {
          return java.util.Collections.unmodifiableList(metadata_);
        } else {
          return metadataBuilder_.getMessageList();
        }
      }
      public int getMetadataCount() {
        if (metadataBuilder_ == null) {
          return metadata_.size();
        } else {
          return metadataBuilder_.getCount();
        }
      }
      public akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
        if (metadataBuilder_ == null) {
          return metadata_.get(index);
        } else {
          return metadataBuilder_.getMessage(index);
        }
      }
      public Builder setMetadata(
          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol value) {
        if (metadataBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureMetadataIsMutable();
          metadata_.set(index, value);
          onChanged();
        } else {
          metadataBuilder_.setMessage(index, value);
        }
        return this;
      }
      public Builder setMetadata(
          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
        if (metadataBuilder_ == null) {
          ensureMetadataIsMutable();
          metadata_.set(index, builderForValue.build());
          onChanged();
        } else {
          metadataBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addMetadata(akka.remote.RemoteProtocol.MetadataEntryProtocol value) {
        if (metadataBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureMetadataIsMutable();
          metadata_.add(value);
          onChanged();
        } else {
          metadataBuilder_.addMessage(value);
        }
        return this;
      }
      public Builder addMetadata(
          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol value) {
        if (metadataBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureMetadataIsMutable();
          metadata_.add(index, value);
          onChanged();
        } else {
          metadataBuilder_.addMessage(index, value);
        }
        return this;
      }
      public Builder addMetadata(
          akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
        if (metadataBuilder_ == null) {
          ensureMetadataIsMutable();
          metadata_.add(builderForValue.build());
          onChanged();
        } else {
          metadataBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      public Builder addMetadata(
          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
        if (metadataBuilder_ == null) {
          ensureMetadataIsMutable();
          metadata_.add(index, builderForValue.build());
          onChanged();
        } else {
          metadataBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addAllMetadata(
          java.lang.Iterable<? extends akka.remote.RemoteProtocol.MetadataEntryProtocol> values) {
        if (metadataBuilder_ == null) {
          ensureMetadataIsMutable();
          super.addAll(values, metadata_);
          onChanged();
        } else {
          metadataBuilder_.addAllMessages(values);
        }
        return this;
      }
      public Builder clearMetadata() {
        if (metadataBuilder_ == null) {
          metadata_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000008);
          onChanged();
        } else {
          metadataBuilder_.clear();
        }
        return this;
      }
      public Builder removeMetadata(int index) {
        if (metadataBuilder_ == null) {
          ensureMetadataIsMutable();
          metadata_.remove(index);
          onChanged();
        } else {
          metadataBuilder_.remove(index);
        }
        return this;
      }
      public akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder getMetadataBuilder(
          int index) {
        return getMetadataFieldBuilder().getBuilder(index);
      }
      public akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
          int index) {
        if (metadataBuilder_ == null) {
          return metadata_.get(index);  } else {
          return metadataBuilder_.getMessageOrBuilder(index);
        }
      }
      public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
           getMetadataOrBuilderList() {
        if (metadataBuilder_ != null) {
          return metadataBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(metadata_);
        }
      }
      public akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder addMetadataBuilder() {
        return getMetadataFieldBuilder().addBuilder(
            akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
      }
      public akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder addMetadataBuilder(
          int index) {
        return getMetadataFieldBuilder().addBuilder(
            index, akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
      }
      public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder> 
           getMetadataBuilderList() {
        return getMetadataFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilder<
          akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
          getMetadataFieldBuilder() {
        if (metadataBuilder_ == null) {
          metadataBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
              akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder>(
                  metadata_,
                  ((bitField0_ & 0x00000008) == 0x00000008),
                  getParentForChildren(),
                  isClean());
          metadata_ = null;
        }
        return metadataBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:RemoteMessageProtocol)
    }
    
    static {
      defaultInstance = new RemoteMessageProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:RemoteMessageProtocol)
  }
  
  public interface RemoteControlProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required .CommandType commandType = 1;
    boolean hasCommandType();
    akka.remote.RemoteProtocol.CommandType getCommandType();
    
    // optional string cookie = 2;
    boolean hasCookie();
    String getCookie();
    
    // optional .AddressProtocol origin = 3;
    boolean hasOrigin();
    akka.remote.RemoteProtocol.AddressProtocol getOrigin();
    akka.remote.RemoteProtocol.AddressProtocolOrBuilder getOriginOrBuilder();
  }
  public static final class RemoteControlProtocol extends
      com.google.protobuf.GeneratedMessage
      implements RemoteControlProtocolOrBuilder {
    // Use RemoteControlProtocol.newBuilder() to construct.
    private RemoteControlProtocol(Builder builder) {
      super(builder);
    }
    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.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required .CommandType commandType = 1;
    public static final int COMMANDTYPE_FIELD_NUMBER = 1;
    private akka.remote.RemoteProtocol.CommandType commandType_;
    public boolean hasCommandType() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public akka.remote.RemoteProtocol.CommandType getCommandType() {
      return commandType_;
    }
    
    // optional string cookie = 2;
    public static final int COOKIE_FIELD_NUMBER = 2;
    private java.lang.Object cookie_;
    public boolean hasCookie() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public String getCookie() {
      java.lang.Object ref = cookie_;
      if (ref instanceof String) {
        return (String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        String s = bs.toStringUtf8();
        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
          cookie_ = s;
        }
        return s;
      }
    }
    private com.google.protobuf.ByteString getCookieBytes() {
      java.lang.Object ref = cookie_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
        cookie_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    
    // optional .AddressProtocol origin = 3;
    public static final int ORIGIN_FIELD_NUMBER = 3;
    private akka.remote.RemoteProtocol.AddressProtocol origin_;
    public boolean hasOrigin() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public akka.remote.RemoteProtocol.AddressProtocol getOrigin() {
      return origin_;
    }
    public akka.remote.RemoteProtocol.AddressProtocolOrBuilder getOriginOrBuilder() {
      return origin_;
    }
    
    private void initFields() {
      commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
      cookie_ = "";
      origin_ = akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasCommandType()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (hasOrigin()) {
        if (!getOrigin().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeEnum(1, commandType_.getNumber());
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeBytes(2, getCookieBytes());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeMessage(3, origin_);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(1, commandType_.getNumber());
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(2, getCookieBytes());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(3, origin_);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.RemoteControlProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.RemoteControlProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.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.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.RemoteProtocol.RemoteControlProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.RemoteControlProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getOriginFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
        bitField0_ = (bitField0_ & ~0x00000001);
        cookie_ = "";
        bitField0_ = (bitField0_ & ~0x00000002);
        if (originBuilder_ == null) {
          origin_ = akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
        } else {
          originBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.RemoteControlProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.RemoteControlProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.RemoteControlProtocol build() {
        akka.remote.RemoteProtocol.RemoteControlProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.RemoteControlProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.RemoteControlProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.RemoteControlProtocol buildPartial() {
        akka.remote.RemoteProtocol.RemoteControlProtocol result = new akka.remote.RemoteProtocol.RemoteControlProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.commandType_ = commandType_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.cookie_ = cookie_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        if (originBuilder_ == null) {
          result.origin_ = origin_;
        } else {
          result.origin_ = originBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.RemoteControlProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.RemoteControlProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteControlProtocol other) {
        if (other == akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) return this;
        if (other.hasCommandType()) {
          setCommandType(other.getCommandType());
        }
        if (other.hasCookie()) {
          setCookie(other.getCookie());
        }
        if (other.hasOrigin()) {
          mergeOrigin(other.getOrigin());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasCommandType()) {
          
          return false;
        }
        if (hasOrigin()) {
          if (!getOrigin().isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 8: {
              int rawValue = input.readEnum();
              akka.remote.RemoteProtocol.CommandType value = akka.remote.RemoteProtocol.CommandType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(1, rawValue);
              } else {
                bitField0_ |= 0x00000001;
                commandType_ = value;
              }
              break;
            }
            case 18: {
              bitField0_ |= 0x00000002;
              cookie_ = input.readBytes();
              break;
            }
            case 26: {
              akka.remote.RemoteProtocol.AddressProtocol.Builder subBuilder = akka.remote.RemoteProtocol.AddressProtocol.newBuilder();
              if (hasOrigin()) {
                subBuilder.mergeFrom(getOrigin());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setOrigin(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required .CommandType commandType = 1;
      private akka.remote.RemoteProtocol.CommandType commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
      public boolean hasCommandType() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public akka.remote.RemoteProtocol.CommandType getCommandType() {
        return commandType_;
      }
      public Builder setCommandType(akka.remote.RemoteProtocol.CommandType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        bitField0_ |= 0x00000001;
        commandType_ = value;
        onChanged();
        return this;
      }
      public Builder clearCommandType() {
        bitField0_ = (bitField0_ & ~0x00000001);
        commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
        onChanged();
        return this;
      }
      
      // optional string cookie = 2;
      private java.lang.Object cookie_ = "";
      public boolean hasCookie() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public String getCookie() {
        java.lang.Object ref = cookie_;
        if (!(ref instanceof String)) {
          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
          cookie_ = s;
          return s;
        } else {
          return (String) ref;
        }
      }
      public Builder setCookie(String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
        cookie_ = value;
        onChanged();
        return this;
      }
      public Builder clearCookie() {
        bitField0_ = (bitField0_ & ~0x00000002);
        cookie_ = getDefaultInstance().getCookie();
        onChanged();
        return this;
      }
      void setCookie(com.google.protobuf.ByteString value) {
        bitField0_ |= 0x00000002;
        cookie_ = value;
        onChanged();
      }
      
      // optional .AddressProtocol origin = 3;
      private akka.remote.RemoteProtocol.AddressProtocol origin_ = akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.AddressProtocol, akka.remote.RemoteProtocol.AddressProtocol.Builder, akka.remote.RemoteProtocol.AddressProtocolOrBuilder> originBuilder_;
      public boolean hasOrigin() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public akka.remote.RemoteProtocol.AddressProtocol getOrigin() {
        if (originBuilder_ == null) {
          return origin_;
        } else {
          return originBuilder_.getMessage();
        }
      }
      public Builder setOrigin(akka.remote.RemoteProtocol.AddressProtocol value) {
        if (originBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          origin_ = value;
          onChanged();
        } else {
          originBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder setOrigin(
          akka.remote.RemoteProtocol.AddressProtocol.Builder builderForValue) {
        if (originBuilder_ == null) {
          origin_ = builderForValue.build();
          onChanged();
        } else {
          originBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder mergeOrigin(akka.remote.RemoteProtocol.AddressProtocol value) {
        if (originBuilder_ == null) {
          if (((bitField0_ & 0x00000004) == 0x00000004) &&
              origin_ != akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance()) {
            origin_ =
              akka.remote.RemoteProtocol.AddressProtocol.newBuilder(origin_).mergeFrom(value).buildPartial();
          } else {
            origin_ = value;
          }
          onChanged();
        } else {
          originBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder clearOrigin() {
        if (originBuilder_ == null) {
          origin_ = akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
          onChanged();
        } else {
          originBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      public akka.remote.RemoteProtocol.AddressProtocol.Builder getOriginBuilder() {
        bitField0_ |= 0x00000004;
        onChanged();
        return getOriginFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.AddressProtocolOrBuilder getOriginOrBuilder() {
        if (originBuilder_ != null) {
          return originBuilder_.getMessageOrBuilder();
        } else {
          return origin_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.AddressProtocol, akka.remote.RemoteProtocol.AddressProtocol.Builder, akka.remote.RemoteProtocol.AddressProtocolOrBuilder> 
          getOriginFieldBuilder() {
        if (originBuilder_ == null) {
          originBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.AddressProtocol, akka.remote.RemoteProtocol.AddressProtocol.Builder, akka.remote.RemoteProtocol.AddressProtocolOrBuilder>(
                  origin_,
                  getParentForChildren(),
                  isClean());
          origin_ = null;
        }
        return originBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:RemoteControlProtocol)
    }
    
    static {
      defaultInstance = new RemoteControlProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:RemoteControlProtocol)
  }
  
  public interface ActorRefProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required string path = 1;
    boolean hasPath();
    String getPath();
  }
  public static final class ActorRefProtocol extends
      com.google.protobuf.GeneratedMessage
      implements ActorRefProtocolOrBuilder {
    // Use ActorRefProtocol.newBuilder() to construct.
    private ActorRefProtocol(Builder builder) {
      super(builder);
    }
    private ActorRefProtocol(boolean noInit) {}
    
    private static final ActorRefProtocol defaultInstance;
    public static ActorRefProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public ActorRefProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required string path = 1;
    public static final int PATH_FIELD_NUMBER = 1;
    private java.lang.Object path_;
    public boolean hasPath() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public String getPath() {
      java.lang.Object ref = path_;
      if (ref instanceof String) {
        return (String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        String s = bs.toStringUtf8();
        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
          path_ = s;
        }
        return s;
      }
    }
    private com.google.protobuf.ByteString getPathBytes() {
      java.lang.Object ref = path_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
        path_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    
    private void initFields() {
      path_ = "";
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasPath()) {
        memoizedIsInitialized = 0;
        return false;
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeBytes(1, getPathBytes());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(1, getPathBytes());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.ActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.RemoteProtocol.ActorRefProtocol 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.RemoteProtocol.ActorRefProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.RemoteProtocol.ActorRefProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.RemoteProtocol.ActorRefProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.RemoteProtocol.ActorRefProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.RemoteProtocol.ActorRefProtocol 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.RemoteProtocol.ActorRefProtocol 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.RemoteProtocol.ActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.RemoteProtocol.ActorRefProtocol 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.RemoteProtocol.ActorRefProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        path_ = "";
        bitField0_ = (bitField0_ & ~0x00000001);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.ActorRefProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.ActorRefProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.ActorRefProtocol build() {
        akka.remote.RemoteProtocol.ActorRefProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.ActorRefProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.ActorRefProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.ActorRefProtocol buildPartial() {
        akka.remote.RemoteProtocol.ActorRefProtocol result = new akka.remote.RemoteProtocol.ActorRefProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.path_ = path_;
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.ActorRefProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.ActorRefProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.ActorRefProtocol other) {
        if (other == akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance()) return this;
        if (other.hasPath()) {
          setPath(other.getPath());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasPath()) {
          
          return false;
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              bitField0_ |= 0x00000001;
              path_ = input.readBytes();
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required string path = 1;
      private java.lang.Object path_ = "";
      public boolean hasPath() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public String getPath() {
        java.lang.Object ref = path_;
        if (!(ref instanceof String)) {
          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
          path_ = s;
          return s;
        } else {
          return (String) ref;
        }
      }
      public Builder setPath(String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
        path_ = value;
        onChanged();
        return this;
      }
      public Builder clearPath() {
        bitField0_ = (bitField0_ & ~0x00000001);
        path_ = getDefaultInstance().getPath();
        onChanged();
        return this;
      }
      void setPath(com.google.protobuf.ByteString value) {
        bitField0_ |= 0x00000001;
        path_ = value;
        onChanged();
      }
      
      // @@protoc_insertion_point(builder_scope:ActorRefProtocol)
    }
    
    static {
      defaultInstance = new ActorRefProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:ActorRefProtocol)
  }
  
  public interface MessageProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required bytes message = 1;
    boolean hasMessage();
    com.google.protobuf.ByteString getMessage();
    
    // required int32 serializerId = 2;
    boolean hasSerializerId();
    int getSerializerId();
    
    // optional bytes messageManifest = 3;
    boolean hasMessageManifest();
    com.google.protobuf.ByteString getMessageManifest();
  }
  public static final class MessageProtocol extends
      com.google.protobuf.GeneratedMessage
      implements MessageProtocolOrBuilder {
    // Use MessageProtocol.newBuilder() to construct.
    private MessageProtocol(Builder builder) {
      super(builder);
    }
    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.RemoteProtocol.internal_static_MessageProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required bytes message = 1;
    public static final int MESSAGE_FIELD_NUMBER = 1;
    private com.google.protobuf.ByteString message_;
    public boolean hasMessage() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public com.google.protobuf.ByteString getMessage() {
      return message_;
    }
    
    // required int32 serializerId = 2;
    public static final int SERIALIZERID_FIELD_NUMBER = 2;
    private int serializerId_;
    public boolean hasSerializerId() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public int getSerializerId() {
      return serializerId_;
    }
    
    // optional bytes messageManifest = 3;
    public static final int MESSAGEMANIFEST_FIELD_NUMBER = 3;
    private com.google.protobuf.ByteString messageManifest_;
    public boolean hasMessageManifest() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public com.google.protobuf.ByteString getMessageManifest() {
      return messageManifest_;
    }
    
    private void initFields() {
      message_ = com.google.protobuf.ByteString.EMPTY;
      serializerId_ = 0;
      messageManifest_ = com.google.protobuf.ByteString.EMPTY;
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasMessage()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!hasSerializerId()) {
        memoizedIsInitialized = 0;
        return false;
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeBytes(1, message_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeInt32(2, serializerId_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeBytes(3, messageManifest_);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(1, message_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(2, serializerId_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(3, messageManifest_);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.MessageProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.MessageProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.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.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.RemoteProtocol.MessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.MessageProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.MessageProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_MessageProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.MessageProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        message_ = com.google.protobuf.ByteString.EMPTY;
        bitField0_ = (bitField0_ & ~0x00000001);
        serializerId_ = 0;
        bitField0_ = (bitField0_ & ~0x00000002);
        messageManifest_ = com.google.protobuf.ByteString.EMPTY;
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.MessageProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.MessageProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.MessageProtocol build() {
        akka.remote.RemoteProtocol.MessageProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.MessageProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.MessageProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.MessageProtocol buildPartial() {
        akka.remote.RemoteProtocol.MessageProtocol result = new akka.remote.RemoteProtocol.MessageProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.message_ = message_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.serializerId_ = serializerId_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        result.messageManifest_ = messageManifest_;
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.MessageProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.MessageProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.MessageProtocol other) {
        if (other == akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance()) return this;
        if (other.hasMessage()) {
          setMessage(other.getMessage());
        }
        if (other.hasSerializerId()) {
          setSerializerId(other.getSerializerId());
        }
        if (other.hasMessageManifest()) {
          setMessageManifest(other.getMessageManifest());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasMessage()) {
          
          return false;
        }
        if (!hasSerializerId()) {
          
          return false;
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              bitField0_ |= 0x00000001;
              message_ = input.readBytes();
              break;
            }
            case 16: {
              bitField0_ |= 0x00000002;
              serializerId_ = input.readInt32();
              break;
            }
            case 26: {
              bitField0_ |= 0x00000004;
              messageManifest_ = input.readBytes();
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required bytes message = 1;
      private com.google.protobuf.ByteString message_ = com.google.protobuf.ByteString.EMPTY;
      public boolean hasMessage() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public com.google.protobuf.ByteString getMessage() {
        return message_;
      }
      public Builder setMessage(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
        message_ = value;
        onChanged();
        return this;
      }
      public Builder clearMessage() {
        bitField0_ = (bitField0_ & ~0x00000001);
        message_ = getDefaultInstance().getMessage();
        onChanged();
        return this;
      }
      
      // required int32 serializerId = 2;
      private int serializerId_ ;
      public boolean hasSerializerId() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public int getSerializerId() {
        return serializerId_;
      }
      public Builder setSerializerId(int value) {
        bitField0_ |= 0x00000002;
        serializerId_ = value;
        onChanged();
        return this;
      }
      public Builder clearSerializerId() {
        bitField0_ = (bitField0_ & ~0x00000002);
        serializerId_ = 0;
        onChanged();
        return this;
      }
      
      // optional bytes messageManifest = 3;
      private com.google.protobuf.ByteString messageManifest_ = com.google.protobuf.ByteString.EMPTY;
      public boolean hasMessageManifest() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public com.google.protobuf.ByteString getMessageManifest() {
        return messageManifest_;
      }
      public Builder setMessageManifest(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000004;
        messageManifest_ = value;
        onChanged();
        return this;
      }
      public Builder clearMessageManifest() {
        bitField0_ = (bitField0_ & ~0x00000004);
        messageManifest_ = getDefaultInstance().getMessageManifest();
        onChanged();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:MessageProtocol)
    }
    
    static {
      defaultInstance = new MessageProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:MessageProtocol)
  }
  
  public interface MetadataEntryProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required string key = 1;
    boolean hasKey();
    String getKey();
    
    // required bytes value = 2;
    boolean hasValue();
    com.google.protobuf.ByteString getValue();
  }
  public static final class MetadataEntryProtocol extends
      com.google.protobuf.GeneratedMessage
      implements MetadataEntryProtocolOrBuilder {
    // Use MetadataEntryProtocol.newBuilder() to construct.
    private MetadataEntryProtocol(Builder builder) {
      super(builder);
    }
    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.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required string key = 1;
    public static final int KEY_FIELD_NUMBER = 1;
    private java.lang.Object key_;
    public boolean hasKey() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public String getKey() {
      java.lang.Object ref = key_;
      if (ref instanceof String) {
        return (String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        String s = bs.toStringUtf8();
        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
          key_ = s;
        }
        return s;
      }
    }
    private com.google.protobuf.ByteString getKeyBytes() {
      java.lang.Object ref = key_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
        key_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    
    // required bytes value = 2;
    public static final int VALUE_FIELD_NUMBER = 2;
    private com.google.protobuf.ByteString value_;
    public boolean hasValue() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public com.google.protobuf.ByteString getValue() {
      return value_;
    }
    
    private void initFields() {
      key_ = "";
      value_ = com.google.protobuf.ByteString.EMPTY;
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasKey()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!hasValue()) {
        memoizedIsInitialized = 0;
        return false;
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeBytes(1, getKeyBytes());
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeBytes(2, value_);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(1, getKeyBytes());
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(2, value_);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.MetadataEntryProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.MetadataEntryProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.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.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.RemoteProtocol.MetadataEntryProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.MetadataEntryProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.MetadataEntryProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        key_ = "";
        bitField0_ = (bitField0_ & ~0x00000001);
        value_ = com.google.protobuf.ByteString.EMPTY;
        bitField0_ = (bitField0_ & ~0x00000002);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.MetadataEntryProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.MetadataEntryProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.MetadataEntryProtocol build() {
        akka.remote.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.MetadataEntryProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.MetadataEntryProtocol buildPartial() {
        akka.remote.RemoteProtocol.MetadataEntryProtocol result = new akka.remote.RemoteProtocol.MetadataEntryProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.key_ = key_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.value_ = value_;
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.MetadataEntryProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.MetadataEntryProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.MetadataEntryProtocol other) {
        if (other == akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance()) return this;
        if (other.hasKey()) {
          setKey(other.getKey());
        }
        if (other.hasValue()) {
          setValue(other.getValue());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasKey()) {
          
          return false;
        }
        if (!hasValue()) {
          
          return false;
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              bitField0_ |= 0x00000001;
              key_ = input.readBytes();
              break;
            }
            case 18: {
              bitField0_ |= 0x00000002;
              value_ = input.readBytes();
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required string key = 1;
      private java.lang.Object key_ = "";
      public boolean hasKey() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public String getKey() {
        java.lang.Object ref = key_;
        if (!(ref instanceof String)) {
          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
          key_ = s;
          return s;
        } else {
          return (String) ref;
        }
      }
      public Builder setKey(String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
        key_ = value;
        onChanged();
        return this;
      }
      public Builder clearKey() {
        bitField0_ = (bitField0_ & ~0x00000001);
        key_ = getDefaultInstance().getKey();
        onChanged();
        return this;
      }
      void setKey(com.google.protobuf.ByteString value) {
        bitField0_ |= 0x00000001;
        key_ = value;
        onChanged();
      }
      
      // required bytes value = 2;
      private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY;
      public boolean hasValue() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public com.google.protobuf.ByteString getValue() {
        return value_;
      }
      public Builder setValue(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
        value_ = value;
        onChanged();
        return this;
      }
      public Builder clearValue() {
        bitField0_ = (bitField0_ & ~0x00000002);
        value_ = getDefaultInstance().getValue();
        onChanged();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:MetadataEntryProtocol)
    }
    
    static {
      defaultInstance = new MetadataEntryProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:MetadataEntryProtocol)
  }
  
  public interface AddressProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required string system = 1;
    boolean hasSystem();
    String getSystem();
    
    // required string hostname = 2;
    boolean hasHostname();
    String getHostname();
    
    // required uint32 port = 3;
    boolean hasPort();
    int getPort();
  }
  public static final class AddressProtocol extends
      com.google.protobuf.GeneratedMessage
      implements AddressProtocolOrBuilder {
    // Use AddressProtocol.newBuilder() to construct.
    private AddressProtocol(Builder builder) {
      super(builder);
    }
    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.RemoteProtocol.internal_static_AddressProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required string system = 1;
    public static final int SYSTEM_FIELD_NUMBER = 1;
    private java.lang.Object system_;
    public boolean hasSystem() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public String getSystem() {
      java.lang.Object ref = system_;
      if (ref instanceof String) {
        return (String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        String s = bs.toStringUtf8();
        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
          system_ = s;
        }
        return s;
      }
    }
    private com.google.protobuf.ByteString getSystemBytes() {
      java.lang.Object ref = system_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
        system_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    
    // required string hostname = 2;
    public static final int HOSTNAME_FIELD_NUMBER = 2;
    private java.lang.Object hostname_;
    public boolean hasHostname() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public String getHostname() {
      java.lang.Object ref = hostname_;
      if (ref instanceof String) {
        return (String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        String s = bs.toStringUtf8();
        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
          hostname_ = s;
        }
        return s;
      }
    }
    private com.google.protobuf.ByteString getHostnameBytes() {
      java.lang.Object ref = hostname_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
        hostname_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    
    // required uint32 port = 3;
    public static final int PORT_FIELD_NUMBER = 3;
    private int port_;
    public boolean hasPort() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public int getPort() {
      return port_;
    }
    
    private void initFields() {
      system_ = "";
      hostname_ = "";
      port_ = 0;
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasSystem()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!hasHostname()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!hasPort()) {
        memoizedIsInitialized = 0;
        return false;
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeBytes(1, getSystemBytes());
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeBytes(2, getHostnameBytes());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeUInt32(3, port_);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(1, getSystemBytes());
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(2, getHostnameBytes());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt32Size(3, port_);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.AddressProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.AddressProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.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.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.RemoteProtocol.AddressProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.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.RemoteProtocol.AddressProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.AddressProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_AddressProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.AddressProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        system_ = "";
        bitField0_ = (bitField0_ & ~0x00000001);
        hostname_ = "";
        bitField0_ = (bitField0_ & ~0x00000002);
        port_ = 0;
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.AddressProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.AddressProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.AddressProtocol build() {
        akka.remote.RemoteProtocol.AddressProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.AddressProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.AddressProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.AddressProtocol buildPartial() {
        akka.remote.RemoteProtocol.AddressProtocol result = new akka.remote.RemoteProtocol.AddressProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.system_ = system_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.hostname_ = hostname_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        result.port_ = port_;
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.AddressProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.AddressProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.AddressProtocol other) {
        if (other == akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance()) return this;
        if (other.hasSystem()) {
          setSystem(other.getSystem());
        }
        if (other.hasHostname()) {
          setHostname(other.getHostname());
        }
        if (other.hasPort()) {
          setPort(other.getPort());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasSystem()) {
          
          return false;
        }
        if (!hasHostname()) {
          
          return false;
        }
        if (!hasPort()) {
          
          return false;
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              bitField0_ |= 0x00000001;
              system_ = input.readBytes();
              break;
            }
            case 18: {
              bitField0_ |= 0x00000002;
              hostname_ = input.readBytes();
              break;
            }
            case 24: {
              bitField0_ |= 0x00000004;
              port_ = input.readUInt32();
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required string system = 1;
      private java.lang.Object system_ = "";
      public boolean hasSystem() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public String getSystem() {
        java.lang.Object ref = system_;
        if (!(ref instanceof String)) {
          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
          system_ = s;
          return s;
        } else {
          return (String) ref;
        }
      }
      public Builder setSystem(String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
        system_ = value;
        onChanged();
        return this;
      }
      public Builder clearSystem() {
        bitField0_ = (bitField0_ & ~0x00000001);
        system_ = getDefaultInstance().getSystem();
        onChanged();
        return this;
      }
      void setSystem(com.google.protobuf.ByteString value) {
        bitField0_ |= 0x00000001;
        system_ = value;
        onChanged();
      }
      
      // required string hostname = 2;
      private java.lang.Object hostname_ = "";
      public boolean hasHostname() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public String getHostname() {
        java.lang.Object ref = hostname_;
        if (!(ref instanceof String)) {
          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
          hostname_ = s;
          return s;
        } else {
          return (String) ref;
        }
      }
      public Builder setHostname(String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
        hostname_ = value;
        onChanged();
        return this;
      }
      public Builder clearHostname() {
        bitField0_ = (bitField0_ & ~0x00000002);
        hostname_ = getDefaultInstance().getHostname();
        onChanged();
        return this;
      }
      void setHostname(com.google.protobuf.ByteString value) {
        bitField0_ |= 0x00000002;
        hostname_ = value;
        onChanged();
      }
      
      // required uint32 port = 3;
      private int port_ ;
      public boolean hasPort() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public int getPort() {
        return port_;
      }
      public Builder setPort(int value) {
        bitField0_ |= 0x00000004;
        port_ = value;
        onChanged();
        return this;
      }
      public Builder clearPort() {
        bitField0_ = (bitField0_ & ~0x00000004);
        port_ = 0;
        onChanged();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:AddressProtocol)
    }
    
    static {
      defaultInstance = new AddressProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:AddressProtocol)
  }
  
  public interface DurableMailboxMessageProtocolOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // required .ActorRefProtocol recipient = 1;
    boolean hasRecipient();
    akka.remote.RemoteProtocol.ActorRefProtocol getRecipient();
    akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder();
    
    // optional .ActorRefProtocol sender = 2;
    boolean hasSender();
    akka.remote.RemoteProtocol.ActorRefProtocol getSender();
    akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder();
    
    // required bytes message = 3;
    boolean hasMessage();
    com.google.protobuf.ByteString getMessage();
  }
  public static final class DurableMailboxMessageProtocol extends
      com.google.protobuf.GeneratedMessage
      implements DurableMailboxMessageProtocolOrBuilder {
    // Use DurableMailboxMessageProtocol.newBuilder() to construct.
    private DurableMailboxMessageProtocol(Builder builder) {
      super(builder);
    }
    private DurableMailboxMessageProtocol(boolean noInit) {}
    
    private static final DurableMailboxMessageProtocol defaultInstance;
    public static DurableMailboxMessageProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public DurableMailboxMessageProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
    }
    
    private int bitField0_;
    // required .ActorRefProtocol recipient = 1;
    public static final int RECIPIENT_FIELD_NUMBER = 1;
    private akka.remote.RemoteProtocol.ActorRefProtocol recipient_;
    public boolean hasRecipient() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public akka.remote.RemoteProtocol.ActorRefProtocol getRecipient() {
      return recipient_;
    }
    public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder() {
      return recipient_;
    }
    
    // optional .ActorRefProtocol sender = 2;
    public static final int SENDER_FIELD_NUMBER = 2;
    private akka.remote.RemoteProtocol.ActorRefProtocol sender_;
    public boolean hasSender() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public akka.remote.RemoteProtocol.ActorRefProtocol getSender() {
      return sender_;
    }
    public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder() {
      return sender_;
    }
    
    // required bytes message = 3;
    public static final int MESSAGE_FIELD_NUMBER = 3;
    private com.google.protobuf.ByteString message_;
    public boolean hasMessage() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public com.google.protobuf.ByteString getMessage() {
      return message_;
    }
    
    private void initFields() {
      recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      message_ = com.google.protobuf.ByteString.EMPTY;
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasRecipient()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!hasMessage()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (!getRecipient().isInitialized()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (hasSender()) {
        if (!getSender().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeMessage(1, recipient_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeMessage(2, sender_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeBytes(3, message_);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, recipient_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, sender_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(3, message_);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    private static final long serialVersionUID = 0L;
    @java.lang.Override
    protected java.lang.Object writeReplace()
        throws java.io.ObjectStreamException {
      return super.writeReplace();
    }
    
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol 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.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol 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.RemoteProtocol.DurableMailboxMessageProtocol 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.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol 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.RemoteProtocol.DurableMailboxMessageProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements akka.remote.RemoteProtocol.DurableMailboxMessageProtocolOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
      }
      
      // Construct using akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getRecipientFieldBuilder();
          getSenderFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        if (recipientBuilder_ == null) {
          recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
        } else {
          recipientBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000001);
        if (senderBuilder_ == null) {
          sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
        } else {
          senderBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        message_ = com.google.protobuf.ByteString.EMPTY;
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.getDescriptor();
      }
      
      public akka.remote.RemoteProtocol.DurableMailboxMessageProtocol getDefaultInstanceForType() {
        return akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.getDefaultInstance();
      }
      
      public akka.remote.RemoteProtocol.DurableMailboxMessageProtocol build() {
        akka.remote.RemoteProtocol.DurableMailboxMessageProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private akka.remote.RemoteProtocol.DurableMailboxMessageProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        akka.remote.RemoteProtocol.DurableMailboxMessageProtocol result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public akka.remote.RemoteProtocol.DurableMailboxMessageProtocol buildPartial() {
        akka.remote.RemoteProtocol.DurableMailboxMessageProtocol result = new akka.remote.RemoteProtocol.DurableMailboxMessageProtocol(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        if (recipientBuilder_ == null) {
          result.recipient_ = recipient_;
        } else {
          result.recipient_ = recipientBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        if (senderBuilder_ == null) {
          result.sender_ = sender_;
        } else {
          result.sender_ = senderBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        result.message_ = message_;
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.RemoteProtocol.DurableMailboxMessageProtocol) {
          return mergeFrom((akka.remote.RemoteProtocol.DurableMailboxMessageProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.RemoteProtocol.DurableMailboxMessageProtocol other) {
        if (other == akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.getDefaultInstance()) return this;
        if (other.hasRecipient()) {
          mergeRecipient(other.getRecipient());
        }
        if (other.hasSender()) {
          mergeSender(other.getSender());
        }
        if (other.hasMessage()) {
          setMessage(other.getMessage());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasRecipient()) {
          
          return false;
        }
        if (!hasMessage()) {
          
          return false;
        }
        if (!getRecipient().isInitialized()) {
          
          return false;
        }
        if (hasSender()) {
          if (!getSender().isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      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());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.RemoteProtocol.ActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder();
              if (hasRecipient()) {
                subBuilder.mergeFrom(getRecipient());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setRecipient(subBuilder.buildPartial());
              break;
            }
            case 18: {
              akka.remote.RemoteProtocol.ActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder();
              if (hasSender()) {
                subBuilder.mergeFrom(getSender());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setSender(subBuilder.buildPartial());
              break;
            }
            case 26: {
              bitField0_ |= 0x00000004;
              message_ = input.readBytes();
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // required .ActorRefProtocol recipient = 1;
      private akka.remote.RemoteProtocol.ActorRefProtocol recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> recipientBuilder_;
      public boolean hasRecipient() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol getRecipient() {
        if (recipientBuilder_ == null) {
          return recipient_;
        } else {
          return recipientBuilder_.getMessage();
        }
      }
      public Builder setRecipient(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (recipientBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          recipient_ = value;
          onChanged();
        } else {
          recipientBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder setRecipient(
          akka.remote.RemoteProtocol.ActorRefProtocol.Builder builderForValue) {
        if (recipientBuilder_ == null) {
          recipient_ = builderForValue.build();
          onChanged();
        } else {
          recipientBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder mergeRecipient(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (recipientBuilder_ == null) {
          if (((bitField0_ & 0x00000001) == 0x00000001) &&
              recipient_ != akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance()) {
            recipient_ =
              akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder(recipient_).mergeFrom(value).buildPartial();
          } else {
            recipient_ = value;
          }
          onChanged();
        } else {
          recipientBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000001;
        return this;
      }
      public Builder clearRecipient() {
        if (recipientBuilder_ == null) {
          recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
          onChanged();
        } else {
          recipientBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000001);
        return this;
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol.Builder getRecipientBuilder() {
        bitField0_ |= 0x00000001;
        onChanged();
        return getRecipientFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder() {
        if (recipientBuilder_ != null) {
          return recipientBuilder_.getMessageOrBuilder();
        } else {
          return recipient_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> 
          getRecipientFieldBuilder() {
        if (recipientBuilder_ == null) {
          recipientBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder>(
                  recipient_,
                  getParentForChildren(),
                  isClean());
          recipient_ = null;
        }
        return recipientBuilder_;
      }
      
      // optional .ActorRefProtocol sender = 2;
      private akka.remote.RemoteProtocol.ActorRefProtocol sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> senderBuilder_;
      public boolean hasSender() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol getSender() {
        if (senderBuilder_ == null) {
          return sender_;
        } else {
          return senderBuilder_.getMessage();
        }
      }
      public Builder setSender(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (senderBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          sender_ = value;
          onChanged();
        } else {
          senderBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder setSender(
          akka.remote.RemoteProtocol.ActorRefProtocol.Builder builderForValue) {
        if (senderBuilder_ == null) {
          sender_ = builderForValue.build();
          onChanged();
        } else {
          senderBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder mergeSender(akka.remote.RemoteProtocol.ActorRefProtocol value) {
        if (senderBuilder_ == null) {
          if (((bitField0_ & 0x00000002) == 0x00000002) &&
              sender_ != akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance()) {
            sender_ =
              akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder(sender_).mergeFrom(value).buildPartial();
          } else {
            sender_ = value;
          }
          onChanged();
        } else {
          senderBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder clearSender() {
        if (senderBuilder_ == null) {
          sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
          onChanged();
        } else {
          senderBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        return this;
      }
      public akka.remote.RemoteProtocol.ActorRefProtocol.Builder getSenderBuilder() {
        bitField0_ |= 0x00000002;
        onChanged();
        return getSenderFieldBuilder().getBuilder();
      }
      public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder() {
        if (senderBuilder_ != null) {
          return senderBuilder_.getMessageOrBuilder();
        } else {
          return sender_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> 
          getSenderFieldBuilder() {
        if (senderBuilder_ == null) {
          senderBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder>(
                  sender_,
                  getParentForChildren(),
                  isClean());
          sender_ = null;
        }
        return senderBuilder_;
      }
      
      // required bytes message = 3;
      private com.google.protobuf.ByteString message_ = com.google.protobuf.ByteString.EMPTY;
      public boolean hasMessage() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public com.google.protobuf.ByteString getMessage() {
        return message_;
      }
      public Builder setMessage(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000004;
        message_ = value;
        onChanged();
        return this;
      }
      public Builder clearMessage() {
        bitField0_ = (bitField0_ & ~0x00000004);
        message_ = getDefaultInstance().getMessage();
        onChanged();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:DurableMailboxMessageProtocol)
    }
    
    static {
      defaultInstance = new DurableMailboxMessageProtocol(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:DurableMailboxMessageProtocol)
  }
  
  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_ActorRefProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_ActorRefProtocol_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_MetadataEntryProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_MetadataEntryProtocol_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_DurableMailboxMessageProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_DurableMailboxMessageProtocol_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\"\255\001\n\025RemoteMessageProtocol\022$\n\t" +
      "recipient\030\001 \002(\0132\021.ActorRefProtocol\022!\n\007me" +
      "ssage\030\002 \002(\0132\020.MessageProtocol\022!\n\006sender\030" +
      "\004 \001(\0132\021.ActorRefProtocol\022(\n\010metadata\030\005 \003" +
      "(\0132\026.MetadataEntryProtocol\"l\n\025RemoteCont" +
      "rolProtocol\022!\n\013commandType\030\001 \002(\0162\014.Comma" +
      "ndType\022\016\n\006cookie\030\002 \001(\t\022 \n\006origin\030\003 \001(\0132\020",
      ".AddressProtocol\" \n\020ActorRefProtocol\022\014\n\004" +
      "path\030\001 \002(\t\"Q\n\017MessageProtocol\022\017\n\007message" +
      "\030\001 \002(\014\022\024\n\014serializerId\030\002 \002(\005\022\027\n\017messageM" +
      "anifest\030\003 \001(\014\"3\n\025MetadataEntryProtocol\022\013" +
      "\n\003key\030\001 \002(\t\022\r\n\005value\030\002 \002(\014\"A\n\017AddressPro" +
      "tocol\022\016\n\006system\030\001 \002(\t\022\020\n\010hostname\030\002 \002(\t\022" +
      "\014\n\004port\030\003 \002(\r\"y\n\035DurableMailboxMessagePr" +
      "otocol\022$\n\trecipient\030\001 \002(\0132\021.ActorRefProt" +
      "ocol\022!\n\006sender\030\002 \001(\0132\021.ActorRefProtocol\022" +
      "\017\n\007message\030\003 \002(\014*7\n\013CommandType\022\013\n\007CONNE",
      "CT\020\001\022\014\n\010SHUTDOWN\020\002\022\r\n\tHEARTBEAT\020\003B\017\n\013akk" +
      "a.remoteH\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.RemoteProtocol.AkkaRemoteProtocol.class,
              akka.remote.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[] { "Recipient", "Message", "Sender", "Metadata", },
              akka.remote.RemoteProtocol.RemoteMessageProtocol.class,
              akka.remote.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[] { "CommandType", "Cookie", "Origin", },
              akka.remote.RemoteProtocol.RemoteControlProtocol.class,
              akka.remote.RemoteProtocol.RemoteControlProtocol.Builder.class);
          internal_static_ActorRefProtocol_descriptor =
            getDescriptor().getMessageTypes().get(3);
          internal_static_ActorRefProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_ActorRefProtocol_descriptor,
              new java.lang.String[] { "Path", },
              akka.remote.RemoteProtocol.ActorRefProtocol.class,
              akka.remote.RemoteProtocol.ActorRefProtocol.Builder.class);
          internal_static_MessageProtocol_descriptor =
            getDescriptor().getMessageTypes().get(4);
          internal_static_MessageProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_MessageProtocol_descriptor,
              new java.lang.String[] { "Message", "SerializerId", "MessageManifest", },
              akka.remote.RemoteProtocol.MessageProtocol.class,
              akka.remote.RemoteProtocol.MessageProtocol.Builder.class);
          internal_static_MetadataEntryProtocol_descriptor =
            getDescriptor().getMessageTypes().get(5);
          internal_static_MetadataEntryProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_MetadataEntryProtocol_descriptor,
              new java.lang.String[] { "Key", "Value", },
              akka.remote.RemoteProtocol.MetadataEntryProtocol.class,
              akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder.class);
          internal_static_AddressProtocol_descriptor =
            getDescriptor().getMessageTypes().get(6);
          internal_static_AddressProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_AddressProtocol_descriptor,
              new java.lang.String[] { "System", "Hostname", "Port", },
              akka.remote.RemoteProtocol.AddressProtocol.class,
              akka.remote.RemoteProtocol.AddressProtocol.Builder.class);
          internal_static_DurableMailboxMessageProtocol_descriptor =
            getDescriptor().getMessageTypes().get(7);
          internal_static_DurableMailboxMessageProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_DurableMailboxMessageProtocol_descriptor,
              new java.lang.String[] { "Recipient", "Sender", "Message", },
              akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.class,
              akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.Builder.class);
          return null;
        }
      };
    com.google.protobuf.Descriptors.FileDescriptor
      .internalBuildGeneratedFileFrom(descriptorData,
        new com.google.protobuf.Descriptors.FileDescriptor[] {
        }, assigner);
  }
  
  // @@protoc_insertion_point(outer_class_scope)
}