text:
namespace bolero {
namespace proto {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_region_5fserver_5fproto_2eproto();
void protobuf_AssignDesc_region_5fserver_5fproto_2eproto();
void protobuf_ShutdownFile_region_5fserver_5fproto_2eproto();

class HashRequest;
class HashResponse;

enum HashRequest_OpType {
  HashRequest_OpType_HGET = 0,
  HashRequest_OpType_HMGET = 1,
  HashRequest_OpType_HSET = 2,
  HashRequest_OpType_HMSET = 3,
  HashRequest_OpType_HDEL = 4,
  HashRequest_OpType_HMDEL = 5
};
bool HashRequest_OpType_IsValid(int value);
const HashRequest_OpType HashRequest_OpType_OpType_MIN = HashRequest_OpType_HGET;
const HashRequest_OpType HashRequest_OpType_OpType_MAX = HashRequest_OpType_HMDEL;
const int HashRequest_OpType_OpType_ARRAYSIZE = HashRequest_OpType_OpType_MAX + 1;

const ::google::protobuf::EnumDescriptor* HashRequest_OpType_descriptor();
inline const ::std::string& HashRequest_OpType_Name(HashRequest_OpType value) {
  return ::google::protobuf::internal::NameOfEnum(
    HashRequest_OpType_descriptor(), value);
}
inline bool HashRequest_OpType_Parse(
    const ::std::string& name, HashRequest_OpType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HashRequest_OpType>(
    HashRequest_OpType_descriptor(), name, value);
}
enum HashResponse_ErrorCode {
  HashResponse_ErrorCode_OK = 0,
  HashResponse_ErrorCode_THREAD_ERROR = 1,
  HashResponse_ErrorCode_BAD_ARGS = 2,
  HashResponse_ErrorCode_DB_ERROR = 3
};
bool HashResponse_ErrorCode_IsValid(int value);
const HashResponse_ErrorCode HashResponse_ErrorCode_ErrorCode_MIN = HashResponse_ErrorCode_OK;
const HashResponse_ErrorCode HashResponse_ErrorCode_ErrorCode_MAX = HashResponse_ErrorCode_DB_ERROR;
const int HashResponse_ErrorCode_ErrorCode_ARRAYSIZE = HashResponse_ErrorCode_ErrorCode_MAX + 1;

const ::google::protobuf::EnumDescriptor* HashResponse_ErrorCode_descriptor();
inline const ::std::string& HashResponse_ErrorCode_Name(HashResponse_ErrorCode value) {
  return ::google::protobuf::internal::NameOfEnum(
    HashResponse_ErrorCode_descriptor(), value);
}
inline bool HashResponse_ErrorCode_Parse(
    const ::std::string& name, HashResponse_ErrorCode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HashResponse_ErrorCode>(
    HashResponse_ErrorCode_descriptor(), name, value);
}
// ===================================================================

class HashRequest : public ::google::protobuf::Message {
 public:
  HashRequest();
  virtual ~HashRequest();

  HashRequest(const HashRequest& from);

