// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: config.proto
// Protobuf C++ Version: 7.35.1

#ifndef config_2eproto_2epb_2eh
#define config_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7035001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_config_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_config_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_config_2eproto;
}  // extern "C"
namespace nsjail {
enum LogLevel : int;
extern const uint32_t LogLevel_internal_data_[];
enum Mode : int;
extern const uint32_t Mode_internal_data_[];
enum RLimit : int;
extern const uint32_t RLimit_internal_data_[];
class Exe;
struct ExeGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ExeGlobalsTypeInternal Exe_globals_;
extern const ::google::protobuf::internal::ClassDataFull Exe_class_data_;
#else
extern const ExeGlobalsTypeInternal Exe_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class IdMap;
struct IdMapGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern IdMapGlobalsTypeInternal IdMap_globals_;
extern const ::google::protobuf::internal::ClassDataFull IdMap_class_data_;
#else
extern const IdMapGlobalsTypeInternal IdMap_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class MountPt;
struct MountPtGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern MountPtGlobalsTypeInternal MountPt_globals_;
extern const ::google::protobuf::internal::ClassDataFull MountPt_class_data_;
#else
extern const MountPtGlobalsTypeInternal MountPt_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NsJailConfig;
struct NsJailConfigGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NsJailConfigGlobalsTypeInternal NsJailConfig_globals_;
extern const ::google::protobuf::internal::ClassDataFull NsJailConfig_class_data_;
#else
extern const NsJailConfigGlobalsTypeInternal NsJailConfig_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NsJailConfig_UserNet;
struct NsJailConfig_UserNetGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NsJailConfig_UserNetGlobalsTypeInternal NsJailConfig_UserNet_globals_;
extern const ::google::protobuf::internal::ClassDataFull NsJailConfig_UserNet_class_data_;
#else
extern const NsJailConfig_UserNetGlobalsTypeInternal NsJailConfig_UserNet_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace nsjail
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::nsjail::LogLevel_internal_data_>
    internal::EnumTraitsImpl::value<::nsjail::LogLevel>;
template <>
internal::EnumTraitsT<::nsjail::Mode_internal_data_>
    internal::EnumTraitsImpl::value<::nsjail::Mode>;
template <>
internal::EnumTraitsT<::nsjail::RLimit_internal_data_>
    internal::EnumTraitsImpl::value<::nsjail::RLimit>;
}  // namespace protobuf
}  // namespace google