  inline HashRequest& operator=(const HashRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HashRequest& default_instance();

  void Swap(HashRequest* other);

  // implements Message ----------------------------------------------

  HashRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HashRequest& from);
  void MergeFrom(const HashRequest& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef HashRequest_OpType OpType;
  static const OpType HGET = HashRequest_OpType_HGET;
  static const OpType HMGET = HashRequest_OpType_HMGET;
  static const OpType HSET = HashRequest_OpType_HSET;
  static const OpType HMSET = HashRequest_OpType_HMSET;
  static const OpType HDEL = HashRequest_OpType_HDEL;
  static const OpType HMDEL = HashRequest_OpType_HMDEL;
  static inline bool OpType_IsValid(int value) {
    return HashRequest_OpType_IsValid(value);
  }
  static const OpType OpType_MIN =
    HashRequest_OpType_OpType_MIN;
  static const OpType OpType_MAX =
    HashRequest_OpType_OpType_MAX;
  static const int OpType_ARRAYSIZE =
    HashRequest_OpType_OpType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  OpType_descriptor() {
    return HashRequest_OpType_descriptor();
  }
  static inline const ::std::string& OpType_Name(OpType value) {
    return HashRequest_OpType_Name(value);
  }
  static inline bool OpType_Parse(const ::std::string& name,
      OpType* value) {
    return HashRequest_OpType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .bolero.proto.HashRequest.OpType operation = 1;
  inline bool has_operation() const;
  inline void clear_operation();
  static const int kOperationFieldNumber = 1;
  inline ::bolero::proto::HashRequest_OpType operation() const;
  inline void set_operation(::bolero::proto::HashRequest_OpType value);

  // optional bytes user_key = 2;
  inline bool has_user_key() const;
  inline void clear_user_key();
  static const int kUserKeyFieldNumber = 2;
  inline const ::std::string& user_key() const;
  inline void set_user_key(const ::std::string& value);
  inline void set_user_key(const char* value);
  inline void set_user_key(const void* value, size_t size);
  inline ::std::string* mutable_user_key();
  inline ::std::string* release_user_key();
  inline void set_allocated_user_key(::std::string* user_key);

  // optional bytes req_batch = 3;
  inline bool has_req_batch() const;
  inline void clear_req_batch();
  static const int kReqBatchFieldNumber = 3;
  inline const ::std::string& req_batch() const;
  inline void set_req_batch(const ::std::string& value);
  inline void set_req_batch(const char* value);
  inline void set_req_batch(const void* value, size_t size);
  inline ::std::string* mutable_req_batch();
  inline ::std::string* release_req_batch();
  inline void set_allocated_req_batch(::std::string* req_batch);

  // @@protoc_insertion_point(class_scope:bolero.proto.HashRequest)
 private:
  inline void set_has_operation();
  inline void clear_has_operation();
  inline void set_has_user_key();
  inline void clear_has_user_key();
  inline void set_has_req_batch();
  inline void clear_has_req_batch();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* user_key_;
  ::std::string* req_batch_;
  int operation_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_region_5fserver_5fproto_2eproto();
  friend void protobuf_AssignDesc_region_5fserver_5fproto_2eproto();
  friend void protobuf_ShutdownFile_region_5fserver_5fproto_2eproto();

  void InitAsDefaultInstance();
  static HashRequest* default_instance_;
};
// -------------------------------------------------------------------

class HashResponse : public ::google::protobuf::Message {
 public:
  HashResponse();
  virtual ~HashResponse();

  HashResponse(const HashResponse& from);

  inline HashResponse& operator=(const HashResponse& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HashResponse& default_instance();

  void Swap(HashResponse* other);

  // implements Message ----------------------------------------------

  HashResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HashResponse& from);
  void MergeFrom(const HashResponse& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef HashResponse_ErrorCode ErrorCode;
  static const ErrorCode OK = HashResponse_ErrorCode_OK;
  static const ErrorCode THREAD_ERROR = HashResponse_ErrorCode_THREAD_ERROR;
  static const ErrorCode BAD_ARGS = HashResponse_ErrorCode_BAD_ARGS;
  static const ErrorCode DB_ERROR = HashResponse_ErrorCode_DB_ERROR;
  static inline bool ErrorCode_IsValid(int value) {
    return HashResponse_ErrorCode_IsValid(value);
  }
  static const ErrorCode ErrorCode_MIN =
    HashResponse_ErrorCode_ErrorCode_MIN;
  static const ErrorCode ErrorCode_MAX =
    HashResponse_ErrorCode_ErrorCode_MAX;
  static const int ErrorCode_ARRAYSIZE =
    HashResponse_ErrorCode_ErrorCode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  ErrorCode_descriptor() {
    return HashResponse_ErrorCode_descriptor();
  }
  static inline const ::std::string& ErrorCode_Name(ErrorCode value) {
    return HashResponse_ErrorCode_Name(value);
  }
  static inline bool ErrorCode_Parse(const ::std::string& name,
      ErrorCode* value) {
    return HashResponse_ErrorCode_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional bytes user_key = 1;
  inline bool has_user_key() const;
  inline void clear_user_key();
  static const int kUserKeyFieldNumber = 1;
  inline const ::std::string& user_key() const;
  inline void set_user_key(const ::std::string& value);
  inline void set_user_key(const char* value);
  inline void set_user_key(const void* value, size_t size);
  inline ::std::string* mutable_user_key();
  inline ::std::string* release_user_key();
  inline void set_allocated_user_key(::std::string* user_key);

  // optional bytes res_batch = 2;
  inline bool has_res_batch() const;
  inline void clear_res_batch();
  static const int kResBatchFieldNumber = 2;
  inline const ::std::string& res_batch() const;
  inline void set_res_batch(const ::std::string& value);
  inline void set_res_batch(const char* value);
  inline void set_res_batch(const void* value, size_t size);
  inline ::std::string* mutable_res_batch();
  inline ::std::string* release_res_batch();
  inline void set_allocated_res_batch(::std::string* res_batch);

  // optional .bolero.proto.HashResponse.ErrorCode err = 3;
  inline bool has_err() const;
  inline void clear_err();
  static const int kErrFieldNumber = 3;
  inline ::bolero::proto::HashResponse_ErrorCode err() const;
  inline void set_err(::bolero::proto::HashResponse_ErrorCode value);

  // @@protoc_insertion_point(class_scope:bolero.proto.HashResponse)
 private:
  inline void set_has_user_key();
  inline void clear_has_user_key();
  inline void set_has_res_batch();
  inline void clear_has_res_batch();
  inline void set_has_err();
  inline void clear_has_err();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* user_key_;
  ::std::string* res_batch_;
  int err_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_region_5fserver_5fproto_2eproto();
  friend void protobuf_AssignDesc_region_5fserver_5fproto_2eproto();
  friend void protobuf_ShutdownFile_region_5fserver_5fproto_2eproto();

  void InitAsDefaultInstance();
  static HashResponse* default_instance_;
};
// ===================================================================

class RegionServerProto_Stub;

class RegionServerProto : public ::google::protobuf::Service {
 protected:
  // This class should be treated as an abstract interface.
  inline RegionServerProto() {};
 public:
  virtual ~RegionServerProto();

  typedef RegionServerProto_Stub Stub;

  static const ::google::protobuf::ServiceDescriptor* descriptor();

  virtual void hash_op(::google::protobuf::RpcController* controller,
                       const ::bolero::proto::HashRequest* request,
                       ::bolero::proto::HashResponse* response,
                       ::google::protobuf::Closure* done);

  // implements Service ----------------------------------------------

  const ::google::protobuf::ServiceDescriptor* GetDescriptor();
  void CallMethod(const ::google::protobuf::MethodDescriptor* method,
                  ::google::protobuf::RpcController* controller,
                  const ::google::protobuf::Message* request,
                  ::google::protobuf::Message* response,
                  ::google::protobuf::Closure* done);
  const ::google::protobuf::Message& GetRequestPrototype(
    const ::google::protobuf::MethodDescriptor* method) const;
  const ::google::protobuf::Message& GetResponsePrototype(
    const ::google::protobuf::MethodDescriptor* method) const;

 private:
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RegionServerProto);
};

class RegionServerProto_Stub : public RegionServerProto {
 public:
  RegionServerProto_Stub(::google::protobuf::RpcChannel* channel);
  RegionServerProto_Stub(::google::protobuf::RpcChannel* channel,
                   ::google::protobuf::Service::ChannelOwnership ownership);
  ~RegionServerProto_Stub();

  inline ::google::protobuf::RpcChannel* channel() { return channel_; }

  // implements RegionServerProto ------------------------------------------

  void hash_op(::google::protobuf::RpcController* controller,
                       const ::bolero::proto::HashRequest* request,
                       ::bolero::proto::HashResponse* response,
                       ::google::protobuf::Closure* done);
 private:
  ::google::protobuf::RpcChannel* channel_;
  bool owns_channel_;
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RegionServerProto_Stub);
};

// ===================================================================

// ===================================================================

// HashRequest

// optional .bolero.proto.HashRequest.OpType operation = 1;
inline bool HashRequest::has_operation() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HashRequest::set_has_operation() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HashRequest::clear_has_operation() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HashRequest::clear_operation() {
  operation_ = 0;
  clear_has_operation();
}
inline ::bolero::proto::HashRequest_OpType HashRequest::operation() const {
  return static_cast< ::bolero::proto::HashRequest_OpType >(operation_);
}
inline void HashRequest::set_operation(::bolero::proto::HashRequest_OpType value) {
  assert(::bolero::proto::HashRequest_OpType_IsValid(value));
  set_has_operation();
  operation_ = value;
}

// optional bytes user_key = 2;
inline bool HashRequest::has_user_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HashRequest::set_has_user_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HashRequest::clear_has_user_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HashRequest::clear_user_key() {
  if (user_key_ != &::google::protobuf::internal::kEmptyString) {
    user_key_->clear();
  }
  clear_has_user_key();
}
inline const ::std::string& HashRequest::user_key() const {
  return *user_key_;
}
inline void HashRequest::set_user_key(const ::std::string& value) {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  user_key_->assign(value);
}
inline void HashRequest::set_user_key(const char* value) {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  user_key_->assign(value);
}
inline void HashRequest::set_user_key(const void* value, size_t size) {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  user_key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HashRequest::mutable_user_key() {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  return user_key_;
}
inline ::std::string* HashRequest::release_user_key() {
  clear_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_key_;
    user_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HashRequest::set_allocated_user_key(::std::string* user_key) {
  if (user_key_ != &::google::protobuf::internal::kEmptyString) {
    delete user_key_;
  }
  if (user_key) {
    set_has_user_key();
    user_key_ = user_key;
  } else {
    clear_has_user_key();
    user_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes req_batch = 3;
inline bool HashRequest::has_req_batch() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HashRequest::set_has_req_batch() {
  _has_bits_[0] |= 0x00000004u;
}
inline void HashRequest::clear_has_req_batch() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void HashRequest::clear_req_batch() {
  if (req_batch_ != &::google::protobuf::internal::kEmptyString) {
    req_batch_->clear();
  }
  clear_has_req_batch();
}
inline const ::std::string& HashRequest::req_batch() const {
  return *req_batch_;
}
inline void HashRequest::set_req_batch(const ::std::string& value) {
  set_has_req_batch();
  if (req_batch_ == &::google::protobuf::internal::kEmptyString) {
    req_batch_ = new ::std::string;
  }
  req_batch_->assign(value);
}
inline void HashRequest::set_req_batch(const char* value) {
  set_has_req_batch();
  if (req_batch_ == &::google::protobuf::internal::kEmptyString) {
    req_batch_ = new ::std::string;
  }
  req_batch_->assign(value);
}
inline void HashRequest::set_req_batch(const void* value, size_t size) {
  set_has_req_batch();
  if (req_batch_ == &::google::protobuf::internal::kEmptyString) {
    req_batch_ = new ::std::string;
  }
  req_batch_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HashRequest::mutable_req_batch() {
  set_has_req_batch();
  if (req_batch_ == &::google::protobuf::internal::kEmptyString) {
    req_batch_ = new ::std::string;
  }
  return req_batch_;
}
inline ::std::string* HashRequest::release_req_batch() {
  clear_has_req_batch();
  if (req_batch_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = req_batch_;
    req_batch_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HashRequest::set_allocated_req_batch(::std::string* req_batch) {
  if (req_batch_ != &::google::protobuf::internal::kEmptyString) {
    delete req_batch_;
  }
  if (req_batch) {
    set_has_req_batch();
    req_batch_ = req_batch;
  } else {
    clear_has_req_batch();
    req_batch_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// HashResponse

// optional bytes user_key = 1;
inline bool HashResponse::has_user_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HashResponse::set_has_user_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HashResponse::clear_has_user_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HashResponse::clear_user_key() {
  if (user_key_ != &::google::protobuf::internal::kEmptyString) {
    user_key_->clear();
  }
  clear_has_user_key();
}
inline const ::std::string& HashResponse::user_key() const {
  return *user_key_;
}
inline void HashResponse::set_user_key(const ::std::string& value) {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  user_key_->assign(value);
}
inline void HashResponse::set_user_key(const char* value) {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  user_key_->assign(value);
}
inline void HashResponse::set_user_key(const void* value, size_t size) {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  user_key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HashResponse::mutable_user_key() {
  set_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    user_key_ = new ::std::string;
  }
  return user_key_;
}
inline ::std::string* HashResponse::release_user_key() {
  clear_has_user_key();
  if (user_key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_key_;
    user_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HashResponse::set_allocated_user_key(::std::string* user_key) {
  if (user_key_ != &::google::protobuf::internal::kEmptyString) {
    delete user_key_;
  }
  if (user_key) {
    set_has_user_key();
    user_key_ = user_key;
  } else {
    clear_has_user_key();
    user_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes res_batch = 2;
inline bool HashResponse::has_res_batch() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HashResponse::set_has_res_batch() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HashResponse::clear_has_res_batch() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HashResponse::clear_res_batch() {
  if (res_batch_ != &::google::protobuf::internal::kEmptyString) {
    res_batch_->clear();
  }
  clear_has_res_batch();
}
inline const ::std::string& HashResponse::res_batch() const {
  return *res_batch_;
}
inline void HashResponse::set_res_batch(const ::std::string& value) {
  set_has_res_batch();
  if (res_batch_ == &::google::protobuf::internal::kEmptyString) {
    res_batch_ = new ::std::string;
  }
  res_batch_->assign(value);
}
inline void HashResponse::set_res_batch(const char* value) {
  set_has_res_batch();
  if (res_batch_ == &::google::protobuf::internal::kEmptyString) {
    res_batch_ = new ::std::string;
  }
  res_batch_->assign(value);
}
inline void HashResponse::set_res_batch(const void* value, size_t size) {
  set_has_res_batch();
  if (res_batch_ == &::google::protobuf::internal::kEmptyString) {
    res_batch_ = new ::std::string;
  }
  res_batch_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HashResponse::mutable_res_batch() {
  set_has_res_batch();
  if (res_batch_ == &::google::protobuf::internal::kEmptyString) {
    res_batch_ = new ::std::string;
  }
  return res_batch_;
}
inline ::std::string* HashResponse::release_res_batch() {
  clear_has_res_batch();
  if (res_batch_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = res_batch_;
    res_batch_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HashResponse::set_allocated_res_batch(::std::string* res_batch) {
  if (res_batch_ != &::google::protobuf::internal::kEmptyString) {
    delete res_batch_;
  }
  if (res_batch) {
    set_has_res_batch();
    res_batch_ = res_batch;
  } else {
    clear_has_res_batch();
    res_batch_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .bolero.proto.HashResponse.ErrorCode err = 3;
inline bool HashResponse::has_err() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HashResponse::set_has_err() {
  _has_bits_[0] |= 0x00000004u;
}
inline void HashResponse::clear_has_err() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void HashResponse::clear_err() {
  err_ = 0;
  clear_has_err();
}
inline ::bolero::proto::HashResponse_ErrorCode HashResponse::err() const {
  return static_cast< ::bolero::proto::HashResponse_ErrorCode >(err_);
}
inline void HashResponse::set_err(::bolero::proto::HashResponse_ErrorCode value) {
  assert(::bolero::proto::HashResponse_ErrorCode_IsValid(value));
  set_has_err();
  err_ = value;
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace bolero

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::bolero::proto::HashRequest_OpType>() {
  return ::bolero::proto::HashRequest_OpType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::bolero::proto::HashResponse_ErrorCode>() {
  return ::bolero::proto::HashResponse_ErrorCode_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_region_5fserver_5fproto_2eproto__INCLUDED


text:
Should You Buy a Nintendo Switch Lite if You Already Own a Switch?
Death and the Maiden is Next Up in the Houston Equity Festival
Dividing the Estate at the Alley a Smart, Funny Crowd-Pleaser
D. L. Groover
D. L. Groover | October 14, 2011 | 2:30pm
Our American Chekov, elegiac and wistful Horton Foote (Pulitzer Prize-winning Young Man From Atlanta, The Trip to Bountiful, Oscar-winning screenplay adaptations of To Kill a Mockingbird and Tender Mercies) isn't known for comedy, but this is the one: a smart and funny crowd-pleaser.
The execution:
Matriarch Stella (the grand Elizabeth Ashley), feeble and living on memories, senses there's something in the air, and it's not the scent of magnolias. It's the stench of progress, and she's at a loss how to deal with it.
The great family house, lovingly appointed and detailed by designer Jeff Cowie and infused in sunny Texas light by Rita Rui, no longer stands proud in town but is encroached upon by noisy highways and fast food joints. Times are changing, fast. The acres of prime farm land can't command high prices in today's dwindling market, even if Stella would want to sell any of it, which she definitely does not. She wants to share, not divide. Money is tight, and getting tighter. Her greedy family wants to divide. Now.
So they gather: no-count son Lewis (James Black), oblivious widowed daughter Lucille (Penny Fuller), and her son, Son (Devon Abner), who manages the estate and doles out loans when Stella's in a forgiving mood. From Houston comes married daughter Mary Jo (Hallie Foote, the playwright's daughter), a whirlwind of stiff knees, frozen smiles, and flailing arms.
One of Foote's most clearly, and wickedly, defined portraits, Mary Jo loves her debt-ridden lifestyle and sees no good reason why it shouldn't continue forever. She wants to get the maximum out of the precarious situation. She wants whatever can be salvaged. Naturally, what she assumes to be a treasure trove, turns out, with typically Foote flourish, to be worth not much at all, once taxes are taken care of, loans refinanced, mortgages paid. Foote transforms sentimental melodrama into genuine laughs.
In this old-fashioned, well-made play (directed with self-effacement by Michael Wilson, who staged the premiere and then its Broadway revival, with pretty much the same cast as here at the Alley), there are no villains, just mismatched priorities, minor peccadilloes, and sweet memories of more tender times. The Gordons are rapacious and out for money, no doubt about it, but they're so sweet at telling each other about their deceptions and outright greed, you can't help but smile and laugh at them. The Hubbards from The Little Foxes have been sprinkled with pixie dust.
At two hours, the slight play begins to repeat, but when the tenacious Gordons agree to a solution to their money problems, all our smiles quickly return. The actors lap up Foote's warm sentiments like the richest cream in town, and we're left in a very good mood.
The play runs through October 30 at the Alley Theatre, 615 Texas, 713-228-8421.
D.L. Groover has contributed to countless reputable publications including the Houston Press since 2003. His theater criticism has earned him a national award from the Association of Alternative Newsmedia (AAN) as well as three statewide Lone Star Press Awards for the same. He's co-author of the irreverent appreciation, Skeletons from the Opera Closet (St. Martin's Press), now in its fourth printing.
Style Suffocates Substance In Woyzeck
The Possible Video Game Influences of Stranger Things
Best Bets This Weekend in Houston: Dog Show, Moor Fest and...
Comic Erica Rhodes Set to Bring The Funny, Both on NBC...

redpajama_set_name: RedPajamaCommonCrawl


text:
20 Years of TAVI
Wednesday 13th April 2022
This year marks 20 years since the first clinical TAVI procedure was performed by Alain Cribbier, and to celebrate this historic milestone, Heart Valve Voice will be sharing 20 TAVI stories throughout the year, one for every year this pioneering procedure has been performed.
Alain Cribier's first clinical TAVI was performed on 16 April 2002 on a 57-year-old man suffering from heart failure and poor left ventricular ejection. Faced with limited options and the patient's fate if nothing was done, Cribier performed a TAVI. Cribier later said, "it is moving to remember the fierce opposition of experts towards this "totally unrealistic and stupid idea" that "would never work."
Five years later, Gladys Adam's received the first UK TAVI, performed by Jan Kovac. The procedure saved her life, and Gladys lived for nine years, spending precious time with her family, welcoming great-grandchildren into the world and creating memories that live with her family to this day.
What was then viewed as a revolutionary method to treat heart valve disease is now a routine procedure, which is seen to be one of the most significant advances in cardiac disease therapy over the last 30 years.
Our 20 for 20 campaign will be a celebration of thousands of stories of how TAVI has saved lives and look at the incredible experiences they have been afforded by this procedure. The campaign will start tomorrow with Mary's story, and run throughout the year.
Heart Valve Voice Executive Director Wil Woan said: "TAVI has come a long way in the 20 years since it was first performed. Now, with the pressures of growing waiting lists and an increasing unmet need, it is vital we utilise all treatment options to ensure we can treat more patients and save lives."
Follow us on Facebook, Twitter, Instagram and LinkedIn to read the incredible stories of patients and their families who have benefited from this procedure.


Welcome to the Carroll County Zoning Administration Home Page, your portal to information about zoning topics and the Carroll County Code of Public Local Laws and Ordinances as it pertains to zoning.
Section 158 of the Carroll County Code of Public Local Laws and Ordinances is the basis for all information about County Zoning regulation. This portion of the County Code is available online in a user-friendly format for your own perusal. The second key element of County zoning is the maps which are maintained in Zoning Administration in room 111 of the County Office Building. Many of the most frequently asked questions the public has about zoning are addressed on this web site; however, we encourage your questions by telephone or e-mail to jvoight@carrollcountymd.gov.
For the staff of Zoning Administration to be of help to you, or for you to find some of your own answers pertaining to zoning on a piece of property, there are three essential numbers that you should have to begin your fact-finding mission: Tax Map #, Block #, and Parcel #. This information is listed on your annual property tax bill and is also available at the State Department of Assessments web site.
Zoning Administration has two distinct areas of operation, enforcement and the dissemination of information. All Zoning Administration staff are involved in both tasks. The enforcement side of OZA involves close cooperation with the Department of the County Attorney. The informational side works closely with the Department of Planning and its associate Bureaus and with the Bureau of Permits and Inspections. The Zoning Administrator is a cabinet-level appointment; Jay Voight is the current Zoning Administrator.
Zoning Administration is responsible for the daily interpretation of the zoning laws. It is our intention to provide consistent interpretations and non-prejudicial decisions. While every jurisdiction's zoning code attempts to be crystal clear on every conceivable application, the reality is that we encounter new uses and questions never thought imaginable daily in Zoning Administration.
Zoning Administration recognizes that many citizens making inquiries of this office may be basing decisions which commit tens or hundreds of thousands of dollars depending on our response. We owe it to our customers to provide accurate information. While Zoning Administration tries to be quickly responsive to questions asked by the public and businesses, please bear in mind that an immediate response may not be wise or possible in all circumstances. Some questions require property research and in our on-going effort to be consistent in athe pplication of the laws we may have to refer to similar cases from years past. In Zoning, even the simplest of questions sometimes require a lengthy response to be accurate and complete.


Most accurate, nano-precise, religion-neutral & the only perfect religion in the world is Astangayoga of Maharsi Patanjali.
Religion is a means to an end. Religion is never the end in itself. Communities which emphasize religion as the end of all pursuits, are invariably destroyed beyond recognition. That is the reason why Islam & Christianity are today standing at cross-roads, loaded with a plethora of problems pertaining to grave issues of survival and sustenance. The moment religion degenerates into obscurantism, it tends to be status-quoist, then a deadly instrument in hands of oppressors.
It is Adhyatma that is supposed to be the ultimate abode of all religions. Once we focus on Adhyatma as everyone's ultimate goal, question arises as to which path leads to the attainment of that goal in the quickest possible time with minimun efforts / hardships. In other words, how to improve the input / output ratio of this spiritual, cosmic journey.
Eight limbs of Astangayoga enunciated by Maharsi Patanjali is the surest, shortest and the quickest way to be attained to the Supreme Existence. Quite mystically, those eight limbs are inevitable as well as mandatory for all human beings irrespective of being a Hindu, Jew, Hispanic, Muslim or Christian if genuinely interested in the business of attaining salvation through emancipation. Maharsi Patanjali is the greatest name when it comes to the world of Yoga. He refined religion so much so that it metamorphosed into pure, sacrosanct Laws of Emancipation From Maya !!
That too, absolutely devoid of personal beliefs whatsoever. Like a mathematical equation, invariably it works in the direction of 2+2=4 !! It does not really mandate, believe in this or believe in that. Just experience it yourself by following the laws in letter and spirit. There is no experimentation too because every failure in pursuit of the Yoga is an invaluable experience and experience in one's inner being is all that matters. Rest is all redundant. Since Yoga is existential, only the resolve to undergo mystical experiences is all that is required. Faith is external and superficial while pursuit of Astangayoga is deeply and intensely internal. That may be the reason that it looks arduous to some and impossible to others.
All practitioners of religions follow one or the other limb, perfectly or imperfectly as narrated in their religious texts. Astangayoga of Maharsi Patanjali is the only, I repeat the only treatise which is complete in all respects and details bare minimum pursuits required for the ultimate deliverance in the briefest possible time for the one who strives assiduously in the most rational, scientific manner. In all other paths, rationalism is fuzzied or muddied, be it Islam or Christianity.
Hence, it is a confusion-, delusion-galores accompanied by repeated downfalls and in majority of instances, utter failure followed by the abandonment of goals.Quite brilliantly, Maharsi Patanjali left it to the ascetic to undertake modifications within the framework of eight limbs and visualise Param Brahma the way he / she wishes to. All religions viz. Hinduism, Islam, Christianity are far inferior to this spiritual path of Astangayoga. Non-Hindus should have absolutely no objection or reluctance in adopting Astangayoga of Maharsi Patanjali. Rather, it is pertinent to question as to how it has escaped their serious attention all these years !!Maharsi Patanjali is certainly the greatest scientist known to mankind. He is such a gigantic phenomenon that instead of awarding a hundred Nobel Prizes to him posthumously, Nobel Prize itself should be named after him.
ASTANGAYOGA IS MOST RATIONAL, SCIENTIFIC AND FAITH-NEUTRAL.This is the most accurate and precise 'Religion' known so far as if it has come out of the most advanced Adhyatmika laboratory in the world ! Hindu-s may shun Hinduism, Muslims may shun Islam and Christians may shun Christianity to adopt Astangayoga as the only universal path leading to the Ultimate.
And there is absolutely no other choice if your are serious about your ultimate deliverance from the cosmic cycles of birth and death ! How can Param Brahma with the supreme consciousness under His ambit, allow so many directionless religions to be pursued to be attained to Him ? FROM BASE CAMP TO THE SUMMIT OF MOUNT EVEREST, PATH IS UNI-DIRECTIONAL i.e. UPWARD WHILE YOU MAY WANDER IN ANY MANNER / DIRECTION FROM ANY CORNER OF THE WORLD TILL YOU REACH THE BASE CAMP !! Of Astangayoga of Maharsi Patanjali.
Hinduism, Islam or Christianity at best, prepare you to undertake the real holy pursuit of Astangayoga in true spirit from the Base Camp and do nothing more than that.
PS: These are excerpts from my yet unpublished title YOGA-DARSANA OF MAHARSI PATANJALI. When Christian Pastors stand up and declare, Jesus is the only way to liberation and Hinduism is so shallow, baseless…. it becomes imperative to counter that effectively. Such articles provide glimpses of Hinduism so deep and intense, not easy to deal with that so superficially. I hope, it will be read and accepted with that perspective in mind.


Author of How Do Animals Stay Alive?
and Tammy Jnes Margie Burton Cathy French is currently considered a "single author." If one or more works are by a distinct, homonymous authors, go ahead and split the author.
and Tammy Jnes Margie Burton Cathy French is composed of 1 name.


text:
Hands-on with Windows 10X via the development tools emulator (video)
by Cody Carson
Email Twitter: @hologei Feb 17th, 2020 inVideos
Windows 10X is the operating system Microsoft has been designing for next-generation devices. People who've been following Microsoft news are probably already familiar with the concept, as Microsoft has demoed the software before running on next-generation devices like the upcoming Surface Neo. Now, they've officially released development tools that allow us to take a look at this software running live on an emulator. This software is still very early in development, so it doesn't necessarily reflect how Windows 10X will look by the time it's launched. Also, because I'm running this in an emulator, the performance is quite choppy. Microsoft released this emulator image of Windows 10X for developers who want to begin making software experiences optimized for dual-screen devices. With that said, let's take a look at what's new.
Windows 10x start menu
The UI is split in two because Windows 10X is currently designed exclusively for dual-screen handheld devices. At first, it might not look a whole lot like Windows 10, but if we swipe up on the taskbar at the bottom, the start menu will appear. This Start menu doesn't look a whole lot like the Start menu we're familiar with; in fact, it seems a whole lot more like the ChromeOS app launcher to me. There's a search bar at the top, an app list, and an area for recent files and activities. From here, we also get a glimpse at the new puffy-looking iconography Microsoft has been working on. Action center has been renamed and completely redesigned in Windows 10X.
Windows 10x quick settings
The new quick settings menu consolidates the different interface controls on the right side of the taskbar. Volume and brightness controls are at the top, quick settings in the middle, which you can toggle or expand, and shortcuts at the very bottom. Once again, this is very much like ChromeOS. It would be great if this interface could make its way to Windows 10 for desktop, as it's much better than the unintelligible mess of applets that's on the taskbar right now.
All around, the entire UI is designed from the ground up in a single consistent design language, much unlike the inconsistent UI found on Windows 10 for desktop. Windows 10X's UI is full of round corners, visually appealing padding and proportions, shadows, transparency, and fluid animations.
Gestures and Interaction
The start menu can be opened by swiping up on either of the two displays. When you choose an app, it will open on the display you selected it on. Similar to Windows 10 for desktop, all the open apps will display on the taskbar to the right of the start button. The gestures in Windows 10X are very similar to those in Windows 8 and Windows 10. A swipe from the left or rightmost edges will take you back into the task view app switcher, and swiping down from the top will grab the app and allow you to snap it left, right, or center. If we snap an app that isn't optimized for Windows 10X in the middle, it will simply stretch across both screens and get cut in half. This is why Microsoft wants developers to optimize their apps for Windows 10X. Apps like these will need to be optimized to show specific content on each screen. Remember that Microsoft intends this software be used on dual-screen devices. Just like having a dual-monitors, the intended use case is two have two apps running simultaneously on each display.
Windows 10x task view
Here in the emulator, we can simulate using this device in multiple different orientations. You can imagine the various use-case scenarios for devices like this with these tools. Propped up in a sort of laptop-like position, we can enable 'compose mode' in the Quick Settings area to dock a keyboard and trackpad to the bottom screen. Now, this Windows 10X device more closely resembles a traditional laptop, with a single screen at the top, and an input area at the bottom. This keyboard is a little different than the standard touch keyboard because it will stay open on the bottom screen and not push your apps around the screen until you exit compose mode.
As for the apps themselves, it looks like Microsoft hasn't done much work themselves optimizing them for dual-screen devices. Most of them are the exact same apps found on any other Windows device. Windows 10X will be able to run most of the same apps available on any other Windows 10 PC. This includes Web apps, native UWP apps, and even legacy Win32 Apps from outside of the Microsoft Store. Of course, native UWP and web apps will run the best on Windows 10X, but Win32 app support will be what sets Windows 10X apart from other mobile operating systems.
Legacy app support has it's drawbacks, though. Legacy windows apps and components are known for their notoriously poor power and performance optimization on mobile devices, so the Windows 10X OS has been stripped of all that.
In Windows 10X, all apps will run in their own little areas of the operating system known as 'Containers'. Win32 apps in Windows 10X will all run in the new 'Win32 Container', where they will have access to the Win32 components they will need to function separate from the host operating system. To ensure maximum compatibility, these Win32 components will be available to legacy apps whether or not the user will ever be able to interact with all of them. For example, Windows 10X is doing away with that hideous taskbar system tray. Despite this, the Win32 container provides Win32 apps with what they need to run their system tray applets, so apps don't get confused and crash. However, because there is no system tray in the Windows 10X shell, users will not be able to interact with these features. Because of this, developers will have to optimize their apps not to rely on the system tray for critical user interface functionality in Windows 10X.
For our convenience, Microsoft included Notepad— a Win32 app— with this image of Windows 10X. As you can see, it's the same notepad app we're familiar with on Windows 10. If we go to save or open a file, the legacy Win32 File explorer will appear. Again, this is an example of the Win32 container providing legacy apps with the components they need to ensure compatibility. The Win32 File explorer is not available anywhere else in Windows 10X. If we open the file explorer listed in the Start menu, the old UWP file explorer app from Windows 10 Mobile will appear instead.
Déjà vu, Windows 10
Though Microsoft is committed to the integration of Win32 apps in Windows 10X, it's difficult not to compare this development to the early days of Windows 8. Microsoft was designing a brand new software experience for a new generation of personal computing devices, even creating their own hardware to demonstrate their vision. Sound familiar? Microsoft is developing Windows 10X for the exact same reason they developed Windows 8. We all know the unfortunate fate that it met the instant it fell into consumers' hands. It was a real shame. The Metro user interface was much more fluid and subjectively more beautiful than what it was trying to replace, but looks aren't everything. Has Microsoft done enough to prevent Windows 10X from failing like Windows 8?
Windows 8 on Surface RT
As pre-release software, Microsoft wants to hear feedback from developers about their thoughts on app experiences in Windows 10X. If you know what you're doing, you can read up on the developer docs for this software and begin testing your apps on this OS.
Tags: Emulator | Windows 10 | Windows 10X | Windows Insider


Following a stroke Lorna was no longer able to use her normal walking stick but struggled to learn how to use anything else.
Lorna is an 84 year old lady who recently suffered a stroke which has affected her mobility, memory and capacity for new learning. Lorna walks with a stick because of a previous mini stroke which has left her with poor balance. Lorna lives alone in a two bedroom ground floor flat and was independent with personal care, preparing hot drinks, ready meals and snacks Mondays to Fridays. She has assistance with domestic activities and spends Saturdays and Sundays with her daughter and family in their home. Lorna accesses her local community independently and enjoys community life, as she has lived there for a number of years. As a result of this stroke Lorna's balance has significantly deteriorated and she is at risk of falls. Her existing walking stick is no longer meeting her needs. Lorna's goal is to continue to walk independently with a piece of walking equipment. Due to poor memory she is finding it difficult to learn to use alternative walking equipment which will ensure her safety and independence.
Lorna has been prescribed a tripod walking stick. This offers her more support whilst walking or standing still. Lorna already knows the basic principle of using a walking stick so it will be easier for her to learn how to use this new tripod.
Lorna's quality of life is maintained as she is able to negotiate her environment safely and independently with the tripod walking stick. She can still access the community with support, due to her memory impairment, and continues to enjoy her usual weekend visits to her daughter's home as before.


text:
Q: If statement on PHP (inserting data) I have to register a costumer and/or a manager into the database. I just have one form for the information, the only difference is the ID number (valid for managers). The costumers should leave this form blank. I was trying to save the data just using an if statement (If it is blank, save the information in costumer table. If it is not, save in manager). I have not seen this on my classes so I am not sure if it is possible.
Is it possible to use an if statement to insert data? What I mean is, I have two different tables but just one form (one of the forms will make the difference for which table the data will be saved.
The data in the manager table is ok, but when I try to insert data into costumer it is not working. I am not sure that I can use this.
if($_SESSION['id'] != null){
  $sql = "INSERT INTO manager (id,magname,maglname,maguser,magpass) VALUES (?, ?, ?, ?, ?);";
  $sth = $DBH->prepare($sql);
  $sth->bindParam(1, $_SESSION['id'], PDO::PARAM_INT);
  $sth->bindParam(2, $_SESSION['firstname'], PDO::PARAM_INT);
  $sth->bindParam(3, $_SESSION['secondname'], PDO::PARAM_INT);
  $sth->bindParam(4, $_SESSION['username'], PDO::PARAM_INT);
  $sth->bindParam(5, $_SESSION['password'], PDO::PARAM_INT);
  $sth->execute();
}

if(empty($_SESSION['id']){
  $sql = "INSERT INTO costumer (fisrtname,lastname,username,password) VALUES (?, ?, ?, ?);";
  $sth = $DBH->prepare($sql);
  $sth->bindParam(1, $_SESSION['firstname'], PDO::PARAM_INT);
  $sth->bindParam(2, $_SESSION['lastname'], PDO::PARAM_INT);
  $sth->bindParam(3, $_SESSION['username'], PDO::PARAM_INT);
  $sth->bindParam(4, $_SESSION['password'], PDO::PARAM_INT);
  $sth->execute();
}

A: you can do it directly through following code
   if(isset($_SESSION['id']))
            $sql = "INSERT INTO `manager`..."
   else
            $sql = "INSERT INTO `customer`..."

A: or something like this
   if(!empty($_SESSION['id']))
          {  $sql = "INSERT INTO `manager`..."}
   else
          {  $sql = "INSERT INTO `customer`..."}

redpajama_set_name: RedPajamaStackExchange