namespace nsjail {
enum Mode : int {
  LISTEN = 0,
  ONCE = 1,
  RERUN = 2,
  EXECVE = 3,
};

extern const uint32_t Mode_internal_data_[];
inline constexpr Mode Mode_MIN =
    static_cast<Mode>(0);
inline constexpr Mode Mode_MAX =
    static_cast<Mode>(3);
[[nodiscard]] inline bool Mode_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int Mode_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Mode_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Mode) {
  return Mode_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Mode_Name(T value) {
  static_assert(::std::is_same<T, Mode>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Mode_Name().");
  return Mode_Name(static_cast<Mode>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Mode_Name(Mode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Mode_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Mode_Parse(
    ::absl::string_view name, Mode* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Mode>(Mode_descriptor(), name,
                                           value);
}
enum LogLevel : int {
  DEBUG = 0,
  INFO = 1,
  WARNING = 2,
  ERROR = 3,
  FATAL = 4,
};

extern const uint32_t LogLevel_internal_data_[];
inline constexpr LogLevel LogLevel_MIN =
    static_cast<LogLevel>(0);
inline constexpr LogLevel LogLevel_MAX =
    static_cast<LogLevel>(4);
[[nodiscard]] inline bool LogLevel_IsValid(int value) {
  return 0 <= value && value <= 4;
}
inline constexpr int LogLevel_ARRAYSIZE = 4 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
LogLevel_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(LogLevel) {
  return LogLevel_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& LogLevel_Name(T value) {
  static_assert(::std::is_same<T, LogLevel>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to LogLevel_Name().");
  return LogLevel_Name(static_cast<LogLevel>(value));
}
template <>
[[nodiscard]] inline const ::std::string& LogLevel_Name(LogLevel value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LogLevel_descriptor, 0, 4>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool LogLevel_Parse(
    ::absl::string_view name, LogLevel* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<LogLevel>(LogLevel_descriptor(), name,
                                           value);
}
enum RLimit : int {
  VALUE = 0,
  SOFT = 1,
  HARD = 2,
  INF = 3,
};

extern const uint32_t RLimit_internal_data_[];
inline constexpr RLimit RLimit_MIN =
    static_cast<RLimit>(0);
inline constexpr RLimit RLimit_MAX =
    static_cast<RLimit>(3);
[[nodiscard]] inline bool RLimit_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int RLimit_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
RLimit_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(RLimit) {
  return RLimit_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& RLimit_Name(T value) {
  static_assert(::std::is_same<T, RLimit>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to RLimit_Name().");
  return RLimit_Name(static_cast<RLimit>(value));
}
template <>
[[nodiscard]] inline const ::std::string& RLimit_Name(RLimit value) {
  return ::google::protobuf::internal::NameOfDenseEnum<RLimit_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool RLimit_Parse(
    ::absl::string_view name, RLimit* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<RLimit>(RLimit_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NsJailConfig_UserNet final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:nsjail.NsJailConfig.UserNet) */ {
 public:
  inline NsJailConfig_UserNet() : NsJailConfig_UserNet(nullptr) {}
  ~NsJailConfig_UserNet() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(NsJailConfig_UserNet* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(NsJailConfig_UserNet));
  }
#endif

  template <typename = void>
  explicit constexpr NsJailConfig_UserNet(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline NsJailConfig_UserNet(const NsJailConfig_UserNet& from) : NsJailConfig_UserNet(nullptr, from) {}
  inline NsJailConfig_UserNet(NsJailConfig_UserNet&& from) noexcept : NsJailConfig_UserNet(nullptr, ::std::move(from)) {}
  inline NsJailConfig_UserNet& operator=(const NsJailConfig_UserNet& from) {
    CopyFrom(from);
    return *this;
  }
  inline NsJailConfig_UserNet& operator=(NsJailConfig_UserNet&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const NsJailConfig_UserNet& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NsJailConfig_UserNet>(&NsJailConfig_UserNet_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(NsJailConfig_UserNet& a, NsJailConfig_UserNet& b) { a.Swap(&b); }
  inline void Swap(NsJailConfig_UserNet* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NsJailConfig_UserNet* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] NsJailConfig_UserNet* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<NsJailConfig_UserNet>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NsJailConfig_UserNet& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const NsJailConfig_UserNet& from) { NsJailConfig_UserNet::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(NsJailConfig_UserNet* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "nsjail.NsJailConfig.UserNet"; }

  explicit NsJailConfig_UserNet(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NsJailConfig_UserNet(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NsJailConfig_UserNet& from);
  NsJailConfig_UserNet(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NsJailConfig_UserNet&& from) noexcept
      : NsJailConfig_UserNet(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kIpFieldNumber = 2,
    kMaskFieldNumber = 3,
    kGwFieldNumber = 4,
    kIp6FieldNumber = 5,
    kMask6FieldNumber = 6,
    kGw6FieldNumber = 7,
    kNsIfaceFieldNumber = 8,
    kTcpPortsFieldNumber = 9,
    kUdpPortsFieldNumber = 10,
    kDnsForwardFieldNumber = 13,
    kEnableFieldNumber = 1,
    kEnableIp4DhcpFieldNumber = 11,
    kEnableDnsFieldNumber = 12,
    kNoMapGwFieldNumber = 17,
    kEnableIp6DhcpFieldNumber = 18,
    kEnableIp6RaFieldNumber = 19,
    kEnableTcpFieldNumber = 14,
    kEnableUdpFieldNumber = 15,
    kEnableIcmpFieldNumber = 16,
  };
  // optional string ip = 2 [default = "10.255.255.2"];
  [[nodiscard]] bool has_ip()
      const;
  void clear_ip() ;
  [[nodiscard]] const ::std::string& ip() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_ip(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_ip();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ip();
  void set_allocated_ip(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_ip() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_ip();

  public:
  // optional string mask = 3 [default = "255.255.255.0"];
  [[nodiscard]] bool has_mask()
      const;
  void clear_mask() ;
  [[nodiscard]] const ::std::string& mask() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_mask(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_mask();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_mask();
  void set_allocated_mask(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_mask() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_mask(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_mask();

  public:
  // optional string gw = 4 [default = "10.255.255.1"];
  [[nodiscard]] bool has_gw()
      const;
  void clear_gw() ;
  [[nodiscard]] const ::std::string& gw() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_gw(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_gw();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_gw();
  void set_allocated_gw(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_gw() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_gw(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_gw();

  public:
  // optional string ip6 = 5 [default = "fc00::2"];
  [[nodiscard]] bool has_ip6()
      const;
  void clear_ip6() ;
  [[nodiscard]] const ::std::string& ip6() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_ip6(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_ip6();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ip6();
  void set_allocated_ip6(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_ip6() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_ip6(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_ip6();

  public:
  // optional string mask6 = 6 [default = "64"];
  [[nodiscard]] bool has_mask6()
      const;
  void clear_mask6() ;
  [[nodiscard]] const ::std::string& mask6() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_mask6(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_mask6();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_mask6();
  void set_allocated_mask6(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_mask6() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_mask6(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_mask6();

  public:
  // optional string gw6 = 7 [default = "fc00::1"];
  [[nodiscard]] bool has_gw6()
      const;
  void clear_gw6() ;
  [[nodiscard]] const ::std::string& gw6() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_gw6(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_gw6();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_gw6();
  void set_allocated_gw6(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_gw6() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_gw6(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_gw6();

  public:
  // optional string ns_iface = 8 [default = "eth0"];
  [[nodiscard]] bool has_ns_iface()
      const;
  void clear_ns_iface() ;
  [[nodiscard]] const ::std::string& ns_iface() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_ns_iface(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_ns_iface();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ns_iface();
  void set_allocated_ns_iface(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_ns_iface() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_ns_iface(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_ns_iface();

  public:
  // optional string tcp_ports = 9 [default = "none"];
  [[nodiscard]] bool has_tcp_ports()
      const;
  void clear_tcp_ports() ;
  [[nodiscard]] const ::std::string& tcp_ports() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_tcp_ports(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_tcp_ports();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_tcp_ports();
  void set_allocated_tcp_ports(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_tcp_ports() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_tcp_ports(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_tcp_ports();

  public:
  // optional string udp_ports = 10 [default = "none"];
  [[nodiscard]] bool has_udp_ports()
      const;
  void clear_udp_ports() ;
  [[nodiscard]] const ::std::string& udp_ports() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_udp_ports(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_udp_ports();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_udp_ports();
  void set_allocated_udp_ports(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_udp_ports() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_udp_ports(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_udp_ports();

  public:
  // optional string dns_forward = 13 [default = ""];
  [[nodiscard]] bool has_dns_forward()
      const;
  void clear_dns_forward() ;
  [[nodiscard]] const ::std::string& dns_forward() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_dns_forward(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_dns_forward();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dns_forward();
  void set_allocated_dns_forward(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_dns_forward() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_dns_forward(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_dns_forward();

  public:
  // optional bool enable = 1 [default = false];
  [[nodiscard]] bool has_enable()
      const;
  void clear_enable() ;
  [[nodiscard]] bool enable() const;
  void set_enable(bool value);

  private:
  bool _internal_enable() const;
  void _internal_set_enable(bool value);

  public:
  // optional bool enable_ip4_dhcp = 11 [default = false];
  [[nodiscard]] bool has_enable_ip4_dhcp()
      const;
  void clear_enable_ip4_dhcp() ;
  [[nodiscard]] bool enable_ip4_dhcp() const;
  void set_enable_ip4_dhcp(bool value);

  private:
  bool _internal_enable_ip4_dhcp() const;
  void _internal_set_enable_ip4_dhcp(bool value);

  public:
  // optional bool enable_dns = 12 [default = false];
  [[nodiscard]] bool has_enable_dns()
      const;
  void clear_enable_dns() ;
  [[nodiscard]] bool enable_dns() const;
  void set_enable_dns(bool value);

  private:
  bool _internal_enable_dns() const;
  void _internal_set_enable_dns(bool value);

  public:
  // optional bool no_map_gw = 17 [default = false];
  [[nodiscard]] bool has_no_map_gw()
      const;
  void clear_no_map_gw() ;
  [[nodiscard]] bool no_map_gw() const;
  void set_no_map_gw(bool value);

  private:
  bool _internal_no_map_gw() const;
  void _internal_set_no_map_gw(bool value);

  public:
  // optional bool enable_ip6_dhcp = 18 [default = false];
  [[nodiscard]] bool has_enable_ip6_dhcp()
      const;
  void clear_enable_ip6_dhcp() ;
  [[nodiscard]] bool enable_ip6_dhcp() const;
  void set_enable_ip6_dhcp(bool value);

  private:
  bool _internal_enable_ip6_dhcp() const;
  void _internal_set_enable_ip6_dhcp(bool value);

  public:
  // optional bool enable_ip6_ra = 19 [default = false];
  [[nodiscard]] bool has_enable_ip6_ra()
      const;
  void clear_enable_ip6_ra() ;
  [[nodiscard]] bool enable_ip6_ra() const;
  void set_enable_ip6_ra(bool value);

  private:
  bool _internal_enable_ip6_ra() const;
  void _internal_set_enable_ip6_ra(bool value);

  public:
  // optional bool enable_tcp = 14 [default = true];
  [[nodiscard]] bool has_enable_tcp()
      const;
  void clear_enable_tcp() ;
  [[nodiscard]] bool enable_tcp() const;
  void set_enable_tcp(bool value);

  private:
  bool _internal_enable_tcp() const;
  void _internal_set_enable_tcp(bool value);

  public:
  // optional bool enable_udp = 15 [default = true];
  [[nodiscard]] bool has_enable_udp()
      const;
  void clear_enable_udp() ;
  [[nodiscard]] bool enable_udp() const;
  void set_enable_udp(bool value);

  private:
  bool _internal_enable_udp() const;
  void _internal_set_enable_udp(bool value);

  public:
  // optional bool enable_icmp = 16 [default = true];
  [[nodiscard]] bool has_enable_icmp()
      const;
  void clear_enable_icmp() ;
  [[nodiscard]] bool enable_icmp() const;
  void set_enable_icmp(bool value);

  private:
  bool _internal_enable_icmp() const;
  void _internal_set_enable_icmp(bool value);

  public:
  // @@protoc_insertion_point(class_scope:nsjail.NsJailConfig.UserNet)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 19,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const NsJailConfig_UserNet& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_ip_;
    ::google::protobuf::internal::ArenaStringPtr ip_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_mask_;
    ::google::protobuf::internal::ArenaStringPtr mask_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_gw_;
    ::google::protobuf::internal::ArenaStringPtr gw_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_ip6_;
    ::google::protobuf::internal::ArenaStringPtr ip6_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_mask6_;
    ::google::protobuf::internal::ArenaStringPtr mask6_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_gw6_;
    ::google::protobuf::internal::ArenaStringPtr gw6_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_ns_iface_;
    ::google::protobuf::internal::ArenaStringPtr ns_iface_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_tcp_ports_;
    ::google::protobuf::internal::ArenaStringPtr tcp_ports_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_udp_ports_;
    ::google::protobuf::internal::ArenaStringPtr udp_ports_;
    ::google::protobuf::internal::ArenaStringPtr dns_forward_;
    bool enable_;
    bool enable_ip4_dhcp_;
    bool enable_dns_;
    bool no_map_gw_;
    bool enable_ip6_dhcp_;
    bool enable_ip6_ra_;
    bool enable_tcp_;
    bool enable_udp_;
    bool enable_icmp_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_config_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED MountPt final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:nsjail.MountPt) */ {
 public:
  inline MountPt() : MountPt(nullptr) {}
  ~MountPt() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(MountPt* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(MountPt));
  }
#endif

  template <typename = void>
  explicit constexpr MountPt(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline MountPt(const MountPt& from) : MountPt(nullptr, from) {}
  inline MountPt(MountPt&& from) noexcept : MountPt(nullptr, ::std::move(from)) {}
  inline MountPt& operator=(const MountPt& from) {
    CopyFrom(from);
    return *this;
  }
  inline MountPt& operator=(MountPt&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const MountPt& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<MountPt>(&MountPt_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(MountPt& a, MountPt& b) { a.Swap(&b); }
  inline void Swap(MountPt* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MountPt* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] MountPt* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<MountPt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const MountPt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const MountPt& from) { MountPt::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(MountPt* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "nsjail.MountPt"; }

  explicit MountPt(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  MountPt(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MountPt& from);
  MountPt(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, MountPt&& from) noexcept
      : MountPt(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kSrcFieldNumber = 1,
    kPrefixSrcEnvFieldNumber = 2,
    kSrcContentFieldNumber = 3,
    kDstFieldNumber = 4,
    kPrefixDstEnvFieldNumber = 5,
    kFstypeFieldNumber = 6,
    kOptionsFieldNumber = 7,
    kIsBindFieldNumber = 8,
    kRwFieldNumber = 9,
    kIsDirFieldNumber = 10,
    kIsSymlinkFieldNumber = 12,
    kNosuidFieldNumber = 13,
    kNodevFieldNumber = 14,
    kNoexecFieldNumber = 15,
    kMandatoryFieldNumber = 11,
  };
  // optional string src = 1 [default = ""];
  [[nodiscard]] bool has_src()
      const;
  void clear_src() ;
  [[nodiscard]] const ::std::string& src() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_src(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_src();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_src();
  void set_allocated_src(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_src() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_src(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_src();

  public:
  // optional string prefix_src_env = 2 [default = ""];
  [[nodiscard]] bool has_prefix_src_env()
      const;
  void clear_prefix_src_env() ;
  [[nodiscard]] const ::std::string& prefix_src_env() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_prefix_src_env(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_prefix_src_env();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_prefix_src_env();
  void set_allocated_prefix_src_env(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_prefix_src_env() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_prefix_src_env(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_prefix_src_env();

  public:
  // optional bytes src_content = 3 [default = ""];
  [[nodiscard]] bool has_src_content()
      const;
  void clear_src_content() ;
  [[nodiscard]] const ::std::string& src_content() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_src_content(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_src_content();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_src_content();
  void set_allocated_src_content(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_src_content() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_src_content(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_src_content();

  public:
  // required string dst = 4 [default = ""];
  [[nodiscard]] bool has_dst()
      const;
  void clear_dst() ;
  [[nodiscard]] const ::std::string& dst() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_dst(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_dst();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dst();
  void set_allocated_dst(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_dst() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_dst(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_dst();

  public:
  // optional string prefix_dst_env = 5 [default = ""];
  [[nodiscard]] bool has_prefix_dst_env()
      const;
  void clear_prefix_dst_env() ;
  [[nodiscard]] const ::std::string& prefix_dst_env() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_prefix_dst_env(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_prefix_dst_env();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_prefix_dst_env();
  void set_allocated_prefix_dst_env(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_prefix_dst_env() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_prefix_dst_env(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_prefix_dst_env();

  public:
  // optional string fstype = 6 [default = ""];
  [[nodiscard]] bool has_fstype()
      const;
  void clear_fstype() ;
  [[nodiscard]] const ::std::string& fstype() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_fstype(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_fstype();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_fstype();
  void set_allocated_fstype(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_fstype() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_fstype(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_fstype();

  public:
  // optional string options = 7 [default = ""];
  [[nodiscard]] bool has_options()
      const;
  void clear_options() ;
  [[nodiscard]] const ::std::string& options() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_options(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_options();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_options();
  void set_allocated_options(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_options() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_options(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_options();

  public:
  // optional bool is_bind = 8 [default = false];
  [[nodiscard]] bool has_is_bind()
      const;
  void clear_is_bind() ;
  [[nodiscard]] bool is_bind() const;
  void set_is_bind(bool value);

  private:
  bool _internal_is_bind() const;
  void _internal_set_is_bind(bool value);

  public:
  // optional bool rw = 9 [default = false];
  [[nodiscard]] bool has_rw()
      const;
  void clear_rw() ;
  [[nodiscard]] bool rw() const;
  void set_rw(bool value);

  private:
  bool _internal_rw() const;
  void _internal_set_rw(bool value);

  public:
  // optional bool is_dir = 10;
  [[nodiscard]] bool has_is_dir()
      const;
  void clear_is_dir() ;
  [[nodiscard]] bool is_dir() const;
  void set_is_dir(bool value);

  private:
  bool _internal_is_dir() const;
  void _internal_set_is_dir(bool value);

  public:
  // optional bool is_symlink = 12 [default = false];
  [[nodiscard]] bool has_is_symlink()
      const;
  void clear_is_symlink() ;
  [[nodiscard]] bool is_symlink() const;
  void set_is_symlink(bool value);

  private:
  bool _internal_is_symlink() const;
  void _internal_set_is_symlink(bool value);

  public:
  // optional bool nosuid = 13 [default = false];
  [[nodiscard]] bool has_nosuid()
      const;
  void clear_nosuid() ;
  [[nodiscard]] bool nosuid() const;
  void set_nosuid(bool value);

  private:
  bool _internal_nosuid() const;
  void _internal_set_nosuid(bool value);

  public:
  // optional bool nodev = 14 [default = false];
  [[nodiscard]] bool has_nodev()
      const;
  void clear_nodev() ;
  [[nodiscard]] bool nodev() const;
  void set_nodev(bool value);

  private:
  bool _internal_nodev() const;
  void _internal_set_nodev(bool value);

  public:
  // optional bool noexec = 15 [default = false];
  [[nodiscard]] bool has_noexec()
      const;
  void clear_noexec() ;
  [[nodiscard]] bool noexec() const;
  void set_noexec(bool value);

  private:
  bool _internal_noexec() const;
  void _internal_set_noexec(bool value);

  public:
  // optional bool mandatory = 11 [default = true];
  [[nodiscard]] bool has_mandatory()
      const;
  void clear_mandatory() ;
  [[nodiscard]] bool mandatory() const;
  void set_mandatory(bool value);

  private:
  bool _internal_mandatory() const;
  void _internal_set_mandatory(bool value);

  public:
  // @@protoc_insertion_point(class_scope:nsjail.MountPt)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 15,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const MountPt& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr src_;
    ::google::protobuf::internal::ArenaStringPtr prefix_src_env_;
    ::google::protobuf::internal::ArenaStringPtr src_content_;
    ::google::protobuf::internal::ArenaStringPtr dst_;
    ::google::protobuf::internal::ArenaStringPtr prefix_dst_env_;
    ::google::protobuf::internal::ArenaStringPtr fstype_;
    ::google::protobuf::internal::ArenaStringPtr options_;
    bool is_bind_;
    bool rw_;
    bool is_dir_;
    bool is_symlink_;
    bool nosuid_;
    bool nodev_;
    bool noexec_;
    bool mandatory_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_config_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED IdMap final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:nsjail.IdMap) */ {
 public:
  inline IdMap() : IdMap(nullptr) {}
  ~IdMap() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(IdMap* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(IdMap));
  }
#endif

  template <typename = void>
  explicit constexpr IdMap(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline IdMap(const IdMap& from) : IdMap(nullptr, from) {}
  inline IdMap(IdMap&& from) noexcept : IdMap(nullptr, ::std::move(from)) {}
  inline IdMap& operator=(const IdMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline IdMap& operator=(IdMap&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const IdMap& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<IdMap>(&IdMap_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(IdMap& a, IdMap& b) { a.Swap(&b); }
  inline void Swap(IdMap* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IdMap* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] IdMap* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<IdMap>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const IdMap& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const IdMap& from) { IdMap::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(IdMap* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "nsjail.IdMap"; }

  explicit IdMap(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  IdMap(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IdMap& from);
  IdMap(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, IdMap&& from) noexcept
      : IdMap(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kInsideIdFieldNumber = 1,
    kOutsideIdFieldNumber = 2,
    kUseNewidmapFieldNumber = 4,
    kCountFieldNumber = 3,
  };
  // optional string inside_id = 1 [default = ""];
  [[nodiscard]] bool has_inside_id()
      const;
  void clear_inside_id() ;
  [[nodiscard]] const ::std::string& inside_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_inside_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_inside_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_inside_id();
  void set_allocated_inside_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_inside_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_inside_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_inside_id();

  public:
  // optional string outside_id = 2 [default = ""];
  [[nodiscard]] bool has_outside_id()
      const;
  void clear_outside_id() ;
  [[nodiscard]] const ::std::string& outside_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_outside_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_outside_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_outside_id();
  void set_allocated_outside_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_outside_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_outside_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_outside_id();

  public:
  // optional bool use_newidmap = 4 [default = false];
  [[nodiscard]] bool has_use_newidmap()
      const;
  void clear_use_newidmap() ;
  [[nodiscard]] bool use_newidmap() const;
  void set_use_newidmap(bool value);

  private:
  bool _internal_use_newidmap() const;
  void _internal_set_use_newidmap(bool value);

  public:
  // optional uint32 count = 3 [default = 1];
  [[nodiscard]] bool has_count()
      const;
  void clear_count() ;
  [[nodiscard]] ::uint32_t count() const;
  void set_count(::uint32_t value);

  private:
  ::uint32_t _internal_count() const;
  void _internal_set_count(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:nsjail.IdMap)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const IdMap& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr inside_id_;
    ::google::protobuf::internal::ArenaStringPtr outside_id_;
    bool use_newidmap_;
    ::uint32_t count_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_config_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Exe final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:nsjail.Exe) */ {
 public:
  inline Exe() : Exe(nullptr) {}
  ~Exe() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Exe* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Exe));
  }
#endif

  template <typename = void>
  explicit constexpr Exe(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Exe(const Exe& from) : Exe(nullptr, from) {}
  inline Exe(Exe&& from) noexcept : Exe(nullptr, ::std::move(from)) {}
  inline Exe& operator=(const Exe& from) {
    CopyFrom(from);
    return *this;
  }
  inline Exe& operator=(Exe&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Exe& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Exe>(&Exe_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(Exe& a, Exe& b) { a.Swap(&b); }
  inline void Swap(Exe* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Exe* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Exe* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Exe>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Exe& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Exe& from) { Exe::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Exe* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "nsjail.Exe"; }

  explicit Exe(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Exe(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Exe& from);
  Exe(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Exe&& from) noexcept
      : Exe(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kArgFieldNumber = 2,
    kPathFieldNumber = 1,
    kArg0FieldNumber = 3,
    kExecFdFieldNumber = 4,
  };
  // repeated string arg = 2;
  [[nodiscard]] int arg_size()
      const;
  private:
  int _internal_arg_size() const;

  public:
  void clear_arg() ;
  [[nodiscard]] const ::std::string& arg(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_arg(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_arg(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_arg();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_arg(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      arg() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_arg();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_arg() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_arg();

  public:
  // required string path = 1;
  [[nodiscard]] bool has_path()
      const;
  void clear_path() ;
  [[nodiscard]] const ::std::string& path() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_path(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_path();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_path();
  void set_allocated_path(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_path() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_path(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_path();

  public:
  // optional string arg0 = 3;
  [[nodiscard]] bool has_arg0()
      const;
  void clear_arg0() ;
  [[nodiscard]] const ::std::string& arg0() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_arg0(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_arg0();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_arg0();
  void set_allocated_arg0(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_arg0() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_arg0(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_arg0();

  public:
  // optional bool exec_fd = 4 [default = false];
  [[nodiscard]] bool has_exec_fd()
      const;
  void clear_exec_fd() ;
  [[nodiscard]] bool exec_fd() const;
  void set_exec_fd(bool value);

  private:
  bool _internal_exec_fd() const;
  void _internal_set_exec_fd(bool value);

  public:
  // @@protoc_insertion_point(class_scope:nsjail.Exe)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Exe& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> arg_;
    ::google::protobuf::internal::ArenaStringPtr path_;
    ::google::protobuf::internal::ArenaStringPtr arg0_;
    bool exec_fd_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_config_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NsJailConfig final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:nsjail.NsJailConfig) */ {
 public:
  inline NsJailConfig() : NsJailConfig(nullptr) {}
  ~NsJailConfig() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(NsJailConfig* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(NsJailConfig));
  }
#endif

  template <typename = void>
  explicit constexpr NsJailConfig(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline NsJailConfig(const NsJailConfig& from) : NsJailConfig(nullptr, from) {}
  inline NsJailConfig(NsJailConfig&& from) noexcept : NsJailConfig(nullptr, ::std::move(from)) {}
  inline NsJailConfig& operator=(const NsJailConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline NsJailConfig& operator=(NsJailConfig&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const NsJailConfig& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NsJailConfig>(&NsJailConfig_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(NsJailConfig& a, NsJailConfig& b) { a.Swap(&b); }
  inline void Swap(NsJailConfig* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NsJailConfig* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] NsJailConfig* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<NsJailConfig>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NsJailConfig& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const NsJailConfig& from) { NsJailConfig::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(NsJailConfig* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "nsjail.NsJailConfig"; }

  explicit NsJailConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NsJailConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NsJailConfig& from);
  NsJailConfig(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NsJailConfig&& from) noexcept
      : NsJailConfig(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using UserNet = NsJailConfig_UserNet;

  // accessors -------------------------------------------------------
  enum : int {
    kDescriptionFieldNumber = 2,
    kEnvarFieldNumber = 19,
    kCapFieldNumber = 21,
    kPassFdFieldNumber = 25,
    kNameFieldNumber = 1,
    kHostnameFieldNumber = 4,
    kCwdFieldNumber = 5,
    kBindhostFieldNumber = 8,
    kLogFileFieldNumber = 16,
    kPortFieldNumber = 7,
    kMaxConnsFieldNumber = 9,
    kMaxConnsPerIpFieldNumber = 10,
    kMaxCpusFieldNumber = 13,
    kNoPivotrootFieldNumber = 6,
    kDaemonFieldNumber = 12,
    kKeepEnvFieldNumber = 18,
    kKeepCapsFieldNumber = 20,
    kLogFdFieldNumber = 15,
    kLogLevelFieldNumber = 17,
    kSilentFieldNumber = 22,
    kSkipSetsidFieldNumber = 23,
    kStderrToNullFieldNumber = 24,
    kDisableNoNewPrivsFieldNumber = 26,
    kForwardSignalsFieldNumber = 27,
    kDisableTscFieldNumber = 28,
    kRlimitAsTypeFieldNumber = 30,
    kRlimitCoreFieldNumber = 31,
    kModeFieldNumber = 3,
    kTimeLimitFieldNumber = 11,
    kRlimitAsFieldNumber = 29,
    kNiceLevelFieldNumber = 14,
    kUidmapFieldNumber = 63,
    kGidmapFieldNumber = 64,
    kMountFieldNumber = 66,
    kSeccompStringFieldNumber = 68,
    kIfaceOwnFieldNumber = 88,
    kSeccompPolicyFileFieldNumber = 67,
    kCgroupMemMountFieldNumber = 73,
    kCgroupMemParentFieldNumber = 74,
    kCgroupPidsMountFieldNumber = 76,
    kCgroupPidsParentFieldNumber = 77,
    kCgroupNetClsMountFieldNumber = 79,
    kCgroupNetClsParentFieldNumber = 80,
    kCgroupCpuMountFieldNumber = 82,
    kCgroupCpuParentFieldNumber = 83,
    kCgroupv2MountFieldNumber = 84,
    kMacvlanIfaceFieldNumber = 89,
    kMacvlanVsIpFieldNumber = 90,
    kMacvlanVsNmFieldNumber = 91,
    kMacvlanVsGwFieldNumber = 92,
    kMacvlanVsMaFieldNumber = 93,
    kMacvlanVsMoFieldNumber = 94,
    kUserNetFieldNumber = 95,
    kExecBinFieldNumber = 96,
    kRlimitCoreTypeFieldNumber = 32,
    kRlimitCpuTypeFieldNumber = 34,
    kRlimitFsizeTypeFieldNumber = 36,
    kRlimitNofileTypeFieldNumber = 38,
    kRlimitRtprioFieldNumber = 45,
    kDisableRlFieldNumber = 49,
    kPersonaAddrCompatLayoutFieldNumber = 50,
    kPersonaMmapPageZeroFieldNumber = 51,
    kPersonaReadImpliesExecFieldNumber = 52,
    kPersonaAddrLimit3GbFieldNumber = 53,
    kPersonaAddrNoRandomizeFieldNumber = 54,
    kCloneNewtimeFieldNumber = 62,
    kMountProcFieldNumber = 65,
    kCgroupMemMaxFieldNumber = 70,
    kCgroupMemMemswMaxFieldNumber = 71,
    kCgroupPidsMaxFieldNumber = 75,
    kCgroupNetClsClassidFieldNumber = 78,
    kCgroupCpuMsPerSecFieldNumber = 81,
    kSeccompLogFieldNumber = 69,
    kUseCgroupv2FieldNumber = 85,
    kDetectCgroupv2FieldNumber = 86,
    kIfaceNoLoFieldNumber = 87,
    kCloneNewipcFieldNumber = 59,
    kCloneNewutsFieldNumber = 60,
    kCloneNewcgroupFieldNumber = 61,
    kRlimitCpuFieldNumber = 33,
    kRlimitFsizeFieldNumber = 35,
    kRlimitNofileFieldNumber = 37,
    kRlimitNprocFieldNumber = 39,
    kRlimitStackFieldNumber = 41,
    kRlimitNprocTypeFieldNumber = 40,
    kRlimitStackTypeFieldNumber = 42,
    kRlimitMemlockFieldNumber = 43,
    kRlimitMemlockTypeFieldNumber = 44,
    kRlimitRtprioTypeFieldNumber = 46,
    kRlimitMsgqueueFieldNumber = 47,
    kRlimitMsgqueueTypeFieldNumber = 48,
    kCloneNewnetFieldNumber = 55,
    kCloneNewuserFieldNumber = 56,
    kCloneNewnsFieldNumber = 57,
    kCloneNewpidFieldNumber = 58,
    kCgroupMemSwapMaxFieldNumber = 72,
  };
  // repeated string description = 2;
  [[nodiscard]] int description_size()
      const;
  private:
  int _internal_description_size() const;

  public:
  void clear_description() ;
  [[nodiscard]] const ::std::string& description(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_description(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_description(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_description();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_description(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      description() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_description();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_description() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_description();

  public:
  // repeated string envar = 19;
  [[nodiscard]] int envar_size()
      const;
  private:
  int _internal_envar_size() const;

  public:
  void clear_envar() ;
  [[nodiscard]] const ::std::string& envar(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_envar(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_envar(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_envar();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_envar(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      envar() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_envar();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_envar() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_envar();

  public:
  // repeated string cap = 21;
  [[nodiscard]] int cap_size()
      const;
  private:
  int _internal_cap_size() const;

  public:
  void clear_cap() ;
  [[nodiscard]] const ::std::string& cap(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_cap(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cap(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_cap();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_cap(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      cap() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_cap();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_cap() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_cap();

  public:
  // repeated int32 pass_fd = 25;
  [[nodiscard]] int pass_fd_size()
      const;
  private:
  int _internal_pass_fd_size() const;

  public:
  void clear_pass_fd() ;
  [[nodiscard]] ::int32_t pass_fd(int index) const;
  void set_pass_fd(int index, ::int32_t value);
  void add_pass_fd(::int32_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int32_t>& pass_fd()
      const;
  ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL mutable_pass_fd();

  private:
  const ::google::protobuf::RepeatedField<::int32_t>& _internal_pass_fd() const;
  ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL _internal_mutable_pass_fd();

  public:
  // optional string name = 1 [default = ""];
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional string hostname = 4 [default = "NSJAIL"];
  [[nodiscard]] bool has_hostname()
      const;
  void clear_hostname() ;
  [[nodiscard]] const ::std::string& hostname() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_hostname(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_hostname();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_hostname();
  void set_allocated_hostname(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_hostname() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_hostname(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_hostname();

  public:
  // optional string cwd = 5 [default = "/"];
  [[nodiscard]] bool has_cwd()
      const;
  void clear_cwd() ;
  [[nodiscard]] const ::std::string& cwd() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cwd(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cwd();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cwd();
  void set_allocated_cwd(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cwd() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cwd(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cwd();

  public:
  // optional string bindhost = 8 [default = "::"];
  [[nodiscard]] bool has_bindhost()
      const;
  void clear_bindhost() ;
  [[nodiscard]] const ::std::string& bindhost() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_bindhost(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_bindhost();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_bindhost();
  void set_allocated_bindhost(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_bindhost() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_bindhost(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_bindhost();

  public:
  // optional string log_file = 16;
  [[nodiscard]] bool has_log_file()
      const;
  void clear_log_file() ;
  [[nodiscard]] const ::std::string& log_file() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_log_file(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_log_file();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_log_file();
  void set_allocated_log_file(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_log_file() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_log_file(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_log_file();

  public:
  // optional uint32 port = 7 [default = 0];
  [[nodiscard]] bool has_port()
      const;
  void clear_port() ;
  [[nodiscard]] ::uint32_t port() const;
  void set_port(::uint32_t value);

  private:
  ::uint32_t _internal_port() const;
  void _internal_set_port(::uint32_t value);

  public:
  // optional uint32 max_conns = 9 [default = 0];
  [[nodiscard]] bool has_max_conns()
      const;
  void clear_max_conns() ;
  [[nodiscard]] ::uint32_t max_conns() const;
  void set_max_conns(::uint32_t value);

  private:
  ::uint32_t _internal_max_conns() const;
  void _internal_set_max_conns(::uint32_t value);

  public:
  // optional uint32 max_conns_per_ip = 10 [default = 0];
  [[nodiscard]] bool has_max_conns_per_ip()
      const;
  void clear_max_conns_per_ip() ;
  [[nodiscard]] ::uint32_t max_conns_per_ip() const;
  void set_max_conns_per_ip(::uint32_t value);

  private:
  ::uint32_t _internal_max_conns_per_ip() const;
  void _internal_set_max_conns_per_ip(::uint32_t value);

  public:
  // optional uint32 max_cpus = 13 [default = 0];
  [[nodiscard]] bool has_max_cpus()
      const;
  void clear_max_cpus() ;
  [[nodiscard]] ::uint32_t max_cpus() const;
  void set_max_cpus(::uint32_t value);

  private:
  ::uint32_t _internal_max_cpus() const;
  void _internal_set_max_cpus(::uint32_t value);

  public:
  // optional bool no_pivotroot = 6 [default = false];
  [[nodiscard]] bool has_no_pivotroot()
      const;
  void clear_no_pivotroot() ;
  [[nodiscard]] bool no_pivotroot() const;
  void set_no_pivotroot(bool value);

  private:
  bool _internal_no_pivotroot() const;
  void _internal_set_no_pivotroot(bool value);

  public:
  // optional bool daemon = 12 [default = false];
  [[nodiscard]] bool has_daemon()
      const;
  void clear_daemon() ;
  [[nodiscard]] bool daemon() const;
  void set_daemon(bool value);

  private:
  bool _internal_daemon() const;
  void _internal_set_daemon(bool value);

  public:
  // optional bool keep_env = 18 [default = false];
  [[nodiscard]] bool has_keep_env()
      const;
  void clear_keep_env() ;
  [[nodiscard]] bool keep_env() const;
  void set_keep_env(bool value);

  private:
  bool _internal_keep_env() const;
  void _internal_set_keep_env(bool value);

  public:
  // optional bool keep_caps = 20 [default = false];
  [[nodiscard]] bool has_keep_caps()
      const;
  void clear_keep_caps() ;
  [[nodiscard]] bool keep_caps() const;
  void set_keep_caps(bool value);

  private:
  bool _internal_keep_caps() const;
  void _internal_set_keep_caps(bool value);

  public:
  // optional int32 log_fd = 15;
  [[nodiscard]] bool has_log_fd()
      const;
  void clear_log_fd() ;
  [[nodiscard]] ::int32_t log_fd() const;
  void set_log_fd(::int32_t value);

  private:
  ::int32_t _internal_log_fd() const;
  void _internal_set_log_fd(::int32_t value);

  public:
  // optional .nsjail.LogLevel log_level = 17;
  [[nodiscard]] bool has_log_level()
      const;
  void clear_log_level() ;
  [[nodiscard]] ::nsjail::LogLevel log_level() const;
  void set_log_level(::nsjail::LogLevel value);

  private:
  ::nsjail::LogLevel _internal_log_level() const;
  void _internal_set_log_level(::nsjail::LogLevel value);

  public:
  // optional bool silent = 22 [default = false];
  [[nodiscard]] bool has_silent()
      const;
  void clear_silent() ;
  [[nodiscard]] bool silent() const;
  void set_silent(bool value);

  private:
  bool _internal_silent() const;
  void _internal_set_silent(bool value);

  public:
  // optional bool skip_setsid = 23 [default = false];
  [[nodiscard]] bool has_skip_setsid()
      const;
  void clear_skip_setsid() ;
  [[nodiscard]] bool skip_setsid() const;
  void set_skip_setsid(bool value);

  private:
  bool _internal_skip_setsid() const;
  void _internal_set_skip_setsid(bool value);

  public:
  // optional bool stderr_to_null = 24 [default = false];
  [[nodiscard]] bool has_stderr_to_null()
      const;
  void clear_stderr_to_null() ;
  [[nodiscard]] bool stderr_to_null() const;
  void set_stderr_to_null(bool value);

  private:
  bool _internal_stderr_to_null() const;
  void _internal_set_stderr_to_null(bool value);

  public:
  // optional bool disable_no_new_privs = 26 [default = false];
  [[nodiscard]] bool has_disable_no_new_privs()
      const;
  void clear_disable_no_new_privs() ;
  [[nodiscard]] bool disable_no_new_privs() const;
  void set_disable_no_new_privs(bool value);

  private:
  bool _internal_disable_no_new_privs() const;
  void _internal_set_disable_no_new_privs(bool value);

  public:
  // optional bool forward_signals = 27 [default = false];
  [[nodiscard]] bool has_forward_signals()
      const;
  void clear_forward_signals() ;
  [[nodiscard]] bool forward_signals() const;
  void set_forward_signals(bool value);

  private:
  bool _internal_forward_signals() const;
  void _internal_set_forward_signals(bool value);

  public:
  // optional bool disable_tsc = 28 [default = false];
  [[nodiscard]] bool has_disable_tsc()
      const;
  void clear_disable_tsc() ;
  [[nodiscard]] bool disable_tsc() const;
  void set_disable_tsc(bool value);

  private:
  bool _internal_disable_tsc() const;
  void _internal_set_disable_tsc(bool value);

  public:
  // optional .nsjail.RLimit rlimit_as_type = 30 [default = VALUE];
  [[nodiscard]] bool has_rlimit_as_type()
      const;
  void clear_rlimit_as_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_as_type() const;
  void set_rlimit_as_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_as_type() const;
  void _internal_set_rlimit_as_type(::nsjail::RLimit value);

  public:
  // optional uint64 rlimit_core = 31 [default = 0];
  [[nodiscard]] bool has_rlimit_core()
      const;
  void clear_rlimit_core() ;
  [[nodiscard]] ::uint64_t rlimit_core() const;
  void set_rlimit_core(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_core() const;
  void _internal_set_rlimit_core(::uint64_t value);

  public:
  // optional .nsjail.Mode mode = 3 [default = ONCE];
  [[nodiscard]] bool has_mode()
      const;
  void clear_mode() ;
  [[nodiscard]] ::nsjail::Mode mode() const;
  void set_mode(::nsjail::Mode value);

  private:
  ::nsjail::Mode _internal_mode() const;
  void _internal_set_mode(::nsjail::Mode value);

  public:
  // optional uint32 time_limit = 11 [default = 600];
  [[nodiscard]] bool has_time_limit()
      const;
  void clear_time_limit() ;
  [[nodiscard]] ::uint32_t time_limit() const;
  void set_time_limit(::uint32_t value);

  private:
  ::uint32_t _internal_time_limit() const;
  void _internal_set_time_limit(::uint32_t value);

  public:
  // optional uint64 rlimit_as = 29 [default = 4096];
  [[nodiscard]] bool has_rlimit_as()
      const;
  void clear_rlimit_as() ;
  [[nodiscard]] ::uint64_t rlimit_as() const;
  void set_rlimit_as(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_as() const;
  void _internal_set_rlimit_as(::uint64_t value);

  public:
  // optional int32 nice_level = 14 [default = 19];
  [[nodiscard]] bool has_nice_level()
      const;
  void clear_nice_level() ;
  [[nodiscard]] ::int32_t nice_level() const;
  void set_nice_level(::int32_t value);

  private:
  ::int32_t _internal_nice_level() const;
  void _internal_set_nice_level(::int32_t value);

  public:
  // repeated .nsjail.IdMap uidmap = 63;
  [[nodiscard]] int uidmap_size()
      const;
  private:
  int _internal_uidmap_size() const;

  public:
  void clear_uidmap() ;
  [[nodiscard]] const ::nsjail::IdMap& uidmap(int index) const;
  [[nodiscard]] ::nsjail::IdMap* PROTOBUF_NONNULL mutable_uidmap(int index);
  ::nsjail::IdMap* PROTOBUF_NONNULL add_uidmap();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>&
  uidmap() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL
  mutable_uidmap();

  private:
  const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>& _internal_uidmap() const;
  ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL _internal_mutable_uidmap();

  public:
  // repeated .nsjail.IdMap gidmap = 64;
  [[nodiscard]] int gidmap_size()
      const;
  private:
  int _internal_gidmap_size() const;

  public:
  void clear_gidmap() ;
  [[nodiscard]] const ::nsjail::IdMap& gidmap(int index) const;
  [[nodiscard]] ::nsjail::IdMap* PROTOBUF_NONNULL mutable_gidmap(int index);
  ::nsjail::IdMap* PROTOBUF_NONNULL add_gidmap();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>&
  gidmap() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL
  mutable_gidmap();

  private:
  const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>& _internal_gidmap() const;
  ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL _internal_mutable_gidmap();

  public:
  // repeated .nsjail.MountPt mount = 66;
  [[nodiscard]] int mount_size()
      const;
  private:
  int _internal_mount_size() const;

  public:
  void clear_mount() ;
  [[nodiscard]] const ::nsjail::MountPt& mount(int index) const;
  [[nodiscard]] ::nsjail::MountPt* PROTOBUF_NONNULL mutable_mount(int index);
  ::nsjail::MountPt* PROTOBUF_NONNULL add_mount();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>&
  mount() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>* PROTOBUF_NONNULL
  mutable_mount();

  private:
  const ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>& _internal_mount() const;
  ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>* PROTOBUF_NONNULL _internal_mutable_mount();

  public:
  // repeated string seccomp_string = 68;
  [[nodiscard]] int seccomp_string_size()
      const;
  private:
  int _internal_seccomp_string_size() const;

  public:
  void clear_seccomp_string() ;
  [[nodiscard]] const ::std::string& seccomp_string(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_seccomp_string(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_seccomp_string(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_seccomp_string();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_seccomp_string(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      seccomp_string() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_seccomp_string();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_seccomp_string() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_seccomp_string();

  public:
  // repeated string iface_own = 88;
  [[nodiscard]] int iface_own_size()
      const;
  private:
  int _internal_iface_own_size() const;

  public:
  void clear_iface_own() ;
  [[nodiscard]] const ::std::string& iface_own(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_iface_own(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_iface_own(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_iface_own();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_iface_own(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      iface_own() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_iface_own();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_iface_own() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_iface_own();

  public:
  // optional string seccomp_policy_file = 67;
  [[nodiscard]] bool has_seccomp_policy_file()
      const;
  void clear_seccomp_policy_file() ;
  [[nodiscard]] const ::std::string& seccomp_policy_file() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_seccomp_policy_file(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_seccomp_policy_file();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_seccomp_policy_file();
  void set_allocated_seccomp_policy_file(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_seccomp_policy_file() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_seccomp_policy_file(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_seccomp_policy_file();

  public:
  // optional string cgroup_mem_mount = 73 [default = "/sys/fs/cgroup/memory"];
  [[nodiscard]] bool has_cgroup_mem_mount()
      const;
  void clear_cgroup_mem_mount() ;
  [[nodiscard]] const ::std::string& cgroup_mem_mount() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_mem_mount(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_mem_mount();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_mem_mount();
  void set_allocated_cgroup_mem_mount(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_mem_mount() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_mem_mount(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_mem_mount();

  public:
  // optional string cgroup_mem_parent = 74 [default = "NSJAIL"];
  [[nodiscard]] bool has_cgroup_mem_parent()
      const;
  void clear_cgroup_mem_parent() ;
  [[nodiscard]] const ::std::string& cgroup_mem_parent() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_mem_parent(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_mem_parent();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_mem_parent();
  void set_allocated_cgroup_mem_parent(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_mem_parent() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_mem_parent(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_mem_parent();

  public:
  // optional string cgroup_pids_mount = 76 [default = "/sys/fs/cgroup/pids"];
  [[nodiscard]] bool has_cgroup_pids_mount()
      const;
  void clear_cgroup_pids_mount() ;
  [[nodiscard]] const ::std::string& cgroup_pids_mount() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_pids_mount(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_pids_mount();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_pids_mount();
  void set_allocated_cgroup_pids_mount(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_pids_mount() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_pids_mount(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_pids_mount();

  public:
  // optional string cgroup_pids_parent = 77 [default = "NSJAIL"];
  [[nodiscard]] bool has_cgroup_pids_parent()
      const;
  void clear_cgroup_pids_parent() ;
  [[nodiscard]] const ::std::string& cgroup_pids_parent() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_pids_parent(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_pids_parent();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_pids_parent();
  void set_allocated_cgroup_pids_parent(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_pids_parent() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_pids_parent(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_pids_parent();

  public:
  // optional string cgroup_net_cls_mount = 79 [default = "/sys/fs/cgroup/net_cls"];
  [[nodiscard]] bool has_cgroup_net_cls_mount()
      const;
  void clear_cgroup_net_cls_mount() ;
  [[nodiscard]] const ::std::string& cgroup_net_cls_mount() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_net_cls_mount(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_net_cls_mount();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_net_cls_mount();
  void set_allocated_cgroup_net_cls_mount(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_net_cls_mount() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_net_cls_mount(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_net_cls_mount();

  public:
  // optional string cgroup_net_cls_parent = 80 [default = "NSJAIL"];
  [[nodiscard]] bool has_cgroup_net_cls_parent()
      const;
  void clear_cgroup_net_cls_parent() ;
  [[nodiscard]] const ::std::string& cgroup_net_cls_parent() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_net_cls_parent(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_net_cls_parent();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_net_cls_parent();
  void set_allocated_cgroup_net_cls_parent(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_net_cls_parent() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_net_cls_parent(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_net_cls_parent();

  public:
  // optional string cgroup_cpu_mount = 82 [default = "/sys/fs/cgroup/cpu"];
  [[nodiscard]] bool has_cgroup_cpu_mount()
      const;
  void clear_cgroup_cpu_mount() ;
  [[nodiscard]] const ::std::string& cgroup_cpu_mount() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_cpu_mount(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_cpu_mount();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_cpu_mount();
  void set_allocated_cgroup_cpu_mount(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_cpu_mount() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_cpu_mount(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_cpu_mount();

  public:
  // optional string cgroup_cpu_parent = 83 [default = "NSJAIL"];
  [[nodiscard]] bool has_cgroup_cpu_parent()
      const;
  void clear_cgroup_cpu_parent() ;
  [[nodiscard]] const ::std::string& cgroup_cpu_parent() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroup_cpu_parent(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroup_cpu_parent();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroup_cpu_parent();
  void set_allocated_cgroup_cpu_parent(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroup_cpu_parent() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroup_cpu_parent(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroup_cpu_parent();

  public:
  // optional string cgroupv2_mount = 84 [default = "/sys/fs/cgroup"];
  [[nodiscard]] bool has_cgroupv2_mount()
      const;
  void clear_cgroupv2_mount() ;
  [[nodiscard]] const ::std::string& cgroupv2_mount() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_cgroupv2_mount(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_cgroupv2_mount();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_cgroupv2_mount();
  void set_allocated_cgroupv2_mount(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_cgroupv2_mount() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_cgroupv2_mount(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_cgroupv2_mount();

  public:
  // optional string macvlan_iface = 89;
  [[nodiscard]] bool has_macvlan_iface()
      const;
  void clear_macvlan_iface() ;
  [[nodiscard]] const ::std::string& macvlan_iface() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_macvlan_iface(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_macvlan_iface();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_macvlan_iface();
  void set_allocated_macvlan_iface(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_macvlan_iface() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_macvlan_iface(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_macvlan_iface();

  public:
  // optional string macvlan_vs_ip = 90 [default = "192.168.0.2"];
  [[nodiscard]] bool has_macvlan_vs_ip()
      const;
  void clear_macvlan_vs_ip() ;
  [[nodiscard]] const ::std::string& macvlan_vs_ip() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_macvlan_vs_ip(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_macvlan_vs_ip();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_macvlan_vs_ip();
  void set_allocated_macvlan_vs_ip(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_macvlan_vs_ip() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_macvlan_vs_ip(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_macvlan_vs_ip();

  public:
  // optional string macvlan_vs_nm = 91 [default = "255.255.255.0"];
  [[nodiscard]] bool has_macvlan_vs_nm()
      const;
  void clear_macvlan_vs_nm() ;
  [[nodiscard]] const ::std::string& macvlan_vs_nm() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_macvlan_vs_nm(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_macvlan_vs_nm();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_macvlan_vs_nm();
  void set_allocated_macvlan_vs_nm(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_macvlan_vs_nm() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_macvlan_vs_nm(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_macvlan_vs_nm();

  public:
  // optional string macvlan_vs_gw = 92 [default = "192.168.0.1"];
  [[nodiscard]] bool has_macvlan_vs_gw()
      const;
  void clear_macvlan_vs_gw() ;
  [[nodiscard]] const ::std::string& macvlan_vs_gw() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_macvlan_vs_gw(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_macvlan_vs_gw();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_macvlan_vs_gw();
  void set_allocated_macvlan_vs_gw(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_macvlan_vs_gw() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_macvlan_vs_gw(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_macvlan_vs_gw();

  public:
  // optional string macvlan_vs_ma = 93 [default = ""];
  [[nodiscard]] bool has_macvlan_vs_ma()
      const;
  void clear_macvlan_vs_ma() ;
  [[nodiscard]] const ::std::string& macvlan_vs_ma() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_macvlan_vs_ma(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_macvlan_vs_ma();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_macvlan_vs_ma();
  void set_allocated_macvlan_vs_ma(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_macvlan_vs_ma() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_macvlan_vs_ma(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_macvlan_vs_ma();

  public:
  // optional string macvlan_vs_mo = 94 [default = "private"];
  [[nodiscard]] bool has_macvlan_vs_mo()
      const;
  void clear_macvlan_vs_mo() ;
  [[nodiscard]] const ::std::string& macvlan_vs_mo() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_macvlan_vs_mo(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_macvlan_vs_mo();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_macvlan_vs_mo();
  void set_allocated_macvlan_vs_mo(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_macvlan_vs_mo() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_macvlan_vs_mo(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_macvlan_vs_mo();

  public:
  // optional .nsjail.NsJailConfig.UserNet user_net = 95;
  [[nodiscard]] bool has_user_net()
      const;
  void clear_user_net() ;
  [[nodiscard]] const ::nsjail::NsJailConfig_UserNet& user_net() const;
  [[nodiscard]] ::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE release_user_net();
  ::nsjail::NsJailConfig_UserNet* PROTOBUF_NONNULL mutable_user_net();
  void set_allocated_user_net(::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_user_net(::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE value);
  ::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE unsafe_arena_release_user_net();

  private:
  const ::nsjail::NsJailConfig_UserNet& _internal_user_net() const;
  ::nsjail::NsJailConfig_UserNet* PROTOBUF_NONNULL _internal_mutable_user_net();

  public:
  // optional .nsjail.Exe exec_bin = 96;
  [[nodiscard]] bool has_exec_bin()
      const;
  void clear_exec_bin() ;
  [[nodiscard]] const ::nsjail::Exe& exec_bin() const;
  [[nodiscard]] ::nsjail::Exe* PROTOBUF_NULLABLE release_exec_bin();
  ::nsjail::Exe* PROTOBUF_NONNULL mutable_exec_bin();
  void set_allocated_exec_bin(::nsjail::Exe* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_exec_bin(::nsjail::Exe* PROTOBUF_NULLABLE value);
  ::nsjail::Exe* PROTOBUF_NULLABLE unsafe_arena_release_exec_bin();

  private:
  const ::nsjail::Exe& _internal_exec_bin() const;
  ::nsjail::Exe* PROTOBUF_NONNULL _internal_mutable_exec_bin();

  public:
  // optional .nsjail.RLimit rlimit_core_type = 32 [default = VALUE];
  [[nodiscard]] bool has_rlimit_core_type()
      const;
  void clear_rlimit_core_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_core_type() const;
  void set_rlimit_core_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_core_type() const;
  void _internal_set_rlimit_core_type(::nsjail::RLimit value);

  public:
  // optional .nsjail.RLimit rlimit_cpu_type = 34 [default = VALUE];
  [[nodiscard]] bool has_rlimit_cpu_type()
      const;
  void clear_rlimit_cpu_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_cpu_type() const;
  void set_rlimit_cpu_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_cpu_type() const;
  void _internal_set_rlimit_cpu_type(::nsjail::RLimit value);

  public:
  // optional .nsjail.RLimit rlimit_fsize_type = 36 [default = VALUE];
  [[nodiscard]] bool has_rlimit_fsize_type()
      const;
  void clear_rlimit_fsize_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_fsize_type() const;
  void set_rlimit_fsize_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_fsize_type() const;
  void _internal_set_rlimit_fsize_type(::nsjail::RLimit value);

  public:
  // optional .nsjail.RLimit rlimit_nofile_type = 38 [default = VALUE];
  [[nodiscard]] bool has_rlimit_nofile_type()
      const;
  void clear_rlimit_nofile_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_nofile_type() const;
  void set_rlimit_nofile_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_nofile_type() const;
  void _internal_set_rlimit_nofile_type(::nsjail::RLimit value);

  public:
  // optional uint64 rlimit_rtprio = 45 [default = 0];
  [[nodiscard]] bool has_rlimit_rtprio()
      const;
  void clear_rlimit_rtprio() ;
  [[nodiscard]] ::uint64_t rlimit_rtprio() const;
  void set_rlimit_rtprio(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_rtprio() const;
  void _internal_set_rlimit_rtprio(::uint64_t value);

  public:
  // optional bool disable_rl = 49 [default = false];
  [[nodiscard]] bool has_disable_rl()
      const;
  void clear_disable_rl() ;
  [[nodiscard]] bool disable_rl() const;
  void set_disable_rl(bool value);

  private:
  bool _internal_disable_rl() const;
  void _internal_set_disable_rl(bool value);

  public:
  // optional bool persona_addr_compat_layout = 50 [default = false];
  [[nodiscard]] bool has_persona_addr_compat_layout()
      const;
  void clear_persona_addr_compat_layout() ;
  [[nodiscard]] bool persona_addr_compat_layout() const;
  void set_persona_addr_compat_layout(bool value);

  private:
  bool _internal_persona_addr_compat_layout() const;
  void _internal_set_persona_addr_compat_layout(bool value);

  public:
  // optional bool persona_mmap_page_zero = 51 [default = false];
  [[nodiscard]] bool has_persona_mmap_page_zero()
      const;
  void clear_persona_mmap_page_zero() ;
  [[nodiscard]] bool persona_mmap_page_zero() const;
  void set_persona_mmap_page_zero(bool value);

  private:
  bool _internal_persona_mmap_page_zero() const;
  void _internal_set_persona_mmap_page_zero(bool value);

  public:
  // optional bool persona_read_implies_exec = 52 [default = false];
  [[nodiscard]] bool has_persona_read_implies_exec()
      const;
  void clear_persona_read_implies_exec() ;
  [[nodiscard]] bool persona_read_implies_exec() const;
  void set_persona_read_implies_exec(bool value);

  private:
  bool _internal_persona_read_implies_exec() const;
  void _internal_set_persona_read_implies_exec(bool value);

  public:
  // optional bool persona_addr_limit_3gb = 53 [default = false];
  [[nodiscard]] bool has_persona_addr_limit_3gb()
      const;
  void clear_persona_addr_limit_3gb() ;
  [[nodiscard]] bool persona_addr_limit_3gb() const;
  void set_persona_addr_limit_3gb(bool value);

  private:
  bool _internal_persona_addr_limit_3gb() const;
  void _internal_set_persona_addr_limit_3gb(bool value);

  public:
  // optional bool persona_addr_no_randomize = 54 [default = false];
  [[nodiscard]] bool has_persona_addr_no_randomize()
      const;
  void clear_persona_addr_no_randomize() ;
  [[nodiscard]] bool persona_addr_no_randomize() const;
  void set_persona_addr_no_randomize(bool value);

  private:
  bool _internal_persona_addr_no_randomize() const;
  void _internal_set_persona_addr_no_randomize(bool value);

  public:
  // optional bool clone_newtime = 62 [default = false];
  [[nodiscard]] bool has_clone_newtime()
      const;
  void clear_clone_newtime() ;
  [[nodiscard]] bool clone_newtime() const;
  void set_clone_newtime(bool value);

  private:
  bool _internal_clone_newtime() const;
  void _internal_set_clone_newtime(bool value);

  public:
  // optional bool mount_proc = 65 [default = false];
  [[nodiscard]] bool has_mount_proc()
      const;
  void clear_mount_proc() ;
  [[nodiscard]] bool mount_proc() const;
  void set_mount_proc(bool value);

  private:
  bool _internal_mount_proc() const;
  void _internal_set_mount_proc(bool value);

  public:
  // optional uint64 cgroup_mem_max = 70 [default = 0];
  [[nodiscard]] bool has_cgroup_mem_max()
      const;
  void clear_cgroup_mem_max() ;
  [[nodiscard]] ::uint64_t cgroup_mem_max() const;
  void set_cgroup_mem_max(::uint64_t value);

  private:
  ::uint64_t _internal_cgroup_mem_max() const;
  void _internal_set_cgroup_mem_max(::uint64_t value);

  public:
  // optional uint64 cgroup_mem_memsw_max = 71 [default = 0];
  [[nodiscard]] bool has_cgroup_mem_memsw_max()
      const;
  void clear_cgroup_mem_memsw_max() ;
  [[nodiscard]] ::uint64_t cgroup_mem_memsw_max() const;
  void set_cgroup_mem_memsw_max(::uint64_t value);

  private:
  ::uint64_t _internal_cgroup_mem_memsw_max() const;
  void _internal_set_cgroup_mem_memsw_max(::uint64_t value);

  public:
  // optional uint64 cgroup_pids_max = 75 [default = 0];
  [[nodiscard]] bool has_cgroup_pids_max()
      const;
  void clear_cgroup_pids_max() ;
  [[nodiscard]] ::uint64_t cgroup_pids_max() const;
  void set_cgroup_pids_max(::uint64_t value);

  private:
  ::uint64_t _internal_cgroup_pids_max() const;
  void _internal_set_cgroup_pids_max(::uint64_t value);

  public:
  // optional uint32 cgroup_net_cls_classid = 78 [default = 0];
  [[nodiscard]] bool has_cgroup_net_cls_classid()
      const;
  void clear_cgroup_net_cls_classid() ;
  [[nodiscard]] ::uint32_t cgroup_net_cls_classid() const;
  void set_cgroup_net_cls_classid(::uint32_t value);

  private:
  ::uint32_t _internal_cgroup_net_cls_classid() const;
  void _internal_set_cgroup_net_cls_classid(::uint32_t value);

  public:
  // optional uint32 cgroup_cpu_ms_per_sec = 81 [default = 0];
  [[nodiscard]] bool has_cgroup_cpu_ms_per_sec()
      const;
  void clear_cgroup_cpu_ms_per_sec() ;
  [[nodiscard]] ::uint32_t cgroup_cpu_ms_per_sec() const;
  void set_cgroup_cpu_ms_per_sec(::uint32_t value);

  private:
  ::uint32_t _internal_cgroup_cpu_ms_per_sec() const;
  void _internal_set_cgroup_cpu_ms_per_sec(::uint32_t value);

  public:
  // optional bool seccomp_log = 69 [default = false];
  [[nodiscard]] bool has_seccomp_log()
      const;
  void clear_seccomp_log() ;
  [[nodiscard]] bool seccomp_log() const;
  void set_seccomp_log(bool value);

  private:
  bool _internal_seccomp_log() const;
  void _internal_set_seccomp_log(bool value);

  public:
  // optional bool use_cgroupv2 = 85 [default = false];
  [[nodiscard]] bool has_use_cgroupv2()
      const;
  void clear_use_cgroupv2() ;
  [[nodiscard]] bool use_cgroupv2() const;
  void set_use_cgroupv2(bool value);

  private:
  bool _internal_use_cgroupv2() const;
  void _internal_set_use_cgroupv2(bool value);

  public:
  // optional bool detect_cgroupv2 = 86 [default = false];
  [[nodiscard]] bool has_detect_cgroupv2()
      const;
  void clear_detect_cgroupv2() ;
  [[nodiscard]] bool detect_cgroupv2() const;
  void set_detect_cgroupv2(bool value);

  private:
  bool _internal_detect_cgroupv2() const;
  void _internal_set_detect_cgroupv2(bool value);

  public:
  // optional bool iface_no_lo = 87 [default = false];
  [[nodiscard]] bool has_iface_no_lo()
      const;
  void clear_iface_no_lo() ;
  [[nodiscard]] bool iface_no_lo() const;
  void set_iface_no_lo(bool value);

  private:
  bool _internal_iface_no_lo() const;
  void _internal_set_iface_no_lo(bool value);

  public:
  // optional bool clone_newipc = 59 [default = true];
  [[nodiscard]] bool has_clone_newipc()
      const;
  void clear_clone_newipc() ;
  [[nodiscard]] bool clone_newipc() const;
  void set_clone_newipc(bool value);

  private:
  bool _internal_clone_newipc() const;
  void _internal_set_clone_newipc(bool value);

  public:
  // optional bool clone_newuts = 60 [default = true];
  [[nodiscard]] bool has_clone_newuts()
      const;
  void clear_clone_newuts() ;
  [[nodiscard]] bool clone_newuts() const;
  void set_clone_newuts(bool value);

  private:
  bool _internal_clone_newuts() const;
  void _internal_set_clone_newuts(bool value);

  public:
  // optional bool clone_newcgroup = 61 [default = true];
  [[nodiscard]] bool has_clone_newcgroup()
      const;
  void clear_clone_newcgroup() ;
  [[nodiscard]] bool clone_newcgroup() const;
  void set_clone_newcgroup(bool value);

  private:
  bool _internal_clone_newcgroup() const;
  void _internal_set_clone_newcgroup(bool value);

  public:
  // optional uint64 rlimit_cpu = 33 [default = 600];
  [[nodiscard]] bool has_rlimit_cpu()
      const;
  void clear_rlimit_cpu() ;
  [[nodiscard]] ::uint64_t rlimit_cpu() const;
  void set_rlimit_cpu(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_cpu() const;
  void _internal_set_rlimit_cpu(::uint64_t value);

  public:
  // optional uint64 rlimit_fsize = 35 [default = 1];
  [[nodiscard]] bool has_rlimit_fsize()
      const;
  void clear_rlimit_fsize() ;
  [[nodiscard]] ::uint64_t rlimit_fsize() const;
  void set_rlimit_fsize(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_fsize() const;
  void _internal_set_rlimit_fsize(::uint64_t value);

  public:
  // optional uint64 rlimit_nofile = 37 [default = 32];
  [[nodiscard]] bool has_rlimit_nofile()
      const;
  void clear_rlimit_nofile() ;
  [[nodiscard]] ::uint64_t rlimit_nofile() const;
  void set_rlimit_nofile(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_nofile() const;
  void _internal_set_rlimit_nofile(::uint64_t value);

  public:
  // optional uint64 rlimit_nproc = 39 [default = 1024];
  [[nodiscard]] bool has_rlimit_nproc()
      const;
  void clear_rlimit_nproc() ;
  [[nodiscard]] ::uint64_t rlimit_nproc() const;
  void set_rlimit_nproc(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_nproc() const;
  void _internal_set_rlimit_nproc(::uint64_t value);

  public:
  // optional uint64 rlimit_stack = 41 [default = 8];
  [[nodiscard]] bool has_rlimit_stack()
      const;
  void clear_rlimit_stack() ;
  [[nodiscard]] ::uint64_t rlimit_stack() const;
  void set_rlimit_stack(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_stack() const;
  void _internal_set_rlimit_stack(::uint64_t value);

  public:
  // optional .nsjail.RLimit rlimit_nproc_type = 40 [default = SOFT];
  [[nodiscard]] bool has_rlimit_nproc_type()
      const;
  void clear_rlimit_nproc_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_nproc_type() const;
  void set_rlimit_nproc_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_nproc_type() const;
  void _internal_set_rlimit_nproc_type(::nsjail::RLimit value);

  public:
  // optional .nsjail.RLimit rlimit_stack_type = 42 [default = SOFT];
  [[nodiscard]] bool has_rlimit_stack_type()
      const;
  void clear_rlimit_stack_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_stack_type() const;
  void set_rlimit_stack_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_stack_type() const;
  void _internal_set_rlimit_stack_type(::nsjail::RLimit value);

  public:
  // optional uint64 rlimit_memlock = 43 [default = 64];
  [[nodiscard]] bool has_rlimit_memlock()
      const;
  void clear_rlimit_memlock() ;
  [[nodiscard]] ::uint64_t rlimit_memlock() const;
  void set_rlimit_memlock(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_memlock() const;
  void _internal_set_rlimit_memlock(::uint64_t value);

  public:
  // optional .nsjail.RLimit rlimit_memlock_type = 44 [default = SOFT];
  [[nodiscard]] bool has_rlimit_memlock_type()
      const;
  void clear_rlimit_memlock_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_memlock_type() const;
  void set_rlimit_memlock_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_memlock_type() const;
  void _internal_set_rlimit_memlock_type(::nsjail::RLimit value);

  public:
  // optional .nsjail.RLimit rlimit_rtprio_type = 46 [default = SOFT];
  [[nodiscard]] bool has_rlimit_rtprio_type()
      const;
  void clear_rlimit_rtprio_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_rtprio_type() const;
  void set_rlimit_rtprio_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_rtprio_type() const;
  void _internal_set_rlimit_rtprio_type(::nsjail::RLimit value);

  public:
  // optional uint64 rlimit_msgqueue = 47 [default = 1024];
  [[nodiscard]] bool has_rlimit_msgqueue()
      const;
  void clear_rlimit_msgqueue() ;
  [[nodiscard]] ::uint64_t rlimit_msgqueue() const;
  void set_rlimit_msgqueue(::uint64_t value);

  private:
  ::uint64_t _internal_rlimit_msgqueue() const;
  void _internal_set_rlimit_msgqueue(::uint64_t value);

  public:
  // optional .nsjail.RLimit rlimit_msgqueue_type = 48 [default = SOFT];
  [[nodiscard]] bool has_rlimit_msgqueue_type()
      const;
  void clear_rlimit_msgqueue_type() ;
  [[nodiscard]] ::nsjail::RLimit rlimit_msgqueue_type() const;
  void set_rlimit_msgqueue_type(::nsjail::RLimit value);

  private:
  ::nsjail::RLimit _internal_rlimit_msgqueue_type() const;
  void _internal_set_rlimit_msgqueue_type(::nsjail::RLimit value);

  public:
  // optional bool clone_newnet = 55 [default = true];
  [[nodiscard]] bool has_clone_newnet()
      const;
  void clear_clone_newnet() ;
  [[nodiscard]] bool clone_newnet() const;
  void set_clone_newnet(bool value);

  private:
  bool _internal_clone_newnet() const;
  void _internal_set_clone_newnet(bool value);

  public:
  // optional bool clone_newuser = 56 [default = true];
  [[nodiscard]] bool has_clone_newuser()
      const;
  void clear_clone_newuser() ;
  [[nodiscard]] bool clone_newuser() const;
  void set_clone_newuser(bool value);

  private:
  bool _internal_clone_newuser() const;
  void _internal_set_clone_newuser(bool value);

  public:
  // optional bool clone_newns = 57 [default = true];
  [[nodiscard]] bool has_clone_newns()
      const;
  void clear_clone_newns() ;
  [[nodiscard]] bool clone_newns() const;
  void set_clone_newns(bool value);

  private:
  bool _internal_clone_newns() const;
  void _internal_set_clone_newns(bool value);

  public:
  // optional bool clone_newpid = 58 [default = true];
  [[nodiscard]] bool has_clone_newpid()
      const;
  void clear_clone_newpid() ;
  [[nodiscard]] bool clone_newpid() const;
  void set_clone_newpid(bool value);

  private:
  bool _internal_clone_newpid() const;
  void _internal_set_clone_newpid(bool value);

  public:
  // optional int64 cgroup_mem_swap_max = 72 [default = -1];
  [[nodiscard]] bool has_cgroup_mem_swap_max()
      const;
  void clear_cgroup_mem_swap_max() ;
  [[nodiscard]] ::int64_t cgroup_mem_swap_max() const;
  void set_cgroup_mem_swap_max(::int64_t value);

  private:
  ::int64_t _internal_cgroup_mem_swap_max() const;
  void _internal_set_cgroup_mem_swap_max(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:nsjail.NsJailConfig)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 96,
                          17, 0,
                          13>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const NsJailConfig& from_msg);
    ::google::protobuf::internal::HasBits<3> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> description_;
    ::google::protobuf::RepeatedPtrField<::std::string> envar_;
    ::google::protobuf::RepeatedPtrField<::std::string> cap_;
    ::google::protobuf::RepeatedField<::int32_t> pass_fd_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_hostname_;
    ::google::protobuf::internal::ArenaStringPtr hostname_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cwd_;
    ::google::protobuf::internal::ArenaStringPtr cwd_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_bindhost_;
    ::google::protobuf::internal::ArenaStringPtr bindhost_;
    ::google::protobuf::internal::ArenaStringPtr log_file_;
    ::uint32_t port_;
    ::uint32_t max_conns_;
    ::uint32_t max_conns_per_ip_;
    ::uint32_t max_cpus_;
    bool no_pivotroot_;
    bool daemon_;
    bool keep_env_;
    bool keep_caps_;
    ::int32_t log_fd_;
    int log_level_;
    bool silent_;
    bool skip_setsid_;
    bool stderr_to_null_;
    bool disable_no_new_privs_;
    bool forward_signals_;
    bool disable_tsc_;
    int rlimit_as_type_;
    ::uint64_t rlimit_core_;
    int mode_;
    ::uint32_t time_limit_;
    ::uint64_t rlimit_as_;
    ::int32_t nice_level_;
    ::google::protobuf::RepeatedPtrField< ::nsjail::IdMap > uidmap_;
    ::google::protobuf::RepeatedPtrField< ::nsjail::IdMap > gidmap_;
    ::google::protobuf::RepeatedPtrField< ::nsjail::MountPt > mount_;
    ::google::protobuf::RepeatedPtrField<::std::string> seccomp_string_;
    ::google::protobuf::RepeatedPtrField<::std::string> iface_own_;
    ::google::protobuf::internal::ArenaStringPtr seccomp_policy_file_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_mem_mount_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_mem_mount_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_mem_parent_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_mem_parent_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_pids_mount_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_pids_mount_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_pids_parent_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_pids_parent_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_net_cls_mount_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_net_cls_mount_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_net_cls_parent_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_net_cls_parent_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_cpu_mount_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_cpu_mount_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroup_cpu_parent_;
    ::google::protobuf::internal::ArenaStringPtr cgroup_cpu_parent_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_cgroupv2_mount_;
    ::google::protobuf::internal::ArenaStringPtr cgroupv2_mount_;
    ::google::protobuf::internal::ArenaStringPtr macvlan_iface_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_macvlan_vs_ip_;
    ::google::protobuf::internal::ArenaStringPtr macvlan_vs_ip_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_macvlan_vs_nm_;
    ::google::protobuf::internal::ArenaStringPtr macvlan_vs_nm_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_macvlan_vs_gw_;
    ::google::protobuf::internal::ArenaStringPtr macvlan_vs_gw_;
    ::google::protobuf::internal::ArenaStringPtr macvlan_vs_ma_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_macvlan_vs_mo_;
    ::google::protobuf::internal::ArenaStringPtr macvlan_vs_mo_;
    ::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE user_net_;
    ::nsjail::Exe* PROTOBUF_NULLABLE exec_bin_;
    int rlimit_core_type_;
    int rlimit_cpu_type_;
    int rlimit_fsize_type_;
    int rlimit_nofile_type_;
    ::uint64_t rlimit_rtprio_;
    bool disable_rl_;
    bool persona_addr_compat_layout_;
    bool persona_mmap_page_zero_;
    bool persona_read_implies_exec_;
    bool persona_addr_limit_3gb_;
    bool persona_addr_no_randomize_;
    bool clone_newtime_;
    bool mount_proc_;
    ::uint64_t cgroup_mem_max_;
    ::uint64_t cgroup_mem_memsw_max_;
    ::uint64_t cgroup_pids_max_;
    ::uint32_t cgroup_net_cls_classid_;
    ::uint32_t cgroup_cpu_ms_per_sec_;
    bool seccomp_log_;
    bool use_cgroupv2_;
    bool detect_cgroupv2_;
    bool iface_no_lo_;
    bool clone_newipc_;
    bool clone_newuts_;
    bool clone_newcgroup_;
    ::uint64_t rlimit_cpu_;
    ::uint64_t rlimit_fsize_;
    ::uint64_t rlimit_nofile_;
    ::uint64_t rlimit_nproc_;
    ::uint64_t rlimit_stack_;
    int rlimit_nproc_type_;
    int rlimit_stack_type_;
    ::uint64_t rlimit_memlock_;
    int rlimit_memlock_type_;
    int rlimit_rtprio_type_;
    ::uint64_t rlimit_msgqueue_;
    int rlimit_msgqueue_type_;
    bool clone_newnet_;
    bool clone_newuser_;
    bool clone_newns_;
    bool clone_newpid_;
    ::int64_t cgroup_mem_swap_max_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_config_2eproto;
};

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




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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// IdMap

// optional string inside_id = 1 [default = ""];
inline bool IdMap::has_inside_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void IdMap::clear_inside_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inside_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& IdMap::inside_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.IdMap.inside_id)
  return _internal_inside_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void IdMap::set_inside_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.inside_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.IdMap.inside_id)
}
inline ::std::string* PROTOBUF_NONNULL IdMap::mutable_inside_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_inside_id();
  // @@protoc_insertion_point(field_mutable:nsjail.IdMap.inside_id)
  return _s;
}
inline const ::std::string& IdMap::_internal_inside_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inside_id_.Get();
}
inline void IdMap::_internal_set_inside_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inside_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL IdMap::_internal_mutable_inside_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.inside_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE IdMap::release_inside_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.IdMap.inside_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.inside_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.inside_id_.Set("", GetArena());
  }
  return released;
}
inline void IdMap::set_allocated_inside_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.inside_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.inside_id_.IsDefault()) {
    _impl_.inside_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.IdMap.inside_id)
}

// optional string outside_id = 2 [default = ""];
inline bool IdMap::has_outside_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void IdMap::clear_outside_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.outside_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& IdMap::outside_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.IdMap.outside_id)
  return _internal_outside_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void IdMap::set_outside_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.outside_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.IdMap.outside_id)
}
inline ::std::string* PROTOBUF_NONNULL IdMap::mutable_outside_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_outside_id();
  // @@protoc_insertion_point(field_mutable:nsjail.IdMap.outside_id)
  return _s;
}
inline const ::std::string& IdMap::_internal_outside_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.outside_id_.Get();
}
inline void IdMap::_internal_set_outside_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.outside_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL IdMap::_internal_mutable_outside_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.outside_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE IdMap::release_outside_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.IdMap.outside_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.outside_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.outside_id_.Set("", GetArena());
  }
  return released;
}
inline void IdMap::set_allocated_outside_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.outside_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.outside_id_.IsDefault()) {
    _impl_.outside_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.IdMap.outside_id)
}

// optional uint32 count = 3 [default = 1];
inline bool IdMap::has_count() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void IdMap::clear_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.count_ = 1u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t IdMap::count() const {
  // @@protoc_insertion_point(field_get:nsjail.IdMap.count)
  return _internal_count();
}
inline void IdMap::set_count(::uint32_t value) {
  _internal_set_count(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:nsjail.IdMap.count)
}
inline ::uint32_t IdMap::_internal_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.count_;
}
inline void IdMap::_internal_set_count(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.count_ = value;
}

// optional bool use_newidmap = 4 [default = false];
inline bool IdMap::has_use_newidmap() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void IdMap::clear_use_newidmap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_newidmap_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline bool IdMap::use_newidmap() const {
  // @@protoc_insertion_point(field_get:nsjail.IdMap.use_newidmap)
  return _internal_use_newidmap();
}
inline void IdMap::set_use_newidmap(bool value) {
  _internal_set_use_newidmap(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:nsjail.IdMap.use_newidmap)
}
inline bool IdMap::_internal_use_newidmap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_newidmap_;
}
inline void IdMap::_internal_set_use_newidmap(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_newidmap_ = value;
}

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

// MountPt

// optional string src = 1 [default = ""];
inline bool MountPt::has_src() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void MountPt::clear_src() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.src_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& MountPt::src() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.src)
  return _internal_src();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_src(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.src_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.src)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_src()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_src();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.src)
  return _s;
}
inline const ::std::string& MountPt::_internal_src() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.src_.Get();
}
inline void MountPt::_internal_set_src(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.src_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_src() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.src_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_src() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.src)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.src_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.src_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_src(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.src_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.src_.IsDefault()) {
    _impl_.src_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.src)
}

// optional string prefix_src_env = 2 [default = ""];
inline bool MountPt::has_prefix_src_env() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void MountPt::clear_prefix_src_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prefix_src_env_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& MountPt::prefix_src_env() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.prefix_src_env)
  return _internal_prefix_src_env();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_prefix_src_env(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.prefix_src_env_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.prefix_src_env)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_prefix_src_env()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_prefix_src_env();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.prefix_src_env)
  return _s;
}
inline const ::std::string& MountPt::_internal_prefix_src_env() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.prefix_src_env_.Get();
}
inline void MountPt::_internal_set_prefix_src_env(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prefix_src_env_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_prefix_src_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.prefix_src_env_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_prefix_src_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.prefix_src_env)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.prefix_src_env_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.prefix_src_env_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_prefix_src_env(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.prefix_src_env_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.prefix_src_env_.IsDefault()) {
    _impl_.prefix_src_env_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.prefix_src_env)
}

// optional bytes src_content = 3 [default = ""];
inline bool MountPt::has_src_content() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void MountPt::clear_src_content() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.src_content_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& MountPt::src_content() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.src_content)
  return _internal_src_content();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_src_content(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.src_content_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.src_content)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_src_content()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_src_content();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.src_content)
  return _s;
}
inline const ::std::string& MountPt::_internal_src_content() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.src_content_.Get();
}
inline void MountPt::_internal_set_src_content(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.src_content_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_src_content() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.src_content_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_src_content() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.src_content)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.src_content_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.src_content_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_src_content(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.src_content_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.src_content_.IsDefault()) {
    _impl_.src_content_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.src_content)
}

// required string dst = 4 [default = ""];
inline bool MountPt::has_dst() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void MountPt::clear_dst() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dst_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& MountPt::dst() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.dst)
  return _internal_dst();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_dst(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.dst_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.dst)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_dst()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_dst();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.dst)
  return _s;
}
inline const ::std::string& MountPt::_internal_dst() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dst_.Get();
}
inline void MountPt::_internal_set_dst(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dst_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_dst() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.dst_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_dst() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.dst)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.dst_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.dst_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_dst(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.dst_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.dst_.IsDefault()) {
    _impl_.dst_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.dst)
}

// optional string prefix_dst_env = 5 [default = ""];
inline bool MountPt::has_prefix_dst_env() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void MountPt::clear_prefix_dst_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prefix_dst_env_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& MountPt::prefix_dst_env() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.prefix_dst_env)
  return _internal_prefix_dst_env();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_prefix_dst_env(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.prefix_dst_env_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.prefix_dst_env)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_prefix_dst_env()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_prefix_dst_env();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.prefix_dst_env)
  return _s;
}
inline const ::std::string& MountPt::_internal_prefix_dst_env() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.prefix_dst_env_.Get();
}
inline void MountPt::_internal_set_prefix_dst_env(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prefix_dst_env_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_prefix_dst_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.prefix_dst_env_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_prefix_dst_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.prefix_dst_env)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.prefix_dst_env_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.prefix_dst_env_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_prefix_dst_env(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.prefix_dst_env_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.prefix_dst_env_.IsDefault()) {
    _impl_.prefix_dst_env_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.prefix_dst_env)
}

// optional string fstype = 6 [default = ""];
inline bool MountPt::has_fstype() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void MountPt::clear_fstype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fstype_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& MountPt::fstype() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.fstype)
  return _internal_fstype();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_fstype(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.fstype_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.fstype)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_fstype()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_fstype();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.fstype)
  return _s;
}
inline const ::std::string& MountPt::_internal_fstype() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fstype_.Get();
}
inline void MountPt::_internal_set_fstype(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fstype_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_fstype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.fstype_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_fstype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.fstype)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.fstype_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.fstype_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_fstype(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.fstype_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.fstype_.IsDefault()) {
    _impl_.fstype_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.fstype)
}

// optional string options = 7 [default = ""];
inline bool MountPt::has_options() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void MountPt::clear_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.options_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& MountPt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.options)
  return _internal_options();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void MountPt::set_options(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.options_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.MountPt.options)
}
inline ::std::string* PROTOBUF_NONNULL MountPt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_options();
  // @@protoc_insertion_point(field_mutable:nsjail.MountPt.options)
  return _s;
}
inline const ::std::string& MountPt::_internal_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.options_.Get();
}
inline void MountPt::_internal_set_options(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.options_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL MountPt::_internal_mutable_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.options_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE MountPt::release_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.MountPt.options)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.options_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.options_.Set("", GetArena());
  }
  return released;
}
inline void MountPt::set_allocated_options(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.options_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.options_.IsDefault()) {
    _impl_.options_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.MountPt.options)
}

// optional bool is_bind = 8 [default = false];
inline bool MountPt::has_is_bind() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void MountPt::clear_is_bind() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_bind_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline bool MountPt::is_bind() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.is_bind)
  return _internal_is_bind();
}
inline void MountPt::set_is_bind(bool value) {
  _internal_set_is_bind(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.is_bind)
}
inline bool MountPt::_internal_is_bind() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.is_bind_;
}
inline void MountPt::_internal_set_is_bind(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_bind_ = value;
}

// optional bool rw = 9 [default = false];
inline bool MountPt::has_rw() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void MountPt::clear_rw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rw_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline bool MountPt::rw() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.rw)
  return _internal_rw();
}
inline void MountPt::set_rw(bool value) {
  _internal_set_rw(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.rw)
}
inline bool MountPt::_internal_rw() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rw_;
}
inline void MountPt::_internal_set_rw(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rw_ = value;
}

// optional bool is_dir = 10;
inline bool MountPt::has_is_dir() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void MountPt::clear_is_dir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_dir_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline bool MountPt::is_dir() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.is_dir)
  return _internal_is_dir();
}
inline void MountPt::set_is_dir(bool value) {
  _internal_set_is_dir(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.is_dir)
}
inline bool MountPt::_internal_is_dir() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.is_dir_;
}
inline void MountPt::_internal_set_is_dir(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_dir_ = value;
}

// optional bool mandatory = 11 [default = true];
inline bool MountPt::has_mandatory() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void MountPt::clear_mandatory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mandatory_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline bool MountPt::mandatory() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.mandatory)
  return _internal_mandatory();
}
inline void MountPt::set_mandatory(bool value) {
  _internal_set_mandatory(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.mandatory)
}
inline bool MountPt::_internal_mandatory() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mandatory_;
}
inline void MountPt::_internal_set_mandatory(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mandatory_ = value;
}

// optional bool is_symlink = 12 [default = false];
inline bool MountPt::has_is_symlink() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void MountPt::clear_is_symlink() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_symlink_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline bool MountPt::is_symlink() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.is_symlink)
  return _internal_is_symlink();
}
inline void MountPt::set_is_symlink(bool value) {
  _internal_set_is_symlink(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.is_symlink)
}
inline bool MountPt::_internal_is_symlink() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.is_symlink_;
}
inline void MountPt::_internal_set_is_symlink(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_symlink_ = value;
}

// optional bool nosuid = 13 [default = false];
inline bool MountPt::has_nosuid() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void MountPt::clear_nosuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nosuid_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline bool MountPt::nosuid() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.nosuid)
  return _internal_nosuid();
}
inline void MountPt::set_nosuid(bool value) {
  _internal_set_nosuid(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.nosuid)
}
inline bool MountPt::_internal_nosuid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.nosuid_;
}
inline void MountPt::_internal_set_nosuid(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nosuid_ = value;
}

// optional bool nodev = 14 [default = false];
inline bool MountPt::has_nodev() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void MountPt::clear_nodev() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nodev_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline bool MountPt::nodev() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.nodev)
  return _internal_nodev();
}
inline void MountPt::set_nodev(bool value) {
  _internal_set_nodev(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.nodev)
}
inline bool MountPt::_internal_nodev() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.nodev_;
}
inline void MountPt::_internal_set_nodev(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nodev_ = value;
}

// optional bool noexec = 15 [default = false];
inline bool MountPt::has_noexec() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void MountPt::clear_noexec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.noexec_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline bool MountPt::noexec() const {
  // @@protoc_insertion_point(field_get:nsjail.MountPt.noexec)
  return _internal_noexec();
}
inline void MountPt::set_noexec(bool value) {
  _internal_set_noexec(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:nsjail.MountPt.noexec)
}
inline bool MountPt::_internal_noexec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.noexec_;
}
inline void MountPt::_internal_set_noexec(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.noexec_ = value;
}

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

// Exe

// required string path = 1;
inline bool Exe::has_path() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void Exe::clear_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.path_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& Exe::path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.Exe.path)
  return _internal_path();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Exe::set_path(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.Exe.path)
}
inline ::std::string* PROTOBUF_NONNULL Exe::mutable_path()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_path();
  // @@protoc_insertion_point(field_mutable:nsjail.Exe.path)
  return _s;
}
inline const ::std::string& Exe::_internal_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.path_.Get();
}
inline void Exe::_internal_set_path(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.path_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Exe::_internal_mutable_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.path_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Exe::release_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.Exe.path)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.path_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.path_.Set("", GetArena());
  }
  return released;
}
inline void Exe::set_allocated_path(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.path_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.path_.IsDefault()) {
    _impl_.path_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.Exe.path)
}

// repeated string arg = 2;
inline int Exe::_internal_arg_size() const {
  return _internal_arg().size();
}
inline int Exe::arg_size() const {
  return _internal_arg_size();
}
inline void Exe::clear_arg() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.arg_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL Exe::add_arg()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_arg()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:nsjail.Exe.arg)
  return _s;
}
inline const ::std::string& Exe::arg(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.Exe.arg)
  return _internal_arg().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL Exe::mutable_arg(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.Exe.arg)
  return _internal_mutable_arg()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void Exe::set_arg(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_arg()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:nsjail.Exe.arg)
}
template <typename Arg_, typename... Args_>
inline void Exe::add_arg(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_arg(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:nsjail.Exe.arg)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& Exe::arg()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.Exe.arg)
  return _internal_arg();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
Exe::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.Exe.arg)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_arg();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
Exe::_internal_arg() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.arg_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
Exe::_internal_mutable_arg() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.arg_;
}

// optional string arg0 = 3;
inline bool Exe::has_arg0() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void Exe::clear_arg0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.arg0_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& Exe::arg0() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.Exe.arg0)
  return _internal_arg0();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Exe::set_arg0(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.arg0_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.Exe.arg0)
}
inline ::std::string* PROTOBUF_NONNULL Exe::mutable_arg0()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_arg0();
  // @@protoc_insertion_point(field_mutable:nsjail.Exe.arg0)
  return _s;
}
inline const ::std::string& Exe::_internal_arg0() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.arg0_.Get();
}
inline void Exe::_internal_set_arg0(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.arg0_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Exe::_internal_mutable_arg0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.arg0_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Exe::release_arg0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.Exe.arg0)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.arg0_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.arg0_.Set("", GetArena());
  }
  return released;
}
inline void Exe::set_allocated_arg0(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.arg0_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.arg0_.IsDefault()) {
    _impl_.arg0_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.Exe.arg0)
}

// optional bool exec_fd = 4 [default = false];
inline bool Exe::has_exec_fd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void Exe::clear_exec_fd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_fd_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline bool Exe::exec_fd() const {
  // @@protoc_insertion_point(field_get:nsjail.Exe.exec_fd)
  return _internal_exec_fd();
}
inline void Exe::set_exec_fd(bool value) {
  _internal_set_exec_fd(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:nsjail.Exe.exec_fd)
}
inline bool Exe::_internal_exec_fd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exec_fd_;
}
inline void Exe::_internal_set_exec_fd(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_fd_ = value;
}

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

// NsJailConfig_UserNet

// optional bool enable = 1 [default = false];
inline bool NsJailConfig_UserNet::has_enable() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline bool NsJailConfig_UserNet::enable() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable)
  return _internal_enable();
}
inline void NsJailConfig_UserNet::set_enable(bool value) {
  _internal_set_enable(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable)
}
inline bool NsJailConfig_UserNet::_internal_enable() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_;
}
inline void NsJailConfig_UserNet::_internal_set_enable(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ = value;
}

// optional string ip = 2 [default = "10.255.255.2"];
inline bool NsJailConfig_UserNet::has_ip() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void NsJailConfig_UserNet::clear_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ip_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_ip_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& NsJailConfig_UserNet::ip() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.ip)
  if (_impl_.ip_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_ip_.get();
  }
  return _internal_ip();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_ip(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.ip_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.ip)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_ip()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.ip)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_ip() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ip_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_ip(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ip_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.ip_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_ip_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.ip)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.ip_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_ip(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.ip_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.ip)
}

// optional string mask = 3 [default = "255.255.255.0"];
inline bool NsJailConfig_UserNet::has_mask() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void NsJailConfig_UserNet::clear_mask() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mask_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_mask_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& NsJailConfig_UserNet::mask() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.mask)
  if (_impl_.mask_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_mask_.get();
  }
  return _internal_mask();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_mask(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.mask_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.mask)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_mask()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_mask();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.mask)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_mask() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mask_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_mask(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mask_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_mask() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.mask_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_mask_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_mask() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.mask)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  return _impl_.mask_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_mask(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.mask_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.mask)
}

// optional string gw = 4 [default = "10.255.255.1"];
inline bool NsJailConfig_UserNet::has_gw() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void NsJailConfig_UserNet::clear_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gw_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_gw_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& NsJailConfig_UserNet::gw() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.gw)
  if (_impl_.gw_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_gw_.get();
  }
  return _internal_gw();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_gw(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.gw_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.gw)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_gw()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_gw();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.gw)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_gw() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gw_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_gw(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gw_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.gw_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_gw_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.gw)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  return _impl_.gw_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_gw(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.gw_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.gw)
}

// optional string ip6 = 5 [default = "fc00::2"];
inline bool NsJailConfig_UserNet::has_ip6() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void NsJailConfig_UserNet::clear_ip6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ip6_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_ip6_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& NsJailConfig_UserNet::ip6() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.ip6)
  if (_impl_.ip6_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_ip6_.get();
  }
  return _internal_ip6();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_ip6(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.ip6_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.ip6)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_ip6()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_ip6();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.ip6)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_ip6() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ip6_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_ip6(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ip6_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_ip6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.ip6_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_ip6_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_ip6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.ip6)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  return _impl_.ip6_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_ip6(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.ip6_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.ip6)
}

// optional string mask6 = 6 [default = "64"];
inline bool NsJailConfig_UserNet::has_mask6() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void NsJailConfig_UserNet::clear_mask6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mask6_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_mask6_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& NsJailConfig_UserNet::mask6() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.mask6)
  if (_impl_.mask6_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_mask6_.get();
  }
  return _internal_mask6();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_mask6(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.mask6_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.mask6)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_mask6()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_mask6();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.mask6)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_mask6() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mask6_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_mask6(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mask6_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_mask6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.mask6_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_mask6_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_mask6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.mask6)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  return _impl_.mask6_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_mask6(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.mask6_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.mask6)
}

// optional string gw6 = 7 [default = "fc00::1"];
inline bool NsJailConfig_UserNet::has_gw6() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void NsJailConfig_UserNet::clear_gw6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gw6_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_gw6_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& NsJailConfig_UserNet::gw6() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.gw6)
  if (_impl_.gw6_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_gw6_.get();
  }
  return _internal_gw6();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_gw6(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.gw6_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.gw6)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_gw6()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_gw6();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.gw6)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_gw6() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gw6_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_gw6(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gw6_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_gw6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.gw6_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_gw6_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_gw6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.gw6)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  return _impl_.gw6_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_gw6(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.gw6_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.gw6)
}

// optional string ns_iface = 8 [default = "eth0"];
inline bool NsJailConfig_UserNet::has_ns_iface() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void NsJailConfig_UserNet::clear_ns_iface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ns_iface_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_ns_iface_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& NsJailConfig_UserNet::ns_iface() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.ns_iface)
  if (_impl_.ns_iface_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_ns_iface_.get();
  }
  return _internal_ns_iface();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_ns_iface(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.ns_iface_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.ns_iface)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_ns_iface()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_ns_iface();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.ns_iface)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_ns_iface() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ns_iface_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_ns_iface(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ns_iface_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_ns_iface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.ns_iface_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_ns_iface_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_ns_iface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.ns_iface)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  return _impl_.ns_iface_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_ns_iface(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.ns_iface_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.ns_iface)
}

// optional string tcp_ports = 9 [default = "none"];
inline bool NsJailConfig_UserNet::has_tcp_ports() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void NsJailConfig_UserNet::clear_tcp_ports() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tcp_ports_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_tcp_ports_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& NsJailConfig_UserNet::tcp_ports() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.tcp_ports)
  if (_impl_.tcp_ports_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_tcp_ports_.get();
  }
  return _internal_tcp_ports();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_tcp_ports(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.tcp_ports_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.tcp_ports)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_tcp_ports()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_tcp_ports();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.tcp_ports)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_tcp_ports() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tcp_ports_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_tcp_ports(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tcp_ports_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_tcp_ports() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.tcp_ports_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_tcp_ports_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_tcp_ports() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.tcp_ports)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  return _impl_.tcp_ports_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_tcp_ports(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.tcp_ports_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.tcp_ports)
}

// optional string udp_ports = 10 [default = "none"];
inline bool NsJailConfig_UserNet::has_udp_ports() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void NsJailConfig_UserNet::clear_udp_ports() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.udp_ports_.ClearToDefault(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_udp_ports_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::std::string& NsJailConfig_UserNet::udp_ports() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.udp_ports)
  if (_impl_.udp_ports_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_udp_ports_.get();
  }
  return _internal_udp_ports();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_udp_ports(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.udp_ports_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.udp_ports)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_udp_ports()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_udp_ports();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.udp_ports)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_udp_ports() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.udp_ports_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_udp_ports(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.udp_ports_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_udp_ports() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.udp_ports_.Mutable(::nsjail::NsJailConfig_UserNet::Impl_::_i_give_permission_to_break_this_code_default_udp_ports_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_udp_ports() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.udp_ports)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  return _impl_.udp_ports_.Release();
}
inline void NsJailConfig_UserNet::set_allocated_udp_ports(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.udp_ports_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.udp_ports)
}

// optional bool enable_ip4_dhcp = 11 [default = false];
inline bool NsJailConfig_UserNet::has_enable_ip4_dhcp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_ip4_dhcp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ip4_dhcp_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline bool NsJailConfig_UserNet::enable_ip4_dhcp() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_ip4_dhcp)
  return _internal_enable_ip4_dhcp();
}
inline void NsJailConfig_UserNet::set_enable_ip4_dhcp(bool value) {
  _internal_set_enable_ip4_dhcp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_ip4_dhcp)
}
inline bool NsJailConfig_UserNet::_internal_enable_ip4_dhcp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_ip4_dhcp_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_ip4_dhcp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ip4_dhcp_ = value;
}

// optional bool enable_dns = 12 [default = false];
inline bool NsJailConfig_UserNet::has_enable_dns() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_dns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_dns_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline bool NsJailConfig_UserNet::enable_dns() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_dns)
  return _internal_enable_dns();
}
inline void NsJailConfig_UserNet::set_enable_dns(bool value) {
  _internal_set_enable_dns(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_dns)
}
inline bool NsJailConfig_UserNet::_internal_enable_dns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_dns_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_dns(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_dns_ = value;
}

// optional string dns_forward = 13 [default = ""];
inline bool NsJailConfig_UserNet::has_dns_forward() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void NsJailConfig_UserNet::clear_dns_forward() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dns_forward_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::std::string& NsJailConfig_UserNet::dns_forward() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.dns_forward)
  return _internal_dns_forward();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig_UserNet::set_dns_forward(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.dns_forward_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.dns_forward)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::mutable_dns_forward()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_dns_forward();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.UserNet.dns_forward)
  return _s;
}
inline const ::std::string& NsJailConfig_UserNet::_internal_dns_forward() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dns_forward_.Get();
}
inline void NsJailConfig_UserNet::_internal_set_dns_forward(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dns_forward_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig_UserNet::_internal_mutable_dns_forward() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.dns_forward_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig_UserNet::release_dns_forward() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.UserNet.dns_forward)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.dns_forward_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.dns_forward_.Set("", GetArena());
  }
  return released;
}
inline void NsJailConfig_UserNet::set_allocated_dns_forward(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.dns_forward_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.dns_forward_.IsDefault()) {
    _impl_.dns_forward_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.UserNet.dns_forward)
}

// optional bool enable_tcp = 14 [default = true];
inline bool NsJailConfig_UserNet::has_enable_tcp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_tcp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_tcp_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline bool NsJailConfig_UserNet::enable_tcp() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_tcp)
  return _internal_enable_tcp();
}
inline void NsJailConfig_UserNet::set_enable_tcp(bool value) {
  _internal_set_enable_tcp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_tcp)
}
inline bool NsJailConfig_UserNet::_internal_enable_tcp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_tcp_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_tcp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_tcp_ = value;
}

// optional bool enable_udp = 15 [default = true];
inline bool NsJailConfig_UserNet::has_enable_udp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_udp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_udp_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline bool NsJailConfig_UserNet::enable_udp() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_udp)
  return _internal_enable_udp();
}
inline void NsJailConfig_UserNet::set_enable_udp(bool value) {
  _internal_set_enable_udp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_udp)
}
inline bool NsJailConfig_UserNet::_internal_enable_udp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_udp_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_udp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_udp_ = value;
}

// optional bool enable_icmp = 16 [default = true];
inline bool NsJailConfig_UserNet::has_enable_icmp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_icmp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_icmp_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline bool NsJailConfig_UserNet::enable_icmp() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_icmp)
  return _internal_enable_icmp();
}
inline void NsJailConfig_UserNet::set_enable_icmp(bool value) {
  _internal_set_enable_icmp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_icmp)
}
inline bool NsJailConfig_UserNet::_internal_enable_icmp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_icmp_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_icmp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_icmp_ = value;
}

// optional bool no_map_gw = 17 [default = false];
inline bool NsJailConfig_UserNet::has_no_map_gw() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_no_map_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.no_map_gw_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline bool NsJailConfig_UserNet::no_map_gw() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.no_map_gw)
  return _internal_no_map_gw();
}
inline void NsJailConfig_UserNet::set_no_map_gw(bool value) {
  _internal_set_no_map_gw(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.no_map_gw)
}
inline bool NsJailConfig_UserNet::_internal_no_map_gw() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.no_map_gw_;
}
inline void NsJailConfig_UserNet::_internal_set_no_map_gw(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.no_map_gw_ = value;
}

// optional bool enable_ip6_dhcp = 18 [default = false];
inline bool NsJailConfig_UserNet::has_enable_ip6_dhcp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_ip6_dhcp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ip6_dhcp_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline bool NsJailConfig_UserNet::enable_ip6_dhcp() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_ip6_dhcp)
  return _internal_enable_ip6_dhcp();
}
inline void NsJailConfig_UserNet::set_enable_ip6_dhcp(bool value) {
  _internal_set_enable_ip6_dhcp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_ip6_dhcp)
}
inline bool NsJailConfig_UserNet::_internal_enable_ip6_dhcp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_ip6_dhcp_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_ip6_dhcp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ip6_dhcp_ = value;
}

// optional bool enable_ip6_ra = 19 [default = false];
inline bool NsJailConfig_UserNet::has_enable_ip6_ra() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void NsJailConfig_UserNet::clear_enable_ip6_ra() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ip6_ra_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline bool NsJailConfig_UserNet::enable_ip6_ra() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.UserNet.enable_ip6_ra)
  return _internal_enable_ip6_ra();
}
inline void NsJailConfig_UserNet::set_enable_ip6_ra(bool value) {
  _internal_set_enable_ip6_ra(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.UserNet.enable_ip6_ra)
}
inline bool NsJailConfig_UserNet::_internal_enable_ip6_ra() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_ip6_ra_;
}
inline void NsJailConfig_UserNet::_internal_set_enable_ip6_ra(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_ip6_ra_ = value;
}

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

// NsJailConfig

// optional string name = 1 [default = ""];
inline bool NsJailConfig::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void NsJailConfig::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& NsJailConfig::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.name)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.name)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void NsJailConfig::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void NsJailConfig::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.name)
}

// repeated string description = 2;
inline int NsJailConfig::_internal_description_size() const {
  return _internal_description().size();
}
inline int NsJailConfig::description_size() const {
  return _internal_description_size();
}
inline void NsJailConfig::clear_description() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.description_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::add_description()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_description()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:nsjail.NsJailConfig.description)
  return _s;
}
inline const ::std::string& NsJailConfig::description(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.description)
  return _internal_description().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_description(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.description)
  return _internal_mutable_description()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::set_description(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_description()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.description)
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::add_description(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_description(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.description)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NsJailConfig::description()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.description)
  return _internal_description();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::mutable_description() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.description)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_description();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NsJailConfig::_internal_description() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.description_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_description() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.description_;
}

// optional .nsjail.Mode mode = 3 [default = ONCE];
inline bool NsJailConfig::has_mode() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x08000000U);
  return value;
}
inline void NsJailConfig::clear_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mode_ = 1;
  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
}
inline ::nsjail::Mode NsJailConfig::mode() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.mode)
  return _internal_mode();
}
inline void NsJailConfig::set_mode(::nsjail::Mode value) {
  _internal_set_mode(value);
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.mode)
}
inline ::nsjail::Mode NsJailConfig::_internal_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::Mode>(_impl_.mode_);
}
inline void NsJailConfig::_internal_set_mode(::nsjail::Mode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::Mode_internal_data_));
                                          _impl_.mode_ = value;
}

// optional string hostname = 4 [default = "NSJAIL"];
inline bool NsJailConfig::has_hostname() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void NsJailConfig::clear_hostname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hostname_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_hostname_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& NsJailConfig::hostname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.hostname)
  if (_impl_.hostname_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_hostname_.get();
  }
  return _internal_hostname();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_hostname(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.hostname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.hostname)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_hostname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_hostname();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.hostname)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_hostname() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.hostname_.Get();
}
inline void NsJailConfig::_internal_set_hostname(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hostname_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_hostname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.hostname_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_hostname_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_hostname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.hostname)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  return _impl_.hostname_.Release();
}
inline void NsJailConfig::set_allocated_hostname(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.hostname_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.hostname)
}

// optional string cwd = 5 [default = "/"];
inline bool NsJailConfig::has_cwd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void NsJailConfig::clear_cwd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cwd_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cwd_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& NsJailConfig::cwd() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cwd)
  if (_impl_.cwd_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cwd_.get();
  }
  return _internal_cwd();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cwd(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.cwd_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cwd)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cwd()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_cwd();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cwd)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cwd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cwd_.Get();
}
inline void NsJailConfig::_internal_set_cwd(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cwd_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cwd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cwd_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cwd_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cwd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cwd)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  return _impl_.cwd_.Release();
}
inline void NsJailConfig::set_allocated_cwd(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.cwd_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cwd)
}

// optional bool no_pivotroot = 6 [default = false];
inline bool NsJailConfig::has_no_pivotroot() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void NsJailConfig::clear_no_pivotroot() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.no_pivotroot_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline bool NsJailConfig::no_pivotroot() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.no_pivotroot)
  return _internal_no_pivotroot();
}
inline void NsJailConfig::set_no_pivotroot(bool value) {
  _internal_set_no_pivotroot(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.no_pivotroot)
}
inline bool NsJailConfig::_internal_no_pivotroot() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.no_pivotroot_;
}
inline void NsJailConfig::_internal_set_no_pivotroot(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.no_pivotroot_ = value;
}

// optional uint32 port = 7 [default = 0];
inline bool NsJailConfig::has_port() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void NsJailConfig::clear_port() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.port_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline ::uint32_t NsJailConfig::port() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.port)
  return _internal_port();
}
inline void NsJailConfig::set_port(::uint32_t value) {
  _internal_set_port(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.port)
}
inline ::uint32_t NsJailConfig::_internal_port() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.port_;
}
inline void NsJailConfig::_internal_set_port(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.port_ = value;
}

// optional string bindhost = 8 [default = "::"];
inline bool NsJailConfig::has_bindhost() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void NsJailConfig::clear_bindhost() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bindhost_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_bindhost_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& NsJailConfig::bindhost() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.bindhost)
  if (_impl_.bindhost_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_bindhost_.get();
  }
  return _internal_bindhost();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_bindhost(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.bindhost_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.bindhost)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_bindhost()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_bindhost();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.bindhost)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_bindhost() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bindhost_.Get();
}
inline void NsJailConfig::_internal_set_bindhost(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bindhost_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_bindhost() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.bindhost_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_bindhost_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_bindhost() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.bindhost)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  return _impl_.bindhost_.Release();
}
inline void NsJailConfig::set_allocated_bindhost(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.bindhost_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.bindhost)
}

// optional uint32 max_conns = 9 [default = 0];
inline bool NsJailConfig::has_max_conns() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void NsJailConfig::clear_max_conns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_conns_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline ::uint32_t NsJailConfig::max_conns() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.max_conns)
  return _internal_max_conns();
}
inline void NsJailConfig::set_max_conns(::uint32_t value) {
  _internal_set_max_conns(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.max_conns)
}
inline ::uint32_t NsJailConfig::_internal_max_conns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_conns_;
}
inline void NsJailConfig::_internal_set_max_conns(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_conns_ = value;
}

// optional uint32 max_conns_per_ip = 10 [default = 0];
inline bool NsJailConfig::has_max_conns_per_ip() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void NsJailConfig::clear_max_conns_per_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_conns_per_ip_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline ::uint32_t NsJailConfig::max_conns_per_ip() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.max_conns_per_ip)
  return _internal_max_conns_per_ip();
}
inline void NsJailConfig::set_max_conns_per_ip(::uint32_t value) {
  _internal_set_max_conns_per_ip(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.max_conns_per_ip)
}
inline ::uint32_t NsJailConfig::_internal_max_conns_per_ip() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_conns_per_ip_;
}
inline void NsJailConfig::_internal_set_max_conns_per_ip(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_conns_per_ip_ = value;
}

// optional uint32 time_limit = 11 [default = 600];
inline bool NsJailConfig::has_time_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x10000000U);
  return value;
}
inline void NsJailConfig::clear_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_limit_ = 600u;
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
}
inline ::uint32_t NsJailConfig::time_limit() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.time_limit)
  return _internal_time_limit();
}
inline void NsJailConfig::set_time_limit(::uint32_t value) {
  _internal_set_time_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.time_limit)
}
inline ::uint32_t NsJailConfig::_internal_time_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.time_limit_;
}
inline void NsJailConfig::_internal_set_time_limit(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_limit_ = value;
}

// optional bool daemon = 12 [default = false];
inline bool NsJailConfig::has_daemon() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void NsJailConfig::clear_daemon() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.daemon_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline bool NsJailConfig::daemon() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.daemon)
  return _internal_daemon();
}
inline void NsJailConfig::set_daemon(bool value) {
  _internal_set_daemon(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.daemon)
}
inline bool NsJailConfig::_internal_daemon() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.daemon_;
}
inline void NsJailConfig::_internal_set_daemon(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.daemon_ = value;
}

// optional uint32 max_cpus = 13 [default = 0];
inline bool NsJailConfig::has_max_cpus() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void NsJailConfig::clear_max_cpus() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_cpus_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline ::uint32_t NsJailConfig::max_cpus() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.max_cpus)
  return _internal_max_cpus();
}
inline void NsJailConfig::set_max_cpus(::uint32_t value) {
  _internal_set_max_cpus(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.max_cpus)
}
inline ::uint32_t NsJailConfig::_internal_max_cpus() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_cpus_;
}
inline void NsJailConfig::_internal_set_max_cpus(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_cpus_ = value;
}

// optional int32 nice_level = 14 [default = 19];
inline bool NsJailConfig::has_nice_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x40000000U);
  return value;
}
inline void NsJailConfig::clear_nice_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nice_level_ = 19;
  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
}
inline ::int32_t NsJailConfig::nice_level() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.nice_level)
  return _internal_nice_level();
}
inline void NsJailConfig::set_nice_level(::int32_t value) {
  _internal_set_nice_level(value);
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.nice_level)
}
inline ::int32_t NsJailConfig::_internal_nice_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.nice_level_;
}
inline void NsJailConfig::_internal_set_nice_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.nice_level_ = value;
}

// optional int32 log_fd = 15;
inline bool NsJailConfig::has_log_fd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void NsJailConfig::clear_log_fd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_fd_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline ::int32_t NsJailConfig::log_fd() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.log_fd)
  return _internal_log_fd();
}
inline void NsJailConfig::set_log_fd(::int32_t value) {
  _internal_set_log_fd(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.log_fd)
}
inline ::int32_t NsJailConfig::_internal_log_fd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_fd_;
}
inline void NsJailConfig::_internal_set_log_fd(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_fd_ = value;
}

// optional string log_file = 16;
inline bool NsJailConfig::has_log_file() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void NsJailConfig::clear_log_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_file_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::std::string& NsJailConfig::log_file() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.log_file)
  return _internal_log_file();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_log_file(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.log_file_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.log_file)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_log_file()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_log_file();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.log_file)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_log_file() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_file_.Get();
}
inline void NsJailConfig::_internal_set_log_file(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_file_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_log_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.log_file_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_log_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.log_file)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.log_file_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.log_file_.Set("", GetArena());
  }
  return released;
}
inline void NsJailConfig::set_allocated_log_file(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.log_file_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.log_file_.IsDefault()) {
    _impl_.log_file_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.log_file)
}

// optional .nsjail.LogLevel log_level = 17;
inline bool NsJailConfig::has_log_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  return value;
}
inline void NsJailConfig::clear_log_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_level_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline ::nsjail::LogLevel NsJailConfig::log_level() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.log_level)
  return _internal_log_level();
}
inline void NsJailConfig::set_log_level(::nsjail::LogLevel value) {
  _internal_set_log_level(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.log_level)
}
inline ::nsjail::LogLevel NsJailConfig::_internal_log_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::LogLevel>(_impl_.log_level_);
}
inline void NsJailConfig::_internal_set_log_level(::nsjail::LogLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::LogLevel_internal_data_));
                                          _impl_.log_level_ = value;
}

// optional bool keep_env = 18 [default = false];
inline bool NsJailConfig::has_keep_env() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void NsJailConfig::clear_keep_env() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_env_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline bool NsJailConfig::keep_env() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.keep_env)
  return _internal_keep_env();
}
inline void NsJailConfig::set_keep_env(bool value) {
  _internal_set_keep_env(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.keep_env)
}
inline bool NsJailConfig::_internal_keep_env() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.keep_env_;
}
inline void NsJailConfig::_internal_set_keep_env(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_env_ = value;
}

// repeated string envar = 19;
inline int NsJailConfig::_internal_envar_size() const {
  return _internal_envar().size();
}
inline int NsJailConfig::envar_size() const {
  return _internal_envar_size();
}
inline void NsJailConfig::clear_envar() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.envar_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::add_envar()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_envar()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add_mutable:nsjail.NsJailConfig.envar)
  return _s;
}
inline const ::std::string& NsJailConfig::envar(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.envar)
  return _internal_envar().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_envar(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.envar)
  return _internal_mutable_envar()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::set_envar(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_envar()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.envar)
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::add_envar(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_envar(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.envar)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NsJailConfig::envar()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.envar)
  return _internal_envar();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::mutable_envar() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.envar)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_envar();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NsJailConfig::_internal_envar() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.envar_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_envar() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.envar_;
}

// optional bool keep_caps = 20 [default = false];
inline bool NsJailConfig::has_keep_caps() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void NsJailConfig::clear_keep_caps() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_caps_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline bool NsJailConfig::keep_caps() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.keep_caps)
  return _internal_keep_caps();
}
inline void NsJailConfig::set_keep_caps(bool value) {
  _internal_set_keep_caps(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.keep_caps)
}
inline bool NsJailConfig::_internal_keep_caps() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.keep_caps_;
}
inline void NsJailConfig::_internal_set_keep_caps(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_caps_ = value;
}

// repeated string cap = 21;
inline int NsJailConfig::_internal_cap_size() const {
  return _internal_cap().size();
}
inline int NsJailConfig::cap_size() const {
  return _internal_cap_size();
}
inline void NsJailConfig::clear_cap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cap_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::add_cap()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_cap()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add_mutable:nsjail.NsJailConfig.cap)
  return _s;
}
inline const ::std::string& NsJailConfig::cap(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cap)
  return _internal_cap().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cap(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cap)
  return _internal_mutable_cap()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::set_cap(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_cap()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cap)
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::add_cap(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_cap(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.cap)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NsJailConfig::cap()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.cap)
  return _internal_cap();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::mutable_cap() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.cap)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_cap();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NsJailConfig::_internal_cap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cap_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_cap() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.cap_;
}

// optional bool silent = 22 [default = false];
inline bool NsJailConfig::has_silent() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  return value;
}
inline void NsJailConfig::clear_silent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.silent_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
}
inline bool NsJailConfig::silent() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.silent)
  return _internal_silent();
}
inline void NsJailConfig::set_silent(bool value) {
  _internal_set_silent(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.silent)
}
inline bool NsJailConfig::_internal_silent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.silent_;
}
inline void NsJailConfig::_internal_set_silent(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.silent_ = value;
}

// optional bool skip_setsid = 23 [default = false];
inline bool NsJailConfig::has_skip_setsid() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  return value;
}
inline void NsJailConfig::clear_skip_setsid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.skip_setsid_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
}
inline bool NsJailConfig::skip_setsid() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.skip_setsid)
  return _internal_skip_setsid();
}
inline void NsJailConfig::set_skip_setsid(bool value) {
  _internal_set_skip_setsid(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.skip_setsid)
}
inline bool NsJailConfig::_internal_skip_setsid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.skip_setsid_;
}
inline void NsJailConfig::_internal_set_skip_setsid(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.skip_setsid_ = value;
}

// optional bool stderr_to_null = 24 [default = false];
inline bool NsJailConfig::has_stderr_to_null() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  return value;
}
inline void NsJailConfig::clear_stderr_to_null() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stderr_to_null_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
}
inline bool NsJailConfig::stderr_to_null() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.stderr_to_null)
  return _internal_stderr_to_null();
}
inline void NsJailConfig::set_stderr_to_null(bool value) {
  _internal_set_stderr_to_null(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.stderr_to_null)
}
inline bool NsJailConfig::_internal_stderr_to_null() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.stderr_to_null_;
}
inline void NsJailConfig::_internal_set_stderr_to_null(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stderr_to_null_ = value;
}

// repeated int32 pass_fd = 25;
inline int NsJailConfig::_internal_pass_fd_size() const {
  return _internal_pass_fd().size();
}
inline int NsJailConfig::pass_fd_size() const {
  return _internal_pass_fd_size();
}
inline void NsJailConfig::clear_pass_fd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pass_fd_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::int32_t NsJailConfig::pass_fd(int index) const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.pass_fd)
  return _internal_pass_fd().Get(index);
}
inline void NsJailConfig::set_pass_fd(int index, ::int32_t value) {
  _internal_mutable_pass_fd()->Set(index, value);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.pass_fd)
}
inline void NsJailConfig::add_pass_fd(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_pass_fd()
      ->InternalAddWithArena<const ::google::protobuf::MessageLite*>(
          internal_visibility(), this, value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.pass_fd)
}
inline const ::google::protobuf::RepeatedField<::int32_t>& NsJailConfig::pass_fd() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.pass_fd)
  return _internal_pass_fd();
}
inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL NsJailConfig::mutable_pass_fd()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.pass_fd)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_pass_fd();
}
inline const ::google::protobuf::RepeatedField<::int32_t>&
NsJailConfig::_internal_pass_fd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pass_fd_;
}
inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_pass_fd() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.pass_fd_;
}

// optional bool disable_no_new_privs = 26 [default = false];
inline bool NsJailConfig::has_disable_no_new_privs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
  return value;
}
inline void NsJailConfig::clear_disable_no_new_privs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_no_new_privs_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline bool NsJailConfig::disable_no_new_privs() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.disable_no_new_privs)
  return _internal_disable_no_new_privs();
}
inline void NsJailConfig::set_disable_no_new_privs(bool value) {
  _internal_set_disable_no_new_privs(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.disable_no_new_privs)
}
inline bool NsJailConfig::_internal_disable_no_new_privs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.disable_no_new_privs_;
}
inline void NsJailConfig::_internal_set_disable_no_new_privs(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_no_new_privs_ = value;
}

// optional bool forward_signals = 27 [default = false];
inline bool NsJailConfig::has_forward_signals() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
  return value;
}
inline void NsJailConfig::clear_forward_signals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.forward_signals_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline bool NsJailConfig::forward_signals() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.forward_signals)
  return _internal_forward_signals();
}
inline void NsJailConfig::set_forward_signals(bool value) {
  _internal_set_forward_signals(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.forward_signals)
}
inline bool NsJailConfig::_internal_forward_signals() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.forward_signals_;
}
inline void NsJailConfig::_internal_set_forward_signals(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.forward_signals_ = value;
}

// optional bool disable_tsc = 28 [default = false];
inline bool NsJailConfig::has_disable_tsc() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
  return value;
}
inline void NsJailConfig::clear_disable_tsc() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_tsc_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline bool NsJailConfig::disable_tsc() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.disable_tsc)
  return _internal_disable_tsc();
}
inline void NsJailConfig::set_disable_tsc(bool value) {
  _internal_set_disable_tsc(value);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.disable_tsc)
}
inline bool NsJailConfig::_internal_disable_tsc() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.disable_tsc_;
}
inline void NsJailConfig::_internal_set_disable_tsc(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_tsc_ = value;
}

// optional uint64 rlimit_as = 29 [default = 4096];
inline bool NsJailConfig::has_rlimit_as() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x20000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_as() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_as_ = ::uint64_t{4096u};
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
}
inline ::uint64_t NsJailConfig::rlimit_as() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_as)
  return _internal_rlimit_as();
}
inline void NsJailConfig::set_rlimit_as(::uint64_t value) {
  _internal_set_rlimit_as(value);
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_as)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_as() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_as_;
}
inline void NsJailConfig::_internal_set_rlimit_as(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_as_ = value;
}

// optional .nsjail.RLimit rlimit_as_type = 30 [default = VALUE];
inline bool NsJailConfig::has_rlimit_as_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x02000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_as_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_as_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_as_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_as_type)
  return _internal_rlimit_as_type();
}
inline void NsJailConfig::set_rlimit_as_type(::nsjail::RLimit value) {
  _internal_set_rlimit_as_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_as_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_as_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_as_type_);
}
inline void NsJailConfig::_internal_set_rlimit_as_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_as_type_ = value;
}

// optional uint64 rlimit_core = 31 [default = 0];
inline bool NsJailConfig::has_rlimit_core() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x04000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_core() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_core_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
}
inline ::uint64_t NsJailConfig::rlimit_core() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_core)
  return _internal_rlimit_core();
}
inline void NsJailConfig::set_rlimit_core(::uint64_t value) {
  _internal_set_rlimit_core(value);
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_core)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_core() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_core_;
}
inline void NsJailConfig::_internal_set_rlimit_core(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_core_ = value;
}

// optional .nsjail.RLimit rlimit_core_type = 32 [default = VALUE];
inline bool NsJailConfig::has_rlimit_core_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00400000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_core_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_core_type_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00400000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_core_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_core_type)
  return _internal_rlimit_core_type();
}
inline void NsJailConfig::set_rlimit_core_type(::nsjail::RLimit value) {
  _internal_set_rlimit_core_type(value);
  SetHasBit(_impl_._has_bits_[1], 0x00400000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_core_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_core_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_core_type_);
}
inline void NsJailConfig::_internal_set_rlimit_core_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_core_type_ = value;
}

// optional uint64 rlimit_cpu = 33 [default = 600];
inline bool NsJailConfig::has_rlimit_cpu() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00008000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_cpu() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_cpu_ = ::uint64_t{600u};
  ClearHasBit(_impl_._has_bits_[2], 0x00008000U);
}
inline ::uint64_t NsJailConfig::rlimit_cpu() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_cpu)
  return _internal_rlimit_cpu();
}
inline void NsJailConfig::set_rlimit_cpu(::uint64_t value) {
  _internal_set_rlimit_cpu(value);
  SetHasBit(_impl_._has_bits_[2], 0x00008000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_cpu)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_cpu() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_cpu_;
}
inline void NsJailConfig::_internal_set_rlimit_cpu(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_cpu_ = value;
}

// optional .nsjail.RLimit rlimit_cpu_type = 34 [default = VALUE];
inline bool NsJailConfig::has_rlimit_cpu_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00800000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_cpu_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_cpu_type_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00800000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_cpu_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_cpu_type)
  return _internal_rlimit_cpu_type();
}
inline void NsJailConfig::set_rlimit_cpu_type(::nsjail::RLimit value) {
  _internal_set_rlimit_cpu_type(value);
  SetHasBit(_impl_._has_bits_[1], 0x00800000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_cpu_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_cpu_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_cpu_type_);
}
inline void NsJailConfig::_internal_set_rlimit_cpu_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_cpu_type_ = value;
}

// optional uint64 rlimit_fsize = 35 [default = 1];
inline bool NsJailConfig::has_rlimit_fsize() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00010000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_fsize() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_fsize_ = ::uint64_t{1u};
  ClearHasBit(_impl_._has_bits_[2], 0x00010000U);
}
inline ::uint64_t NsJailConfig::rlimit_fsize() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_fsize)
  return _internal_rlimit_fsize();
}
inline void NsJailConfig::set_rlimit_fsize(::uint64_t value) {
  _internal_set_rlimit_fsize(value);
  SetHasBit(_impl_._has_bits_[2], 0x00010000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_fsize)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_fsize() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_fsize_;
}
inline void NsJailConfig::_internal_set_rlimit_fsize(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_fsize_ = value;
}

// optional .nsjail.RLimit rlimit_fsize_type = 36 [default = VALUE];
inline bool NsJailConfig::has_rlimit_fsize_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x01000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_fsize_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_fsize_type_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x01000000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_fsize_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_fsize_type)
  return _internal_rlimit_fsize_type();
}
inline void NsJailConfig::set_rlimit_fsize_type(::nsjail::RLimit value) {
  _internal_set_rlimit_fsize_type(value);
  SetHasBit(_impl_._has_bits_[1], 0x01000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_fsize_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_fsize_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_fsize_type_);
}
inline void NsJailConfig::_internal_set_rlimit_fsize_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_fsize_type_ = value;
}

// optional uint64 rlimit_nofile = 37 [default = 32];
inline bool NsJailConfig::has_rlimit_nofile() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00020000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_nofile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_nofile_ = ::uint64_t{32u};
  ClearHasBit(_impl_._has_bits_[2], 0x00020000U);
}
inline ::uint64_t NsJailConfig::rlimit_nofile() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_nofile)
  return _internal_rlimit_nofile();
}
inline void NsJailConfig::set_rlimit_nofile(::uint64_t value) {
  _internal_set_rlimit_nofile(value);
  SetHasBit(_impl_._has_bits_[2], 0x00020000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_nofile)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_nofile() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_nofile_;
}
inline void NsJailConfig::_internal_set_rlimit_nofile(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_nofile_ = value;
}

// optional .nsjail.RLimit rlimit_nofile_type = 38 [default = VALUE];
inline bool NsJailConfig::has_rlimit_nofile_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x02000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_nofile_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_nofile_type_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x02000000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_nofile_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_nofile_type)
  return _internal_rlimit_nofile_type();
}
inline void NsJailConfig::set_rlimit_nofile_type(::nsjail::RLimit value) {
  _internal_set_rlimit_nofile_type(value);
  SetHasBit(_impl_._has_bits_[1], 0x02000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_nofile_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_nofile_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_nofile_type_);
}
inline void NsJailConfig::_internal_set_rlimit_nofile_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_nofile_type_ = value;
}

// optional uint64 rlimit_nproc = 39 [default = 1024];
inline bool NsJailConfig::has_rlimit_nproc() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00040000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_nproc() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_nproc_ = ::uint64_t{1024u};
  ClearHasBit(_impl_._has_bits_[2], 0x00040000U);
}
inline ::uint64_t NsJailConfig::rlimit_nproc() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_nproc)
  return _internal_rlimit_nproc();
}
inline void NsJailConfig::set_rlimit_nproc(::uint64_t value) {
  _internal_set_rlimit_nproc(value);
  SetHasBit(_impl_._has_bits_[2], 0x00040000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_nproc)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_nproc() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_nproc_;
}
inline void NsJailConfig::_internal_set_rlimit_nproc(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_nproc_ = value;
}

// optional .nsjail.RLimit rlimit_nproc_type = 40 [default = SOFT];
inline bool NsJailConfig::has_rlimit_nproc_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00100000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_nproc_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_nproc_type_ = 1;
  ClearHasBit(_impl_._has_bits_[2], 0x00100000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_nproc_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_nproc_type)
  return _internal_rlimit_nproc_type();
}
inline void NsJailConfig::set_rlimit_nproc_type(::nsjail::RLimit value) {
  _internal_set_rlimit_nproc_type(value);
  SetHasBit(_impl_._has_bits_[2], 0x00100000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_nproc_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_nproc_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_nproc_type_);
}
inline void NsJailConfig::_internal_set_rlimit_nproc_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_nproc_type_ = value;
}

// optional uint64 rlimit_stack = 41 [default = 8];
inline bool NsJailConfig::has_rlimit_stack() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00080000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_stack() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_stack_ = ::uint64_t{8u};
  ClearHasBit(_impl_._has_bits_[2], 0x00080000U);
}
inline ::uint64_t NsJailConfig::rlimit_stack() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_stack)
  return _internal_rlimit_stack();
}
inline void NsJailConfig::set_rlimit_stack(::uint64_t value) {
  _internal_set_rlimit_stack(value);
  SetHasBit(_impl_._has_bits_[2], 0x00080000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_stack)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_stack() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_stack_;
}
inline void NsJailConfig::_internal_set_rlimit_stack(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_stack_ = value;
}

// optional .nsjail.RLimit rlimit_stack_type = 42 [default = SOFT];
inline bool NsJailConfig::has_rlimit_stack_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00200000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_stack_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_stack_type_ = 1;
  ClearHasBit(_impl_._has_bits_[2], 0x00200000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_stack_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_stack_type)
  return _internal_rlimit_stack_type();
}
inline void NsJailConfig::set_rlimit_stack_type(::nsjail::RLimit value) {
  _internal_set_rlimit_stack_type(value);
  SetHasBit(_impl_._has_bits_[2], 0x00200000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_stack_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_stack_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_stack_type_);
}
inline void NsJailConfig::_internal_set_rlimit_stack_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_stack_type_ = value;
}

// optional uint64 rlimit_memlock = 43 [default = 64];
inline bool NsJailConfig::has_rlimit_memlock() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00400000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_memlock() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_memlock_ = ::uint64_t{64u};
  ClearHasBit(_impl_._has_bits_[2], 0x00400000U);
}
inline ::uint64_t NsJailConfig::rlimit_memlock() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_memlock)
  return _internal_rlimit_memlock();
}
inline void NsJailConfig::set_rlimit_memlock(::uint64_t value) {
  _internal_set_rlimit_memlock(value);
  SetHasBit(_impl_._has_bits_[2], 0x00400000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_memlock)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_memlock() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_memlock_;
}
inline void NsJailConfig::_internal_set_rlimit_memlock(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_memlock_ = value;
}

// optional .nsjail.RLimit rlimit_memlock_type = 44 [default = SOFT];
inline bool NsJailConfig::has_rlimit_memlock_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00800000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_memlock_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_memlock_type_ = 1;
  ClearHasBit(_impl_._has_bits_[2], 0x00800000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_memlock_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_memlock_type)
  return _internal_rlimit_memlock_type();
}
inline void NsJailConfig::set_rlimit_memlock_type(::nsjail::RLimit value) {
  _internal_set_rlimit_memlock_type(value);
  SetHasBit(_impl_._has_bits_[2], 0x00800000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_memlock_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_memlock_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_memlock_type_);
}
inline void NsJailConfig::_internal_set_rlimit_memlock_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_memlock_type_ = value;
}

// optional uint64 rlimit_rtprio = 45 [default = 0];
inline bool NsJailConfig::has_rlimit_rtprio() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x04000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_rtprio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_rtprio_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[1], 0x04000000U);
}
inline ::uint64_t NsJailConfig::rlimit_rtprio() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_rtprio)
  return _internal_rlimit_rtprio();
}
inline void NsJailConfig::set_rlimit_rtprio(::uint64_t value) {
  _internal_set_rlimit_rtprio(value);
  SetHasBit(_impl_._has_bits_[1], 0x04000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_rtprio)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_rtprio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_rtprio_;
}
inline void NsJailConfig::_internal_set_rlimit_rtprio(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_rtprio_ = value;
}

// optional .nsjail.RLimit rlimit_rtprio_type = 46 [default = SOFT];
inline bool NsJailConfig::has_rlimit_rtprio_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x01000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_rtprio_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_rtprio_type_ = 1;
  ClearHasBit(_impl_._has_bits_[2], 0x01000000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_rtprio_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_rtprio_type)
  return _internal_rlimit_rtprio_type();
}
inline void NsJailConfig::set_rlimit_rtprio_type(::nsjail::RLimit value) {
  _internal_set_rlimit_rtprio_type(value);
  SetHasBit(_impl_._has_bits_[2], 0x01000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_rtprio_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_rtprio_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_rtprio_type_);
}
inline void NsJailConfig::_internal_set_rlimit_rtprio_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_rtprio_type_ = value;
}

// optional uint64 rlimit_msgqueue = 47 [default = 1024];
inline bool NsJailConfig::has_rlimit_msgqueue() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x02000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_msgqueue() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_msgqueue_ = ::uint64_t{1024u};
  ClearHasBit(_impl_._has_bits_[2], 0x02000000U);
}
inline ::uint64_t NsJailConfig::rlimit_msgqueue() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_msgqueue)
  return _internal_rlimit_msgqueue();
}
inline void NsJailConfig::set_rlimit_msgqueue(::uint64_t value) {
  _internal_set_rlimit_msgqueue(value);
  SetHasBit(_impl_._has_bits_[2], 0x02000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_msgqueue)
}
inline ::uint64_t NsJailConfig::_internal_rlimit_msgqueue() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rlimit_msgqueue_;
}
inline void NsJailConfig::_internal_set_rlimit_msgqueue(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_msgqueue_ = value;
}

// optional .nsjail.RLimit rlimit_msgqueue_type = 48 [default = SOFT];
inline bool NsJailConfig::has_rlimit_msgqueue_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x04000000U);
  return value;
}
inline void NsJailConfig::clear_rlimit_msgqueue_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rlimit_msgqueue_type_ = 1;
  ClearHasBit(_impl_._has_bits_[2], 0x04000000U);
}
inline ::nsjail::RLimit NsJailConfig::rlimit_msgqueue_type() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.rlimit_msgqueue_type)
  return _internal_rlimit_msgqueue_type();
}
inline void NsJailConfig::set_rlimit_msgqueue_type(::nsjail::RLimit value) {
  _internal_set_rlimit_msgqueue_type(value);
  SetHasBit(_impl_._has_bits_[2], 0x04000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.rlimit_msgqueue_type)
}
inline ::nsjail::RLimit NsJailConfig::_internal_rlimit_msgqueue_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::nsjail::RLimit>(_impl_.rlimit_msgqueue_type_);
}
inline void NsJailConfig::_internal_set_rlimit_msgqueue_type(::nsjail::RLimit value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::nsjail::RLimit_internal_data_));
                                          _impl_.rlimit_msgqueue_type_ = value;
}

// optional bool disable_rl = 49 [default = false];
inline bool NsJailConfig::has_disable_rl() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x08000000U);
  return value;
}
inline void NsJailConfig::clear_disable_rl() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_rl_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x08000000U);
}
inline bool NsJailConfig::disable_rl() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.disable_rl)
  return _internal_disable_rl();
}
inline void NsJailConfig::set_disable_rl(bool value) {
  _internal_set_disable_rl(value);
  SetHasBit(_impl_._has_bits_[1], 0x08000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.disable_rl)
}
inline bool NsJailConfig::_internal_disable_rl() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.disable_rl_;
}
inline void NsJailConfig::_internal_set_disable_rl(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_rl_ = value;
}

// optional bool persona_addr_compat_layout = 50 [default = false];
inline bool NsJailConfig::has_persona_addr_compat_layout() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x10000000U);
  return value;
}
inline void NsJailConfig::clear_persona_addr_compat_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_addr_compat_layout_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x10000000U);
}
inline bool NsJailConfig::persona_addr_compat_layout() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.persona_addr_compat_layout)
  return _internal_persona_addr_compat_layout();
}
inline void NsJailConfig::set_persona_addr_compat_layout(bool value) {
  _internal_set_persona_addr_compat_layout(value);
  SetHasBit(_impl_._has_bits_[1], 0x10000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.persona_addr_compat_layout)
}
inline bool NsJailConfig::_internal_persona_addr_compat_layout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.persona_addr_compat_layout_;
}
inline void NsJailConfig::_internal_set_persona_addr_compat_layout(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_addr_compat_layout_ = value;
}

// optional bool persona_mmap_page_zero = 51 [default = false];
inline bool NsJailConfig::has_persona_mmap_page_zero() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x20000000U);
  return value;
}
inline void NsJailConfig::clear_persona_mmap_page_zero() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_mmap_page_zero_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x20000000U);
}
inline bool NsJailConfig::persona_mmap_page_zero() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.persona_mmap_page_zero)
  return _internal_persona_mmap_page_zero();
}
inline void NsJailConfig::set_persona_mmap_page_zero(bool value) {
  _internal_set_persona_mmap_page_zero(value);
  SetHasBit(_impl_._has_bits_[1], 0x20000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.persona_mmap_page_zero)
}
inline bool NsJailConfig::_internal_persona_mmap_page_zero() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.persona_mmap_page_zero_;
}
inline void NsJailConfig::_internal_set_persona_mmap_page_zero(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_mmap_page_zero_ = value;
}

// optional bool persona_read_implies_exec = 52 [default = false];
inline bool NsJailConfig::has_persona_read_implies_exec() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x40000000U);
  return value;
}
inline void NsJailConfig::clear_persona_read_implies_exec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_read_implies_exec_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x40000000U);
}
inline bool NsJailConfig::persona_read_implies_exec() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.persona_read_implies_exec)
  return _internal_persona_read_implies_exec();
}
inline void NsJailConfig::set_persona_read_implies_exec(bool value) {
  _internal_set_persona_read_implies_exec(value);
  SetHasBit(_impl_._has_bits_[1], 0x40000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.persona_read_implies_exec)
}
inline bool NsJailConfig::_internal_persona_read_implies_exec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.persona_read_implies_exec_;
}
inline void NsJailConfig::_internal_set_persona_read_implies_exec(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_read_implies_exec_ = value;
}

// optional bool persona_addr_limit_3gb = 53 [default = false];
inline bool NsJailConfig::has_persona_addr_limit_3gb() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x80000000U);
  return value;
}
inline void NsJailConfig::clear_persona_addr_limit_3gb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_addr_limit_3gb_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x80000000U);
}
inline bool NsJailConfig::persona_addr_limit_3gb() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.persona_addr_limit_3gb)
  return _internal_persona_addr_limit_3gb();
}
inline void NsJailConfig::set_persona_addr_limit_3gb(bool value) {
  _internal_set_persona_addr_limit_3gb(value);
  SetHasBit(_impl_._has_bits_[1], 0x80000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.persona_addr_limit_3gb)
}
inline bool NsJailConfig::_internal_persona_addr_limit_3gb() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.persona_addr_limit_3gb_;
}
inline void NsJailConfig::_internal_set_persona_addr_limit_3gb(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_addr_limit_3gb_ = value;
}

// optional bool persona_addr_no_randomize = 54 [default = false];
inline bool NsJailConfig::has_persona_addr_no_randomize() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000001U);
  return value;
}
inline void NsJailConfig::clear_persona_addr_no_randomize() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_addr_no_randomize_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000001U);
}
inline bool NsJailConfig::persona_addr_no_randomize() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.persona_addr_no_randomize)
  return _internal_persona_addr_no_randomize();
}
inline void NsJailConfig::set_persona_addr_no_randomize(bool value) {
  _internal_set_persona_addr_no_randomize(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000001U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.persona_addr_no_randomize)
}
inline bool NsJailConfig::_internal_persona_addr_no_randomize() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.persona_addr_no_randomize_;
}
inline void NsJailConfig::_internal_set_persona_addr_no_randomize(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.persona_addr_no_randomize_ = value;
}

// optional bool clone_newnet = 55 [default = true];
inline bool NsJailConfig::has_clone_newnet() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x08000000U);
  return value;
}
inline void NsJailConfig::clear_clone_newnet() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newnet_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x08000000U);
}
inline bool NsJailConfig::clone_newnet() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newnet)
  return _internal_clone_newnet();
}
inline void NsJailConfig::set_clone_newnet(bool value) {
  _internal_set_clone_newnet(value);
  SetHasBit(_impl_._has_bits_[2], 0x08000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newnet)
}
inline bool NsJailConfig::_internal_clone_newnet() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newnet_;
}
inline void NsJailConfig::_internal_set_clone_newnet(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newnet_ = value;
}

// optional bool clone_newuser = 56 [default = true];
inline bool NsJailConfig::has_clone_newuser() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x10000000U);
  return value;
}
inline void NsJailConfig::clear_clone_newuser() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newuser_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x10000000U);
}
inline bool NsJailConfig::clone_newuser() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newuser)
  return _internal_clone_newuser();
}
inline void NsJailConfig::set_clone_newuser(bool value) {
  _internal_set_clone_newuser(value);
  SetHasBit(_impl_._has_bits_[2], 0x10000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newuser)
}
inline bool NsJailConfig::_internal_clone_newuser() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newuser_;
}
inline void NsJailConfig::_internal_set_clone_newuser(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newuser_ = value;
}

// optional bool clone_newns = 57 [default = true];
inline bool NsJailConfig::has_clone_newns() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x20000000U);
  return value;
}
inline void NsJailConfig::clear_clone_newns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newns_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x20000000U);
}
inline bool NsJailConfig::clone_newns() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newns)
  return _internal_clone_newns();
}
inline void NsJailConfig::set_clone_newns(bool value) {
  _internal_set_clone_newns(value);
  SetHasBit(_impl_._has_bits_[2], 0x20000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newns)
}
inline bool NsJailConfig::_internal_clone_newns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newns_;
}
inline void NsJailConfig::_internal_set_clone_newns(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newns_ = value;
}

// optional bool clone_newpid = 58 [default = true];
inline bool NsJailConfig::has_clone_newpid() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x40000000U);
  return value;
}
inline void NsJailConfig::clear_clone_newpid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newpid_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x40000000U);
}
inline bool NsJailConfig::clone_newpid() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newpid)
  return _internal_clone_newpid();
}
inline void NsJailConfig::set_clone_newpid(bool value) {
  _internal_set_clone_newpid(value);
  SetHasBit(_impl_._has_bits_[2], 0x40000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newpid)
}
inline bool NsJailConfig::_internal_clone_newpid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newpid_;
}
inline void NsJailConfig::_internal_set_clone_newpid(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newpid_ = value;
}

// optional bool clone_newipc = 59 [default = true];
inline bool NsJailConfig::has_clone_newipc() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00001000U);
  return value;
}
inline void NsJailConfig::clear_clone_newipc() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newipc_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x00001000U);
}
inline bool NsJailConfig::clone_newipc() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newipc)
  return _internal_clone_newipc();
}
inline void NsJailConfig::set_clone_newipc(bool value) {
  _internal_set_clone_newipc(value);
  SetHasBit(_impl_._has_bits_[2], 0x00001000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newipc)
}
inline bool NsJailConfig::_internal_clone_newipc() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newipc_;
}
inline void NsJailConfig::_internal_set_clone_newipc(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newipc_ = value;
}

// optional bool clone_newuts = 60 [default = true];
inline bool NsJailConfig::has_clone_newuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00002000U);
  return value;
}
inline void NsJailConfig::clear_clone_newuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newuts_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x00002000U);
}
inline bool NsJailConfig::clone_newuts() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newuts)
  return _internal_clone_newuts();
}
inline void NsJailConfig::set_clone_newuts(bool value) {
  _internal_set_clone_newuts(value);
  SetHasBit(_impl_._has_bits_[2], 0x00002000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newuts)
}
inline bool NsJailConfig::_internal_clone_newuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newuts_;
}
inline void NsJailConfig::_internal_set_clone_newuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newuts_ = value;
}

// optional bool clone_newcgroup = 61 [default = true];
inline bool NsJailConfig::has_clone_newcgroup() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00004000U);
  return value;
}
inline void NsJailConfig::clear_clone_newcgroup() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newcgroup_ = true;
  ClearHasBit(_impl_._has_bits_[2], 0x00004000U);
}
inline bool NsJailConfig::clone_newcgroup() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newcgroup)
  return _internal_clone_newcgroup();
}
inline void NsJailConfig::set_clone_newcgroup(bool value) {
  _internal_set_clone_newcgroup(value);
  SetHasBit(_impl_._has_bits_[2], 0x00004000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newcgroup)
}
inline bool NsJailConfig::_internal_clone_newcgroup() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newcgroup_;
}
inline void NsJailConfig::_internal_set_clone_newcgroup(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newcgroup_ = value;
}

// optional bool clone_newtime = 62 [default = false];
inline bool NsJailConfig::has_clone_newtime() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000002U);
  return value;
}
inline void NsJailConfig::clear_clone_newtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newtime_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000002U);
}
inline bool NsJailConfig::clone_newtime() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.clone_newtime)
  return _internal_clone_newtime();
}
inline void NsJailConfig::set_clone_newtime(bool value) {
  _internal_set_clone_newtime(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000002U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.clone_newtime)
}
inline bool NsJailConfig::_internal_clone_newtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clone_newtime_;
}
inline void NsJailConfig::_internal_set_clone_newtime(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clone_newtime_ = value;
}

// repeated .nsjail.IdMap uidmap = 63;
inline int NsJailConfig::_internal_uidmap_size() const {
  return _internal_uidmap().size();
}
inline int NsJailConfig::uidmap_size() const {
  return _internal_uidmap_size();
}
inline void NsJailConfig::clear_uidmap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.uidmap_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
}
inline const ::nsjail::IdMap& NsJailConfig::uidmap(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.uidmap)
  return _internal_uidmap().Get(index);
}
inline ::nsjail::IdMap* PROTOBUF_NONNULL NsJailConfig::mutable_uidmap(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.uidmap)
  return _internal_mutable_uidmap()->Mutable(index);
}
inline ::nsjail::IdMap* PROTOBUF_NONNULL NsJailConfig::add_uidmap()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::nsjail::IdMap* _add =
      _internal_mutable_uidmap()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.uidmap)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>& NsJailConfig::uidmap() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.uidmap)
  return _internal_uidmap();
}
inline ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL
NsJailConfig::mutable_uidmap() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.uidmap)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_uidmap();
}
inline const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>&
NsJailConfig::_internal_uidmap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.uidmap_;
}
inline ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_uidmap() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.uidmap_;
}

// repeated .nsjail.IdMap gidmap = 64;
inline int NsJailConfig::_internal_gidmap_size() const {
  return _internal_gidmap().size();
}
inline int NsJailConfig::gidmap_size() const {
  return _internal_gidmap_size();
}
inline void NsJailConfig::clear_gidmap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gidmap_.Clear();
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
}
inline const ::nsjail::IdMap& NsJailConfig::gidmap(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.gidmap)
  return _internal_gidmap().Get(index);
}
inline ::nsjail::IdMap* PROTOBUF_NONNULL NsJailConfig::mutable_gidmap(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.gidmap)
  return _internal_mutable_gidmap()->Mutable(index);
}
inline ::nsjail::IdMap* PROTOBUF_NONNULL NsJailConfig::add_gidmap()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::nsjail::IdMap* _add =
      _internal_mutable_gidmap()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.gidmap)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>& NsJailConfig::gidmap() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.gidmap)
  return _internal_gidmap();
}
inline ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL
NsJailConfig::mutable_gidmap() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.gidmap)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_gidmap();
}
inline const ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>&
NsJailConfig::_internal_gidmap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gidmap_;
}
inline ::google::protobuf::RepeatedPtrField<::nsjail::IdMap>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_gidmap() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.gidmap_;
}

// optional bool mount_proc = 65 [default = false];
inline bool NsJailConfig::has_mount_proc() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000004U);
  return value;
}
inline void NsJailConfig::clear_mount_proc() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mount_proc_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000004U);
}
inline bool NsJailConfig::mount_proc() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.mount_proc)
  return _internal_mount_proc();
}
inline void NsJailConfig::set_mount_proc(bool value) {
  _internal_set_mount_proc(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000004U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.mount_proc)
}
inline bool NsJailConfig::_internal_mount_proc() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mount_proc_;
}
inline void NsJailConfig::_internal_set_mount_proc(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mount_proc_ = value;
}

// repeated .nsjail.MountPt mount = 66;
inline int NsJailConfig::_internal_mount_size() const {
  return _internal_mount().size();
}
inline int NsJailConfig::mount_size() const {
  return _internal_mount_size();
}
inline void NsJailConfig::clear_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mount_.Clear();
  ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
}
inline const ::nsjail::MountPt& NsJailConfig::mount(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.mount)
  return _internal_mount().Get(index);
}
inline ::nsjail::MountPt* PROTOBUF_NONNULL NsJailConfig::mutable_mount(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.mount)
  return _internal_mutable_mount()->Mutable(index);
}
inline ::nsjail::MountPt* PROTOBUF_NONNULL NsJailConfig::add_mount()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::nsjail::MountPt* _add =
      _internal_mutable_mount()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.mount)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>& NsJailConfig::mount() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.mount)
  return _internal_mount();
}
inline ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>* PROTOBUF_NONNULL
NsJailConfig::mutable_mount() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.mount)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_mount();
}
inline const ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>&
NsJailConfig::_internal_mount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mount_;
}
inline ::google::protobuf::RepeatedPtrField<::nsjail::MountPt>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_mount() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.mount_;
}

// optional string seccomp_policy_file = 67;
inline bool NsJailConfig::has_seccomp_policy_file() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000010U);
  return value;
}
inline void NsJailConfig::clear_seccomp_policy_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seccomp_policy_file_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
}
inline const ::std::string& NsJailConfig::seccomp_policy_file() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.seccomp_policy_file)
  return _internal_seccomp_policy_file();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_seccomp_policy_file(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  _impl_.seccomp_policy_file_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.seccomp_policy_file)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_seccomp_policy_file()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  ::std::string* _s = _internal_mutable_seccomp_policy_file();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.seccomp_policy_file)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_seccomp_policy_file() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seccomp_policy_file_.Get();
}
inline void NsJailConfig::_internal_set_seccomp_policy_file(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seccomp_policy_file_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_seccomp_policy_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.seccomp_policy_file_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_seccomp_policy_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.seccomp_policy_file)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
  auto* released = _impl_.seccomp_policy_file_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.seccomp_policy_file_.Set("", GetArena());
  }
  return released;
}
inline void NsJailConfig::set_allocated_seccomp_policy_file(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
  }
  _impl_.seccomp_policy_file_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.seccomp_policy_file_.IsDefault()) {
    _impl_.seccomp_policy_file_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.seccomp_policy_file)
}

// repeated string seccomp_string = 68;
inline int NsJailConfig::_internal_seccomp_string_size() const {
  return _internal_seccomp_string().size();
}
inline int NsJailConfig::seccomp_string_size() const {
  return _internal_seccomp_string_size();
}
inline void NsJailConfig::clear_seccomp_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seccomp_string_.Clear();
  ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::add_seccomp_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_seccomp_string()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  // @@protoc_insertion_point(field_add_mutable:nsjail.NsJailConfig.seccomp_string)
  return _s;
}
inline const ::std::string& NsJailConfig::seccomp_string(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.seccomp_string)
  return _internal_seccomp_string().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_seccomp_string(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.seccomp_string)
  return _internal_mutable_seccomp_string()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::set_seccomp_string(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_seccomp_string()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.seccomp_string)
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::add_seccomp_string(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_seccomp_string(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.seccomp_string)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NsJailConfig::seccomp_string()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.seccomp_string)
  return _internal_seccomp_string();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::mutable_seccomp_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.seccomp_string)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_seccomp_string();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NsJailConfig::_internal_seccomp_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seccomp_string_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_seccomp_string() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.seccomp_string_;
}

// optional bool seccomp_log = 69 [default = false];
inline bool NsJailConfig::has_seccomp_log() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000100U);
  return value;
}
inline void NsJailConfig::clear_seccomp_log() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seccomp_log_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000100U);
}
inline bool NsJailConfig::seccomp_log() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.seccomp_log)
  return _internal_seccomp_log();
}
inline void NsJailConfig::set_seccomp_log(bool value) {
  _internal_set_seccomp_log(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000100U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.seccomp_log)
}
inline bool NsJailConfig::_internal_seccomp_log() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seccomp_log_;
}
inline void NsJailConfig::_internal_set_seccomp_log(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seccomp_log_ = value;
}

// optional uint64 cgroup_mem_max = 70 [default = 0];
inline bool NsJailConfig::has_cgroup_mem_max() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000008U);
  return value;
}
inline void NsJailConfig::clear_cgroup_mem_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_max_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[2], 0x00000008U);
}
inline ::uint64_t NsJailConfig::cgroup_mem_max() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_mem_max)
  return _internal_cgroup_mem_max();
}
inline void NsJailConfig::set_cgroup_mem_max(::uint64_t value) {
  _internal_set_cgroup_mem_max(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000008U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_mem_max)
}
inline ::uint64_t NsJailConfig::_internal_cgroup_mem_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_mem_max_;
}
inline void NsJailConfig::_internal_set_cgroup_mem_max(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_max_ = value;
}

// optional uint64 cgroup_mem_memsw_max = 71 [default = 0];
inline bool NsJailConfig::has_cgroup_mem_memsw_max() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000010U);
  return value;
}
inline void NsJailConfig::clear_cgroup_mem_memsw_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_memsw_max_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[2], 0x00000010U);
}
inline ::uint64_t NsJailConfig::cgroup_mem_memsw_max() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_mem_memsw_max)
  return _internal_cgroup_mem_memsw_max();
}
inline void NsJailConfig::set_cgroup_mem_memsw_max(::uint64_t value) {
  _internal_set_cgroup_mem_memsw_max(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000010U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_mem_memsw_max)
}
inline ::uint64_t NsJailConfig::_internal_cgroup_mem_memsw_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_mem_memsw_max_;
}
inline void NsJailConfig::_internal_set_cgroup_mem_memsw_max(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_memsw_max_ = value;
}

// optional int64 cgroup_mem_swap_max = 72 [default = -1];
inline bool NsJailConfig::has_cgroup_mem_swap_max() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x80000000U);
  return value;
}
inline void NsJailConfig::clear_cgroup_mem_swap_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_swap_max_ = ::int64_t{-1};
  ClearHasBit(_impl_._has_bits_[2], 0x80000000U);
}
inline ::int64_t NsJailConfig::cgroup_mem_swap_max() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_mem_swap_max)
  return _internal_cgroup_mem_swap_max();
}
inline void NsJailConfig::set_cgroup_mem_swap_max(::int64_t value) {
  _internal_set_cgroup_mem_swap_max(value);
  SetHasBit(_impl_._has_bits_[2], 0x80000000U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_mem_swap_max)
}
inline ::int64_t NsJailConfig::_internal_cgroup_mem_swap_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_mem_swap_max_;
}
inline void NsJailConfig::_internal_set_cgroup_mem_swap_max(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_swap_max_ = value;
}

// optional string cgroup_mem_mount = 73 [default = "/sys/fs/cgroup/memory"];
inline bool NsJailConfig::has_cgroup_mem_mount() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U);
  return value;
}
inline void NsJailConfig::clear_cgroup_mem_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_mount_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_mem_mount_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
}
inline const ::std::string& NsJailConfig::cgroup_mem_mount() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_mem_mount)
  if (_impl_.cgroup_mem_mount_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_mem_mount_.get();
  }
  return _internal_cgroup_mem_mount();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_mem_mount(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  _impl_.cgroup_mem_mount_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_mem_mount)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_mem_mount()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  ::std::string* _s = _internal_mutable_cgroup_mem_mount();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_mem_mount)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_mem_mount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_mem_mount_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_mem_mount(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_mount_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_mem_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_mem_mount_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_mem_mount_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_mem_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_mem_mount)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
  return _impl_.cgroup_mem_mount_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_mem_mount(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
  }
  _impl_.cgroup_mem_mount_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_mem_mount)
}

// optional string cgroup_mem_parent = 74 [default = "NSJAIL"];
inline bool NsJailConfig::has_cgroup_mem_parent() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U);
  return value;
}
inline void NsJailConfig::clear_cgroup_mem_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_parent_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_mem_parent_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
}
inline const ::std::string& NsJailConfig::cgroup_mem_parent() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_mem_parent)
  if (_impl_.cgroup_mem_parent_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_mem_parent_.get();
  }
  return _internal_cgroup_mem_parent();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_mem_parent(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  _impl_.cgroup_mem_parent_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_mem_parent)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_mem_parent()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  ::std::string* _s = _internal_mutable_cgroup_mem_parent();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_mem_parent)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_mem_parent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_mem_parent_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_mem_parent(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_mem_parent_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_mem_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_mem_parent_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_mem_parent_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_mem_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_mem_parent)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
  return _impl_.cgroup_mem_parent_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_mem_parent(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
  }
  _impl_.cgroup_mem_parent_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_mem_parent)
}

// optional uint64 cgroup_pids_max = 75 [default = 0];
inline bool NsJailConfig::has_cgroup_pids_max() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000020U);
  return value;
}
inline void NsJailConfig::clear_cgroup_pids_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_pids_max_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[2], 0x00000020U);
}
inline ::uint64_t NsJailConfig::cgroup_pids_max() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_pids_max)
  return _internal_cgroup_pids_max();
}
inline void NsJailConfig::set_cgroup_pids_max(::uint64_t value) {
  _internal_set_cgroup_pids_max(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000020U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_pids_max)
}
inline ::uint64_t NsJailConfig::_internal_cgroup_pids_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_pids_max_;
}
inline void NsJailConfig::_internal_set_cgroup_pids_max(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_pids_max_ = value;
}

// optional string cgroup_pids_mount = 76 [default = "/sys/fs/cgroup/pids"];
inline bool NsJailConfig::has_cgroup_pids_mount() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U);
  return value;
}
inline void NsJailConfig::clear_cgroup_pids_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_pids_mount_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_pids_mount_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
}
inline const ::std::string& NsJailConfig::cgroup_pids_mount() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_pids_mount)
  if (_impl_.cgroup_pids_mount_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_pids_mount_.get();
  }
  return _internal_cgroup_pids_mount();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_pids_mount(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  _impl_.cgroup_pids_mount_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_pids_mount)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_pids_mount()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::std::string* _s = _internal_mutable_cgroup_pids_mount();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_pids_mount)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_pids_mount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_pids_mount_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_pids_mount(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_pids_mount_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_pids_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_pids_mount_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_pids_mount_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_pids_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_pids_mount)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  return _impl_.cgroup_pids_mount_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_pids_mount(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  }
  _impl_.cgroup_pids_mount_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_pids_mount)
}

// optional string cgroup_pids_parent = 77 [default = "NSJAIL"];
inline bool NsJailConfig::has_cgroup_pids_parent() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U);
  return value;
}
inline void NsJailConfig::clear_cgroup_pids_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_pids_parent_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_pids_parent_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
}
inline const ::std::string& NsJailConfig::cgroup_pids_parent() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_pids_parent)
  if (_impl_.cgroup_pids_parent_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_pids_parent_.get();
  }
  return _internal_cgroup_pids_parent();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_pids_parent(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  _impl_.cgroup_pids_parent_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_pids_parent)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_pids_parent()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  ::std::string* _s = _internal_mutable_cgroup_pids_parent();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_pids_parent)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_pids_parent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_pids_parent_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_pids_parent(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_pids_parent_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_pids_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_pids_parent_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_pids_parent_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_pids_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_pids_parent)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
  return _impl_.cgroup_pids_parent_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_pids_parent(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
  }
  _impl_.cgroup_pids_parent_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_pids_parent)
}

// optional uint32 cgroup_net_cls_classid = 78 [default = 0];
inline bool NsJailConfig::has_cgroup_net_cls_classid() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000040U);
  return value;
}
inline void NsJailConfig::clear_cgroup_net_cls_classid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_net_cls_classid_ = 0u;
  ClearHasBit(_impl_._has_bits_[2], 0x00000040U);
}
inline ::uint32_t NsJailConfig::cgroup_net_cls_classid() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_net_cls_classid)
  return _internal_cgroup_net_cls_classid();
}
inline void NsJailConfig::set_cgroup_net_cls_classid(::uint32_t value) {
  _internal_set_cgroup_net_cls_classid(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000040U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_net_cls_classid)
}
inline ::uint32_t NsJailConfig::_internal_cgroup_net_cls_classid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_net_cls_classid_;
}
inline void NsJailConfig::_internal_set_cgroup_net_cls_classid(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_net_cls_classid_ = value;
}

// optional string cgroup_net_cls_mount = 79 [default = "/sys/fs/cgroup/net_cls"];
inline bool NsJailConfig::has_cgroup_net_cls_mount() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U);
  return value;
}
inline void NsJailConfig::clear_cgroup_net_cls_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_net_cls_mount_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_net_cls_mount_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
}
inline const ::std::string& NsJailConfig::cgroup_net_cls_mount() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_net_cls_mount)
  if (_impl_.cgroup_net_cls_mount_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_net_cls_mount_.get();
  }
  return _internal_cgroup_net_cls_mount();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_net_cls_mount(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  _impl_.cgroup_net_cls_mount_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_net_cls_mount)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_net_cls_mount()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  ::std::string* _s = _internal_mutable_cgroup_net_cls_mount();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_net_cls_mount)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_net_cls_mount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_net_cls_mount_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_net_cls_mount(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_net_cls_mount_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_net_cls_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_net_cls_mount_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_net_cls_mount_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_net_cls_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_net_cls_mount)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
  return _impl_.cgroup_net_cls_mount_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_net_cls_mount(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
  }
  _impl_.cgroup_net_cls_mount_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_net_cls_mount)
}

// optional string cgroup_net_cls_parent = 80 [default = "NSJAIL"];
inline bool NsJailConfig::has_cgroup_net_cls_parent() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U);
  return value;
}
inline void NsJailConfig::clear_cgroup_net_cls_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_net_cls_parent_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_net_cls_parent_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000400U);
}
inline const ::std::string& NsJailConfig::cgroup_net_cls_parent() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_net_cls_parent)
  if (_impl_.cgroup_net_cls_parent_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_net_cls_parent_.get();
  }
  return _internal_cgroup_net_cls_parent();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_net_cls_parent(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000400U);
  _impl_.cgroup_net_cls_parent_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_net_cls_parent)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_net_cls_parent()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000400U);
  ::std::string* _s = _internal_mutable_cgroup_net_cls_parent();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_net_cls_parent)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_net_cls_parent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_net_cls_parent_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_net_cls_parent(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_net_cls_parent_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_net_cls_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_net_cls_parent_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_net_cls_parent_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_net_cls_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_net_cls_parent)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000400U);
  return _impl_.cgroup_net_cls_parent_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_net_cls_parent(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000400U);
  }
  _impl_.cgroup_net_cls_parent_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_net_cls_parent)
}

// optional uint32 cgroup_cpu_ms_per_sec = 81 [default = 0];
inline bool NsJailConfig::has_cgroup_cpu_ms_per_sec() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000080U);
  return value;
}
inline void NsJailConfig::clear_cgroup_cpu_ms_per_sec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_cpu_ms_per_sec_ = 0u;
  ClearHasBit(_impl_._has_bits_[2], 0x00000080U);
}
inline ::uint32_t NsJailConfig::cgroup_cpu_ms_per_sec() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_cpu_ms_per_sec)
  return _internal_cgroup_cpu_ms_per_sec();
}
inline void NsJailConfig::set_cgroup_cpu_ms_per_sec(::uint32_t value) {
  _internal_set_cgroup_cpu_ms_per_sec(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000080U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_cpu_ms_per_sec)
}
inline ::uint32_t NsJailConfig::_internal_cgroup_cpu_ms_per_sec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_cpu_ms_per_sec_;
}
inline void NsJailConfig::_internal_set_cgroup_cpu_ms_per_sec(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_cpu_ms_per_sec_ = value;
}

// optional string cgroup_cpu_mount = 82 [default = "/sys/fs/cgroup/cpu"];
inline bool NsJailConfig::has_cgroup_cpu_mount() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U);
  return value;
}
inline void NsJailConfig::clear_cgroup_cpu_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_cpu_mount_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_cpu_mount_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000800U);
}
inline const ::std::string& NsJailConfig::cgroup_cpu_mount() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_cpu_mount)
  if (_impl_.cgroup_cpu_mount_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_cpu_mount_.get();
  }
  return _internal_cgroup_cpu_mount();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_cpu_mount(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000800U);
  _impl_.cgroup_cpu_mount_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_cpu_mount)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_cpu_mount()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000800U);
  ::std::string* _s = _internal_mutable_cgroup_cpu_mount();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_cpu_mount)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_cpu_mount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_cpu_mount_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_cpu_mount(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_cpu_mount_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_cpu_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_cpu_mount_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_cpu_mount_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_cpu_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_cpu_mount)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000800U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000800U);
  return _impl_.cgroup_cpu_mount_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_cpu_mount(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000800U);
  }
  _impl_.cgroup_cpu_mount_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_cpu_mount)
}

// optional string cgroup_cpu_parent = 83 [default = "NSJAIL"];
inline bool NsJailConfig::has_cgroup_cpu_parent() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U);
  return value;
}
inline void NsJailConfig::clear_cgroup_cpu_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_cpu_parent_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_cpu_parent_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00001000U);
}
inline const ::std::string& NsJailConfig::cgroup_cpu_parent() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroup_cpu_parent)
  if (_impl_.cgroup_cpu_parent_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroup_cpu_parent_.get();
  }
  return _internal_cgroup_cpu_parent();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroup_cpu_parent(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00001000U);
  _impl_.cgroup_cpu_parent_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroup_cpu_parent)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroup_cpu_parent()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00001000U);
  ::std::string* _s = _internal_mutable_cgroup_cpu_parent();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroup_cpu_parent)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroup_cpu_parent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroup_cpu_parent_.Get();
}
inline void NsJailConfig::_internal_set_cgroup_cpu_parent(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroup_cpu_parent_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroup_cpu_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroup_cpu_parent_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroup_cpu_parent_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroup_cpu_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroup_cpu_parent)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00001000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00001000U);
  return _impl_.cgroup_cpu_parent_.Release();
}
inline void NsJailConfig::set_allocated_cgroup_cpu_parent(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00001000U);
  }
  _impl_.cgroup_cpu_parent_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroup_cpu_parent)
}

// optional string cgroupv2_mount = 84 [default = "/sys/fs/cgroup"];
inline bool NsJailConfig::has_cgroupv2_mount() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00002000U);
  return value;
}
inline void NsJailConfig::clear_cgroupv2_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroupv2_mount_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroupv2_mount_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00002000U);
}
inline const ::std::string& NsJailConfig::cgroupv2_mount() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.cgroupv2_mount)
  if (_impl_.cgroupv2_mount_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_cgroupv2_mount_.get();
  }
  return _internal_cgroupv2_mount();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_cgroupv2_mount(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00002000U);
  _impl_.cgroupv2_mount_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.cgroupv2_mount)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_cgroupv2_mount()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00002000U);
  ::std::string* _s = _internal_mutable_cgroupv2_mount();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.cgroupv2_mount)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_cgroupv2_mount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cgroupv2_mount_.Get();
}
inline void NsJailConfig::_internal_set_cgroupv2_mount(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cgroupv2_mount_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_cgroupv2_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.cgroupv2_mount_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_cgroupv2_mount_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_cgroupv2_mount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.cgroupv2_mount)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00002000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00002000U);
  return _impl_.cgroupv2_mount_.Release();
}
inline void NsJailConfig::set_allocated_cgroupv2_mount(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00002000U);
  }
  _impl_.cgroupv2_mount_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.cgroupv2_mount)
}

// optional bool use_cgroupv2 = 85 [default = false];
inline bool NsJailConfig::has_use_cgroupv2() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000200U);
  return value;
}
inline void NsJailConfig::clear_use_cgroupv2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_cgroupv2_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000200U);
}
inline bool NsJailConfig::use_cgroupv2() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.use_cgroupv2)
  return _internal_use_cgroupv2();
}
inline void NsJailConfig::set_use_cgroupv2(bool value) {
  _internal_set_use_cgroupv2(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000200U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.use_cgroupv2)
}
inline bool NsJailConfig::_internal_use_cgroupv2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_cgroupv2_;
}
inline void NsJailConfig::_internal_set_use_cgroupv2(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_cgroupv2_ = value;
}

// optional bool detect_cgroupv2 = 86 [default = false];
inline bool NsJailConfig::has_detect_cgroupv2() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000400U);
  return value;
}
inline void NsJailConfig::clear_detect_cgroupv2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detect_cgroupv2_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000400U);
}
inline bool NsJailConfig::detect_cgroupv2() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.detect_cgroupv2)
  return _internal_detect_cgroupv2();
}
inline void NsJailConfig::set_detect_cgroupv2(bool value) {
  _internal_set_detect_cgroupv2(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000400U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.detect_cgroupv2)
}
inline bool NsJailConfig::_internal_detect_cgroupv2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.detect_cgroupv2_;
}
inline void NsJailConfig::_internal_set_detect_cgroupv2(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detect_cgroupv2_ = value;
}

// optional bool iface_no_lo = 87 [default = false];
inline bool NsJailConfig::has_iface_no_lo() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000800U);
  return value;
}
inline void NsJailConfig::clear_iface_no_lo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.iface_no_lo_ = false;
  ClearHasBit(_impl_._has_bits_[2], 0x00000800U);
}
inline bool NsJailConfig::iface_no_lo() const {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.iface_no_lo)
  return _internal_iface_no_lo();
}
inline void NsJailConfig::set_iface_no_lo(bool value) {
  _internal_set_iface_no_lo(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000800U);
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.iface_no_lo)
}
inline bool NsJailConfig::_internal_iface_no_lo() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.iface_no_lo_;
}
inline void NsJailConfig::_internal_set_iface_no_lo(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.iface_no_lo_ = value;
}

// repeated string iface_own = 88;
inline int NsJailConfig::_internal_iface_own_size() const {
  return _internal_iface_own().size();
}
inline int NsJailConfig::iface_own_size() const {
  return _internal_iface_own_size();
}
inline void NsJailConfig::clear_iface_own() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.iface_own_.Clear();
  ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::add_iface_own()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_iface_own()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  // @@protoc_insertion_point(field_add_mutable:nsjail.NsJailConfig.iface_own)
  return _s;
}
inline const ::std::string& NsJailConfig::iface_own(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.iface_own)
  return _internal_iface_own().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_iface_own(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.iface_own)
  return _internal_mutable_iface_own()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::set_iface_own(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_iface_own()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.iface_own)
}
template <typename Arg_, typename... Args_>
inline void NsJailConfig::add_iface_own(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_iface_own(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  // @@protoc_insertion_point(field_add:nsjail.NsJailConfig.iface_own)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NsJailConfig::iface_own()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:nsjail.NsJailConfig.iface_own)
  return _internal_iface_own();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::mutable_iface_own() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:nsjail.NsJailConfig.iface_own)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_iface_own();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NsJailConfig::_internal_iface_own() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.iface_own_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NsJailConfig::_internal_mutable_iface_own() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.iface_own_;
}

// optional string macvlan_iface = 89;
inline bool NsJailConfig::has_macvlan_iface() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00004000U);
  return value;
}
inline void NsJailConfig::clear_macvlan_iface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_iface_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00004000U);
}
inline const ::std::string& NsJailConfig::macvlan_iface() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.macvlan_iface)
  return _internal_macvlan_iface();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_macvlan_iface(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00004000U);
  _impl_.macvlan_iface_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.macvlan_iface)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_macvlan_iface()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00004000U);
  ::std::string* _s = _internal_mutable_macvlan_iface();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.macvlan_iface)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_macvlan_iface() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.macvlan_iface_.Get();
}
inline void NsJailConfig::_internal_set_macvlan_iface(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_iface_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_macvlan_iface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.macvlan_iface_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_macvlan_iface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.macvlan_iface)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00004000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00004000U);
  auto* released = _impl_.macvlan_iface_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.macvlan_iface_.Set("", GetArena());
  }
  return released;
}
inline void NsJailConfig::set_allocated_macvlan_iface(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00004000U);
  }
  _impl_.macvlan_iface_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.macvlan_iface_.IsDefault()) {
    _impl_.macvlan_iface_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.macvlan_iface)
}

// optional string macvlan_vs_ip = 90 [default = "192.168.0.2"];
inline bool NsJailConfig::has_macvlan_vs_ip() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00008000U);
  return value;
}
inline void NsJailConfig::clear_macvlan_vs_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_ip_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_ip_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00008000U);
}
inline const ::std::string& NsJailConfig::macvlan_vs_ip() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.macvlan_vs_ip)
  if (_impl_.macvlan_vs_ip_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_ip_.get();
  }
  return _internal_macvlan_vs_ip();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_macvlan_vs_ip(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00008000U);
  _impl_.macvlan_vs_ip_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.macvlan_vs_ip)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_macvlan_vs_ip()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00008000U);
  ::std::string* _s = _internal_mutable_macvlan_vs_ip();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.macvlan_vs_ip)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_macvlan_vs_ip() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.macvlan_vs_ip_.Get();
}
inline void NsJailConfig::_internal_set_macvlan_vs_ip(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_ip_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_macvlan_vs_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.macvlan_vs_ip_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_ip_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_macvlan_vs_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.macvlan_vs_ip)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00008000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00008000U);
  return _impl_.macvlan_vs_ip_.Release();
}
inline void NsJailConfig::set_allocated_macvlan_vs_ip(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00008000U);
  }
  _impl_.macvlan_vs_ip_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.macvlan_vs_ip)
}

// optional string macvlan_vs_nm = 91 [default = "255.255.255.0"];
inline bool NsJailConfig::has_macvlan_vs_nm() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00010000U);
  return value;
}
inline void NsJailConfig::clear_macvlan_vs_nm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_nm_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_nm_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00010000U);
}
inline const ::std::string& NsJailConfig::macvlan_vs_nm() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.macvlan_vs_nm)
  if (_impl_.macvlan_vs_nm_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_nm_.get();
  }
  return _internal_macvlan_vs_nm();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_macvlan_vs_nm(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00010000U);
  _impl_.macvlan_vs_nm_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.macvlan_vs_nm)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_macvlan_vs_nm()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00010000U);
  ::std::string* _s = _internal_mutable_macvlan_vs_nm();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.macvlan_vs_nm)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_macvlan_vs_nm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.macvlan_vs_nm_.Get();
}
inline void NsJailConfig::_internal_set_macvlan_vs_nm(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_nm_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_macvlan_vs_nm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.macvlan_vs_nm_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_nm_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_macvlan_vs_nm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.macvlan_vs_nm)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00010000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00010000U);
  return _impl_.macvlan_vs_nm_.Release();
}
inline void NsJailConfig::set_allocated_macvlan_vs_nm(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00010000U);
  }
  _impl_.macvlan_vs_nm_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.macvlan_vs_nm)
}

// optional string macvlan_vs_gw = 92 [default = "192.168.0.1"];
inline bool NsJailConfig::has_macvlan_vs_gw() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00020000U);
  return value;
}
inline void NsJailConfig::clear_macvlan_vs_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_gw_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_gw_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00020000U);
}
inline const ::std::string& NsJailConfig::macvlan_vs_gw() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.macvlan_vs_gw)
  if (_impl_.macvlan_vs_gw_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_gw_.get();
  }
  return _internal_macvlan_vs_gw();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_macvlan_vs_gw(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00020000U);
  _impl_.macvlan_vs_gw_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.macvlan_vs_gw)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_macvlan_vs_gw()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00020000U);
  ::std::string* _s = _internal_mutable_macvlan_vs_gw();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.macvlan_vs_gw)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_macvlan_vs_gw() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.macvlan_vs_gw_.Get();
}
inline void NsJailConfig::_internal_set_macvlan_vs_gw(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_gw_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_macvlan_vs_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.macvlan_vs_gw_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_gw_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_macvlan_vs_gw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.macvlan_vs_gw)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00020000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00020000U);
  return _impl_.macvlan_vs_gw_.Release();
}
inline void NsJailConfig::set_allocated_macvlan_vs_gw(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00020000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00020000U);
  }
  _impl_.macvlan_vs_gw_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.macvlan_vs_gw)
}

// optional string macvlan_vs_ma = 93 [default = ""];
inline bool NsJailConfig::has_macvlan_vs_ma() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00040000U);
  return value;
}
inline void NsJailConfig::clear_macvlan_vs_ma() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_ma_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00040000U);
}
inline const ::std::string& NsJailConfig::macvlan_vs_ma() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.macvlan_vs_ma)
  return _internal_macvlan_vs_ma();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_macvlan_vs_ma(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00040000U);
  _impl_.macvlan_vs_ma_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.macvlan_vs_ma)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_macvlan_vs_ma()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00040000U);
  ::std::string* _s = _internal_mutable_macvlan_vs_ma();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.macvlan_vs_ma)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_macvlan_vs_ma() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.macvlan_vs_ma_.Get();
}
inline void NsJailConfig::_internal_set_macvlan_vs_ma(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_ma_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_macvlan_vs_ma() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.macvlan_vs_ma_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_macvlan_vs_ma() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.macvlan_vs_ma)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00040000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00040000U);
  auto* released = _impl_.macvlan_vs_ma_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.macvlan_vs_ma_.Set("", GetArena());
  }
  return released;
}
inline void NsJailConfig::set_allocated_macvlan_vs_ma(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00040000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00040000U);
  }
  _impl_.macvlan_vs_ma_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.macvlan_vs_ma_.IsDefault()) {
    _impl_.macvlan_vs_ma_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.macvlan_vs_ma)
}

// optional string macvlan_vs_mo = 94 [default = "private"];
inline bool NsJailConfig::has_macvlan_vs_mo() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00080000U);
  return value;
}
inline void NsJailConfig::clear_macvlan_vs_mo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_mo_.ClearToDefault(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_mo_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00080000U);
}
inline const ::std::string& NsJailConfig::macvlan_vs_mo() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.macvlan_vs_mo)
  if (_impl_.macvlan_vs_mo_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_mo_.get();
  }
  return _internal_macvlan_vs_mo();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NsJailConfig::set_macvlan_vs_mo(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00080000U);
  _impl_.macvlan_vs_mo_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:nsjail.NsJailConfig.macvlan_vs_mo)
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::mutable_macvlan_vs_mo()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00080000U);
  ::std::string* _s = _internal_mutable_macvlan_vs_mo();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.macvlan_vs_mo)
  return _s;
}
inline const ::std::string& NsJailConfig::_internal_macvlan_vs_mo() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.macvlan_vs_mo_.Get();
}
inline void NsJailConfig::_internal_set_macvlan_vs_mo(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.macvlan_vs_mo_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_macvlan_vs_mo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.macvlan_vs_mo_.Mutable(::nsjail::NsJailConfig::Impl_::_i_give_permission_to_break_this_code_default_macvlan_vs_mo_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NsJailConfig::release_macvlan_vs_mo() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.macvlan_vs_mo)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00080000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00080000U);
  return _impl_.macvlan_vs_mo_.Release();
}
inline void NsJailConfig::set_allocated_macvlan_vs_mo(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00080000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00080000U);
  }
  _impl_.macvlan_vs_mo_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.macvlan_vs_mo)
}

// optional .nsjail.NsJailConfig.UserNet user_net = 95;
inline bool NsJailConfig::has_user_net() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00100000U);
  PROTOBUF_ASSUME(!value || _impl_.user_net_ != nullptr);
  return value;
}
inline void NsJailConfig::clear_user_net() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.user_net_ != nullptr) _impl_.user_net_->Clear();
  ClearHasBit(_impl_._has_bits_[1], 0x00100000U);
}
inline const ::nsjail::NsJailConfig_UserNet& NsJailConfig::_internal_user_net() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::nsjail::NsJailConfig_UserNet* p = _impl_.user_net_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::nsjail::NsJailConfig_UserNet>(&::nsjail::NsJailConfig_UserNet_globals_);
}
inline const ::nsjail::NsJailConfig_UserNet& NsJailConfig::user_net() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.user_net)
  return _internal_user_net();
}
inline void NsJailConfig::unsafe_arena_set_allocated_user_net(
    ::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.user_net_);
  }
  _impl_.user_net_ = reinterpret_cast<::nsjail::NsJailConfig_UserNet*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00100000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00100000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nsjail.NsJailConfig.user_net)
}
inline ::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE NsJailConfig::release_user_net() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00100000U);
  ::nsjail::NsJailConfig_UserNet* released = _impl_.user_net_;
  _impl_.user_net_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE NsJailConfig::unsafe_arena_release_user_net() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.user_net)

  ClearHasBit(_impl_._has_bits_[1], 0x00100000U);
  ::nsjail::NsJailConfig_UserNet* temp = _impl_.user_net_;
  _impl_.user_net_ = nullptr;
  return temp;
}
inline ::nsjail::NsJailConfig_UserNet* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_user_net() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.user_net_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::nsjail::NsJailConfig_UserNet>(GetArena());
    _impl_.user_net_ = reinterpret_cast<::nsjail::NsJailConfig_UserNet*>(p);
  }
  return _impl_.user_net_;
}
inline ::nsjail::NsJailConfig_UserNet* PROTOBUF_NONNULL NsJailConfig::mutable_user_net()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00100000U);
  ::nsjail::NsJailConfig_UserNet* _msg = _internal_mutable_user_net();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.user_net)
  return _msg;
}
inline void NsJailConfig::set_allocated_user_net(::nsjail::NsJailConfig_UserNet* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.user_net_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[1], 0x00100000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00100000U);
  }

  _impl_.user_net_ = reinterpret_cast<::nsjail::NsJailConfig_UserNet*>(value);
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.user_net)
}

// optional .nsjail.Exe exec_bin = 96;
inline bool NsJailConfig::has_exec_bin() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00200000U);
  PROTOBUF_ASSUME(!value || _impl_.exec_bin_ != nullptr);
  return value;
}
inline void NsJailConfig::clear_exec_bin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.exec_bin_ != nullptr) _impl_.exec_bin_->Clear();
  ClearHasBit(_impl_._has_bits_[1], 0x00200000U);
}
inline const ::nsjail::Exe& NsJailConfig::_internal_exec_bin() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::nsjail::Exe* p = _impl_.exec_bin_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::nsjail::Exe>(&::nsjail::Exe_globals_);
}
inline const ::nsjail::Exe& NsJailConfig::exec_bin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:nsjail.NsJailConfig.exec_bin)
  return _internal_exec_bin();
}
inline void NsJailConfig::unsafe_arena_set_allocated_exec_bin(
    ::nsjail::Exe* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.exec_bin_);
  }
  _impl_.exec_bin_ = reinterpret_cast<::nsjail::Exe*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00200000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00200000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nsjail.NsJailConfig.exec_bin)
}
inline ::nsjail::Exe* PROTOBUF_NULLABLE NsJailConfig::release_exec_bin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00200000U);
  ::nsjail::Exe* released = _impl_.exec_bin_;
  _impl_.exec_bin_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::nsjail::Exe* PROTOBUF_NULLABLE NsJailConfig::unsafe_arena_release_exec_bin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:nsjail.NsJailConfig.exec_bin)

  ClearHasBit(_impl_._has_bits_[1], 0x00200000U);
  ::nsjail::Exe* temp = _impl_.exec_bin_;
  _impl_.exec_bin_ = nullptr;
  return temp;
}
inline ::nsjail::Exe* PROTOBUF_NONNULL NsJailConfig::_internal_mutable_exec_bin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.exec_bin_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::nsjail::Exe>(GetArena());
    _impl_.exec_bin_ = reinterpret_cast<::nsjail::Exe*>(p);
  }
  return _impl_.exec_bin_;
}
inline ::nsjail::Exe* PROTOBUF_NONNULL NsJailConfig::mutable_exec_bin()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00200000U);
  ::nsjail::Exe* _msg = _internal_mutable_exec_bin();
  // @@protoc_insertion_point(field_mutable:nsjail.NsJailConfig.exec_bin)
  return _msg;
}
inline void NsJailConfig::set_allocated_exec_bin(::nsjail::Exe* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.exec_bin_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[1], 0x00200000U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00200000U);
  }

  _impl_.exec_bin_ = reinterpret_cast<::nsjail::Exe*>(value);
  // @@protoc_insertion_point(field_set_allocated:nsjail.NsJailConfig.exec_bin)
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace nsjail


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::nsjail::Mode> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::nsjail::Mode>() {
  return ::nsjail::Mode_descriptor();
}
template <>
struct is_proto_enum<::nsjail::LogLevel> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::nsjail::LogLevel>() {
  return ::nsjail::LogLevel_descriptor();
}
template <>
struct is_proto_enum<::nsjail::RLimit> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::nsjail::RLimit>() {
  return ::nsjail::RLimit_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // config_2eproto_2epb_2eh
