text: /* Generated SBE (Simple Binary Encoding) message codec */
  #ifndef _ILINKBINARY_ORDERCANCELREPLACEREJECT536_H_
  #define _ILINKBINARY_ORDERCANCELREPLACEREJECT536_H_
  
  #if defined(SBE_HAVE_CMATH)
  /* cmath needed for std::numeric_limits<double>::quiet_NaN() */
  #  include <cmath>
  #  define SBE_FLOAT_NAN std::numeric_limits<float>::quiet_NaN()
  #  define SBE_DOUBLE_NAN std::numeric_limits<double>::quiet_NaN()
  #else
  /* math.h needed for NAN */
  #  include <math.h>
  #  define SBE_FLOAT_NAN NAN
  #  define SBE_DOUBLE_NAN NAN
  #endif
  
  #if __cplusplus >= 201103L
  #  define SBE_CONSTEXPR constexpr
  #  define SBE_NOEXCEPT noexcept
  #else
  #  define SBE_CONSTEXPR
  #  define SBE_NOEXCEPT
  #endif
  
  #if __cplusplus >= 201402L
  #  define SBE_CONSTEXPR_14 constexpr
  #else
  #  define SBE_CONSTEXPR_14
  #endif
  
  #if __cplusplus >= 201703L
  #  include <string_view>
  #  define SBE_NODISCARD [[nodiscard]]
  #else
  #  define SBE_NODISCARD
  #endif
  
  #if !defined(__STDC_LIMIT_MACROS)
  #  define __STDC_LIMIT_MACROS 1
  #endif
  
  #include <cstdint>
  #include <cstring>
  #include <iomanip>
  #include <limits>
  #include <ostream>
  #include <stdexcept>
  #include <sstream>
  #include <string>
  #include <vector>
  
  #if defined(WIN32) || defined(_WIN32)
  #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
  #  define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v)
  #  define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v)
  #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  #  define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v)
  #  define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v)
  #  define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v)
  #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  #  define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v)
  #  define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v)
  #  define SBE_BIG_ENDIAN_ENCODE_16(v) (v)
  #  define SBE_BIG_ENDIAN_ENCODE_32(v) (v)
  #  define SBE_BIG_ENDIAN_ENCODE_64(v) (v)
  #else
  #  error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file."
  #endif
  
  #if defined(SBE_NO_BOUNDS_CHECK)
  #  define SBE_BOUNDS_CHECK_EXPECT(exp,c) (false)
  #elif defined(_MSC_VER)
  #  define SBE_BOUNDS_CHECK_EXPECT(exp,c) (exp)
  #else
  #  define SBE_BOUNDS_CHECK_EXPECT(exp,c) (__builtin_expect(exp,c))
  #endif
  
  #define SBE_NULLVALUE_INT8 (std::numeric_limits<std::int8_t>::min)()
  #define SBE_NULLVALUE_INT16 (std::numeric_limits<std::int16_t>::min)()
  #define SBE_NULLVALUE_INT32 (std::numeric_limits<std::int32_t>::min)()
  #define SBE_NULLVALUE_INT64 (std::numeric_limits<std::int64_t>::min)()
  #define SBE_NULLVALUE_UINT8 (std::numeric_limits<std::uint8_t>::max)()
  #define SBE_NULLVALUE_UINT16 (std::numeric_limits<std::uint16_t>::max)()
  #define SBE_NULLVALUE_UINT32 (std::numeric_limits<std::uint32_t>::max)()
  #define SBE_NULLVALUE_UINT64 (std::numeric_limits<std::uint64_t>::max)()
  
  
  #include "MaturityMonthYear.h"
  #include "Decimal64NULL.h"
  #include "OrderTypeReq.h"
  #include "BooleanNULL.h"
  #include "AvgPxInd.h"
  #include "OrderEventType.h"
  #include "CmtaGiveUpCD.h"
  #include "PRICENULL9.h"
  #include "BooleanFlag.h"
  #include "OrderType.h"
  #include "QuoteCxlStatus.h"
  #include "TimeInForce.h"
  #include "PRICE9.h"
  #include "MassStatusOrdTyp.h"
  #include "ExecInst.h"
  #include "Decimal32NULL.h"
  #include "SplitMsg.h"
  #include "SideReq.h"
  #include "MassActionResponse.h"
  #include "CustOrderCapacity.h"
  #include "SideTimeInForce.h"
  #include "SLEDS.h"
  #include "ReqResult.h"
  #include "ClearingAcctType.h"
  #include "KeepAliveLapsed.h"
  #include "ExecAckStatus.h"
  #include "DATA.h"
  #include "OFMOverrideReq.h"
  #include "SideNULL.h"
  #include "GroupSize.h"
  #include "ListUpdAct.h"
  #include "FTI.h"
  #include "ExecReason.h"
  #include "MassStatusReqTyp.h"
  #include "DKReason.h"
  #include "SecRspTyp.h"
  #include "MassActionOrdTyp.h"
  #include "QuoteAckStatus.h"
  #include "ExpCycle.h"
  #include "MassCancelTIF.h"
  #include "OrderStatus.h"
  #include "ShortSaleType.h"
  #include "PartyDetailRole.h"
  #include "MassActionScope.h"
  #include "RFQSide.h"
  #include "OrdStatusTrdCxl.h"
  #include "TradeAddendum.h"
  #include "MessageHeader.h"
  #include "ManualOrdInd.h"
  #include "QuoteCxlTyp.h"
  #include "MassCxlReqTyp.h"
  #include "ExecTypTrdCxl.h"
  #include "ManualOrdIndReq.h"
  #include "CustOrdHandlInst.h"
  #include "OrdStatusTrd.h"
  #include "MassStatusTIF.h"
  #include "SMPI.h"
  #include "ExecMode.h"
  #include "QuoteTyp.h"
  
  namespace iLinkBinary {
  
  class OrderCancelReplaceReject536
  {
  private:
      char *m_buffer = nullptr;
      std::uint64_t m_bufferLength = 0;
      std::uint64_t m_offset = 0;
      std::uint64_t m_position = 0;
      std::uint64_t m_actingVersion = 0;
  
      inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT
      {
          return &m_position;
      }
  
  public:
      enum MetaAttribute
      {
          EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
      };
  
      union sbe_float_as_uint_u
      {
          float fp_value;
          std::uint32_t uint_value;
      };
  
      union sbe_double_as_uint_u
      {
          double fp_value;
          std::uint64_t uint_value;
      };
  
      OrderCancelReplaceReject536() = default;
  
      OrderCancelReplaceReject536(
          char *buffer,
          const std::uint64_t offset,
          const std::uint64_t bufferLength,
          const std::uint64_t actingBlockLength,
          const std::uint64_t actingVersion) :
          m_buffer(buffer),
          m_bufferLength(bufferLength),
          m_offset(offset),
          m_position(sbeCheckPosition(offset + actingBlockLength)),
          m_actingVersion(actingVersion)
      {
      }
  
      OrderCancelReplaceReject536(char *buffer, const std::uint64_t bufferLength) :
          OrderCancelReplaceReject536(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion())
      {
      }
  
      OrderCancelReplaceReject536(
          char *buffer,
          const std::uint64_t bufferLength,
          const std::uint64_t actingBlockLength,
          const std::uint64_t actingVersion) :
          OrderCancelReplaceReject536(buffer, 0, bufferLength, actingBlockLength, actingVersion)
      {
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
      {
          return (std::uint16_t)409;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
      {
          return MessageHeader::encodedLength() + sbeBlockLength();
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
      {
          return (std::uint16_t)536;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
      {
          return (std::uint16_t)8;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
      {
          return (std::uint16_t)5;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
      {
          return "9";
      }
  
      SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT
      {
          return m_offset;
      }
  
      OrderCancelReplaceReject536 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
      {
          return *this = OrderCancelReplaceReject536(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion());
      }
  
      OrderCancelReplaceReject536 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
      {
          MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
  
          hdr
              .blockLength(sbeBlockLength())
              .templateId(sbeTemplateId())
              .schemaId(sbeSchemaId())
              .version(sbeSchemaVersion());
  
          return *this = OrderCancelReplaceReject536(
              buffer,
              offset + MessageHeader::encodedLength(),
              bufferLength,
              sbeBlockLength(),
              sbeSchemaVersion());
      }
  
      OrderCancelReplaceReject536 &wrapForDecode(
          char *buffer,
          const std::uint64_t offset,
          const std::uint64_t actingBlockLength,
          const std::uint64_t actingVersion,
          const std::uint64_t bufferLength)
      {
          return *this = OrderCancelReplaceReject536(buffer, offset, bufferLength, actingBlockLength, actingVersion);
      }
  
      SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT
      {
          return m_position;
      }
  
      // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
      std::uint64_t sbeCheckPosition(const std::uint64_t position)
      {
          if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false))
          {
              throw std::runtime_error("buffer too short [E100]");
          }
          return position;
      }
  
      void sbePosition(const std::uint64_t position)
      {
          m_position = sbeCheckPosition(position);
      }
  
      SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT
      {
          return sbePosition() - m_offset;
      }
  
      SBE_NODISCARD std::uint64_t decodeLength() const
      {
          OrderCancelReplaceReject536 skipper(m_buffer, m_offset,
              m_bufferLength, sbeBlockLength(), m_actingVersion);
          skipper.skip();
          return skipper.encodedLength();
      }
  
      SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
      {
          return m_buffer;
      }
  
      SBE_NODISCARD char * buffer() SBE_NOEXCEPT
      {
          return m_buffer;
      }
  
      SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT
      {
          return m_bufferLength;
      }
  
      SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT
      {
          return m_actingVersion;
      }
  
      SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT
      {
          return 9726;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= seqNumSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT
      {
          return 0;
      }
  
      static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT32;
      }
  
      static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
      {
          return 0;
      }
  
      static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
      {
          return 4294967294;
      }
  
      static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
      {
          return 4;
      }
  
      SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT
      {
          std::uint32_t val;
          std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t));
          return SBE_LITTLE_ENDIAN_ENCODE_32(val);
      }
  
      OrderCancelReplaceReject536 &seqNum(const std::uint32_t value) SBE_NOEXCEPT
      {
          std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value);
          std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT
      {
          return 39001;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= uUIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT
      {
          return 4;
      }
  
      static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT64;
      }
  
      static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT
      {
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &uUID(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "String";
              case MetaAttribute::PRESENCE: return "optional";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT
      {
          return 58;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= textSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT
      {
          return 12;
      }
  
      static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
      {
          return 256;
      }
  
      static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT
      {
          return 256;
      }
  
      SBE_NODISCARD const char *text() const SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 12;
      }
  
      SBE_NODISCARD char *text() SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 12;
      }
  
      SBE_NODISCARD char text(const std::uint64_t index) const
      {
          if (index >= 256)
          {
              throw std::runtime_error("index out of range for text [E104]");
          }
  
          char val;
          std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char));
          return (val);
      }
  
      OrderCancelReplaceReject536 &text(const std::uint64_t index, const char value)
      {
          if (index >= 256)
          {
              throw std::runtime_error("index out of range for text [E105]");
          }
  
          char val = (value);
          std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char));
          return *this;
      }
  
      std::uint64_t getText(char *const dst, const std::uint64_t length) const
      {
          if (length > 256)
          {
              throw std::runtime_error("length too large for getText [E106]");
          }
  
          std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<size_t>(length));
          return length;
      }
  
      OrderCancelReplaceReject536 &putText(const char *const src) SBE_NOEXCEPT
      {
          std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256);
          return *this;
      }
  
      SBE_NODISCARD std::string getTextAsString() const
      {
          const char *buffer = m_buffer + m_offset + 12;
          size_t length = 0;
  
          for (; length < 256 && *(buffer + length) != '\0'; ++length);
          std::string result(buffer, length);
  
          return result;
      }
  
      std::string getTextAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getTextAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      #if __cplusplus >= 201703L
      SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
      {
          const char *buffer = m_buffer + m_offset + 12;
          size_t length = 0;
  
          for (; length < 256 && *(buffer + length) != '\0'; ++length);
          std::string_view result(buffer, length);
  
          return result;
      }
      #endif
  
      #if __cplusplus >= 201703L
      OrderCancelReplaceReject536 &putText(const std::string_view str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 256)
          {
              throw std::runtime_error("string too large for putText [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength);
          for (size_t start = srcLength; start < 256; ++start)
          {
              m_buffer[m_offset + 12 + start] = 0;
          }
  
          return *this;
      }
      #else
      OrderCancelReplaceReject536 &putText(const std::string& str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 256)
          {
              throw std::runtime_error("string too large for putText [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength);
          for (size_t start = srcLength; start < 256; ++start)
          {
              m_buffer[m_offset + 12 + start] = 0;
          }
  
          return *this;
      }
      #endif
  
      SBE_NODISCARD static const char * ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "String";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT
      {
          return 17;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= execIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT
      {
          return 268;
      }
  
      static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT
      {
          return 40;
      }
  
      static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT
      {
          return 40;
      }
  
      SBE_NODISCARD const char *execID() const SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 268;
      }
  
      SBE_NODISCARD char *execID() SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 268;
      }
  
      SBE_NODISCARD char execID(const std::uint64_t index) const
      {
          if (index >= 40)
          {
              throw std::runtime_error("index out of range for execID [E104]");
          }
  
          char val;
          std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char));
          return (val);
      }
  
      OrderCancelReplaceReject536 &execID(const std::uint64_t index, const char value)
      {
          if (index >= 40)
          {
              throw std::runtime_error("index out of range for execID [E105]");
          }
  
          char val = (value);
          std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char));
          return *this;
      }
  
      std::uint64_t getExecID(char *const dst, const std::uint64_t length) const
      {
          if (length > 40)
          {
              throw std::runtime_error("length too large for getExecID [E106]");
          }
  
          std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<size_t>(length));
          return length;
      }
  
      OrderCancelReplaceReject536 &putExecID(const char *const src) SBE_NOEXCEPT
      {
          std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40);
          return *this;
      }
  
      SBE_NODISCARD std::string getExecIDAsString() const
      {
          const char *buffer = m_buffer + m_offset + 268;
          size_t length = 0;
  
          for (; length < 40 && *(buffer + length) != '\0'; ++length);
          std::string result(buffer, length);
  
          return result;
      }
  
      std::string getExecIDAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getExecIDAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      #if __cplusplus >= 201703L
      SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT
      {
          const char *buffer = m_buffer + m_offset + 268;
          size_t length = 0;
  
          for (; length < 40 && *(buffer + length) != '\0'; ++length);
          std::string_view result(buffer, length);
  
          return result;
      }
      #endif
  
      #if __cplusplus >= 201703L
      OrderCancelReplaceReject536 &putExecID(const std::string_view str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 40)
          {
              throw std::runtime_error("string too large for putExecID [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength);
          for (size_t start = srcLength; start < 40; ++start)
          {
              m_buffer[m_offset + 268 + start] = 0;
          }
  
          return *this;
      }
      #else
      OrderCancelReplaceReject536 &putExecID(const std::string& str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 40)
          {
              throw std::runtime_error("string too large for putExecID [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength);
          for (size_t start = srcLength; start < 40; ++start)
          {
              m_buffer[m_offset + 268 + start] = 0;
          }
  
          return *this;
      }
      #endif
  
      SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "String";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT
      {
          return 5392;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= senderIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT
      {
          return 308;
      }
  
      static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
      {
          return 20;
      }
  
      static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT
      {
          return 20;
      }
  
      SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 308;
      }
  
      SBE_NODISCARD char *senderID() SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 308;
      }
  
      SBE_NODISCARD char senderID(const std::uint64_t index) const
      {
          if (index >= 20)
          {
              throw std::runtime_error("index out of range for senderID [E104]");
          }
  
          char val;
          std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char));
          return (val);
      }
  
      OrderCancelReplaceReject536 &senderID(const std::uint64_t index, const char value)
      {
          if (index >= 20)
          {
              throw std::runtime_error("index out of range for senderID [E105]");
          }
  
          char val = (value);
          std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char));
          return *this;
      }
  
      std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const
      {
          if (length > 20)
          {
              throw std::runtime_error("length too large for getSenderID [E106]");
          }
  
          std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast<size_t>(length));
          return length;
      }
  
      OrderCancelReplaceReject536 &putSenderID(const char *const src) SBE_NOEXCEPT
      {
          std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20);
          return *this;
      }
  
      SBE_NODISCARD std::string getSenderIDAsString() const
      {
          const char *buffer = m_buffer + m_offset + 308;
          size_t length = 0;
  
          for (; length < 20 && *(buffer + length) != '\0'; ++length);
          std::string result(buffer, length);
  
          return result;
      }
  
      std::string getSenderIDAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getSenderIDAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      #if __cplusplus >= 201703L
      SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
      {
          const char *buffer = m_buffer + m_offset + 308;
          size_t length = 0;
  
          for (; length < 20 && *(buffer + length) != '\0'; ++length);
          std::string_view result(buffer, length);
  
          return result;
      }
      #endif
  
      #if __cplusplus >= 201703L
      OrderCancelReplaceReject536 &putSenderID(const std::string_view str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 20)
          {
              throw std::runtime_error("string too large for putSenderID [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength);
          for (size_t start = srcLength; start < 20; ++start)
          {
              m_buffer[m_offset + 308 + start] = 0;
          }
  
          return *this;
      }
      #else
      OrderCancelReplaceReject536 &putSenderID(const std::string& str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 20)
          {
              throw std::runtime_error("string too large for putSenderID [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength);
          for (size_t start = srcLength; start < 20; ++start)
          {
              m_buffer[m_offset + 308 + start] = 0;
          }
  
          return *this;
      }
      #endif
  
      SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "String";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT
      {
          return 11;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= clOrdIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT
      {
          return 328;
      }
  
      static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
      {
          return 20;
      }
  
      static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT
      {
          return 20;
      }
  
      SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 328;
      }
  
      SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 328;
      }
  
      SBE_NODISCARD char clOrdID(const std::uint64_t index) const
      {
          if (index >= 20)
          {
              throw std::runtime_error("index out of range for clOrdID [E104]");
          }
  
          char val;
          std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char));
          return (val);
      }
  
      OrderCancelReplaceReject536 &clOrdID(const std::uint64_t index, const char value)
      {
          if (index >= 20)
          {
              throw std::runtime_error("index out of range for clOrdID [E105]");
          }
  
          char val = (value);
          std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char));
          return *this;
      }
  
      std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const
      {
          if (length > 20)
          {
              throw std::runtime_error("length too large for getClOrdID [E106]");
          }
  
          std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast<size_t>(length));
          return length;
      }
  
      OrderCancelReplaceReject536 &putClOrdID(const char *const src) SBE_NOEXCEPT
      {
          std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20);
          return *this;
      }
  
      SBE_NODISCARD std::string getClOrdIDAsString() const
      {
          const char *buffer = m_buffer + m_offset + 328;
          size_t length = 0;
  
          for (; length < 20 && *(buffer + length) != '\0'; ++length);
          std::string result(buffer, length);
  
          return result;
      }
  
      std::string getClOrdIDAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getClOrdIDAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      #if __cplusplus >= 201703L
      SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
      {
          const char *buffer = m_buffer + m_offset + 328;
          size_t length = 0;
  
          for (; length < 20 && *(buffer + length) != '\0'; ++length);
          std::string_view result(buffer, length);
  
          return result;
      }
      #endif
  
      #if __cplusplus >= 201703L
      OrderCancelReplaceReject536 &putClOrdID(const std::string_view str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 20)
          {
              throw std::runtime_error("string too large for putClOrdID [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength);
          for (size_t start = srcLength; start < 20; ++start)
          {
              m_buffer[m_offset + 328 + start] = 0;
          }
  
          return *this;
      }
      #else
      OrderCancelReplaceReject536 &putClOrdID(const std::string& str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 20)
          {
              throw std::runtime_error("string too large for putClOrdID [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength);
          for (size_t start = srcLength; start < 20; ++start)
          {
              m_buffer[m_offset + 328 + start] = 0;
          }
  
          return *this;
      }
      #endif
  
      SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT
      {
          return 1505;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= partyDetailsListReqIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT
      {
          return 348;
      }
  
      static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT64;
      }
  
      static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT
      {
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT
      {
          return 37;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= orderIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT
      {
          return 356;
      }
  
      static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT64;
      }
  
      static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT
      {
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &orderID(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT
      {
          return 60;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= transactTimeSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT
      {
          return 364;
      }
  
      static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT64;
      }
  
      static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT
      {
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 364, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &transactTime(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 364, &val, sizeof(std::uint64_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT
      {
          return 5297;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= sendingTimeEpochSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT
      {
          return 372;
      }
  
      static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT64;
      }
  
      static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT
      {
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 372, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 372, &val, sizeof(std::uint64_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT
      {
          return 2422;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= orderRequestIDSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT
      {
          return 380;
      }
  
      static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT64;
      }
  
      static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT
      {
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "String";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT
      {
          return 9537;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= locationSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT
      {
          return 388;
      }
  
      static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
      {
          return 5;
      }
  
      static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT
      {
          return 5;
      }
  
      SBE_NODISCARD const char *location() const SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 388;
      }
  
      SBE_NODISCARD char *location() SBE_NOEXCEPT
      {
          return m_buffer + m_offset + 388;
      }
  
      SBE_NODISCARD char location(const std::uint64_t index) const
      {
          if (index >= 5)
          {
              throw std::runtime_error("index out of range for location [E104]");
          }
  
          char val;
          std::memcpy(&val, m_buffer + m_offset + 388 + (index * 1), sizeof(char));
          return (val);
      }
  
      OrderCancelReplaceReject536 &location(const std::uint64_t index, const char value)
      {
          if (index >= 5)
          {
              throw std::runtime_error("index out of range for location [E105]");
          }
  
          char val = (value);
          std::memcpy(m_buffer + m_offset + 388 + (index * 1), &val, sizeof(char));
          return *this;
      }
  
      std::uint64_t getLocation(char *const dst, const std::uint64_t length) const
      {
          if (length > 5)
          {
              throw std::runtime_error("length too large for getLocation [E106]");
          }
  
          std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast<size_t>(length));
          return length;
      }
  
      OrderCancelReplaceReject536 &putLocation(const char *const src) SBE_NOEXCEPT
      {
          std::memcpy(m_buffer + m_offset + 388, src, sizeof(char) * 5);
          return *this;
      }
  
      SBE_NODISCARD std::string getLocationAsString() const
      {
          const char *buffer = m_buffer + m_offset + 388;
          size_t length = 0;
  
          for (; length < 5 && *(buffer + length) != '\0'; ++length);
          std::string result(buffer, length);
  
          return result;
      }
  
      std::string getLocationAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getLocationAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      #if __cplusplus >= 201703L
      SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
      {
          const char *buffer = m_buffer + m_offset + 388;
          size_t length = 0;
  
          for (; length < 5 && *(buffer + length) != '\0'; ++length);
          std::string_view result(buffer, length);
  
          return result;
      }
      #endif
  
      #if __cplusplus >= 201703L
      OrderCancelReplaceReject536 &putLocation(const std::string_view str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 5)
          {
              throw std::runtime_error("string too large for putLocation [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength);
          for (size_t start = srcLength; start < 5; ++start)
          {
              m_buffer[m_offset + 388 + start] = 0;
          }
  
          return *this;
      }
      #else
      OrderCancelReplaceReject536 &putLocation(const std::string& str)
      {
          const size_t srcLength = str.length();
          if (srcLength > 5)
          {
              throw std::runtime_error("string too large for putLocation [E106]");
          }
  
          std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength);
          for (size_t start = srcLength; start < 5; ++start)
          {
              m_buffer[m_offset + 388 + start] = 0;
          }
  
          return *this;
      }
      #endif
  
      SBE_NODISCARD static const char * CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t cxlRejReasonId() SBE_NOEXCEPT
      {
          return 102;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlRejReasonSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool cxlRejReasonInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= cxlRejReasonSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingOffset() SBE_NOEXCEPT
      {
          return 393;
      }
  
      static SBE_CONSTEXPR std::uint16_t cxlRejReasonNullValue() SBE_NOEXCEPT
      {
          return SBE_NULLVALUE_UINT16;
      }
  
      static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT
      {
          return (std::uint16_t)0;
      }
  
      static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT
      {
          return (std::uint16_t)65534;
      }
  
      static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT
      {
          return 2;
      }
  
      SBE_NODISCARD std::uint16_t cxlRejReason() const SBE_NOEXCEPT
      {
          std::uint16_t val;
          std::memcpy(&val, m_buffer + m_offset + 393, sizeof(std::uint16_t));
          return SBE_LITTLE_ENDIAN_ENCODE_16(val);
      }
  
      OrderCancelReplaceReject536 &cxlRejReason(const std::uint16_t value) SBE_NOEXCEPT
      {
          std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value);
          std::memcpy(m_buffer + m_offset + 393, &val, sizeof(std::uint16_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "optional";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT
      {
          return 5904;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= delayDurationSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT
      {
          return 395;
      }
  
      static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT
      {
          return (std::uint16_t)65535;
      }
  
      static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT
      {
          return (std::uint16_t)0;
      }
  
      static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT
      {
          return (std::uint16_t)65534;
      }
  
      static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
      {
          return 2;
      }
  
      SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT
      {
          std::uint16_t val;
          std::memcpy(&val, m_buffer + m_offset + 395, sizeof(std::uint16_t));
          return SBE_LITTLE_ENDIAN_ENCODE_16(val);
      }
  
      OrderCancelReplaceReject536 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT
      {
          std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value);
          std::memcpy(m_buffer + m_offset + 395, &val, sizeof(std::uint16_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "char";
              case MetaAttribute::PRESENCE: return "constant";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT
      {
          return 39;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= ordStatusSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT
      {
          return 397;
      }
  
      static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT
      {
          return 0;
      }
  
      static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT
      {
          return 1;
      }
  
      SBE_NODISCARD const char *ordStatus() const
      {
          static const std::uint8_t ordStatusValues[] = { 85 };
  
          return (const char *)ordStatusValues;
      }
  
      SBE_NODISCARD char ordStatus(const std::uint64_t index) const
      {
          static const std::uint8_t ordStatusValues[] = { 85 };
  
          return (char)ordStatusValues[index];
      }
  
      std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const
      {
          static std::uint8_t ordStatusValues[] = { 85 };
          std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues);
  
          std::memcpy(dst, ordStatusValues, static_cast<size_t>(bytesToCopy));
          return bytesToCopy;
      }
  
      std::string getOrdStatusAsString() const
      {
          static const std::uint8_t OrdStatusValues[] = { 85 };
  
          return std::string((const char *)OrdStatusValues, 1);
      }
  
      std::string getOrdStatusAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getOrdStatusAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      SBE_NODISCARD static const char * CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "char";
              case MetaAttribute::PRESENCE: return "constant";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t cxlRejResponseToId() SBE_NOEXCEPT
      {
          return 434;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlRejResponseToSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool cxlRejResponseToInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= cxlRejResponseToSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingOffset() SBE_NOEXCEPT
      {
          return 397;
      }
  
      static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT
      {
          return (char)0;
      }
  
      static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT
      {
          return (char)32;
      }
  
      static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT
      {
          return (char)126;
      }
  
      static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT
      {
          return 0;
      }
  
      static SBE_CONSTEXPR std::uint64_t cxlRejResponseToLength() SBE_NOEXCEPT
      {
          return 1;
      }
  
      SBE_NODISCARD const char *cxlRejResponseTo() const
      {
          static const std::uint8_t cxlRejResponseToValues[] = { 50 };
  
          return (const char *)cxlRejResponseToValues;
      }
  
      SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const
      {
          static const std::uint8_t cxlRejResponseToValues[] = { 50 };
  
          return (char)cxlRejResponseToValues[index];
      }
  
      std::uint64_t getCxlRejResponseTo(char *dst, const std::uint64_t length) const
      {
          static std::uint8_t cxlRejResponseToValues[] = { 50 };
          std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues);
  
          std::memcpy(dst, cxlRejResponseToValues, static_cast<size_t>(bytesToCopy));
          return bytesToCopy;
      }
  
      std::string getCxlRejResponseToAsString() const
      {
          static const std::uint8_t CxlRejResponseToValues[] = { 50 };
  
          return std::string((const char *)CxlRejResponseToValues, 1);
      }
  
      std::string getCxlRejResponseToAsJsonEscapedString()
      {
          std::ostringstream oss;
          std::string s = getCxlRejResponseToAsString();
  
          for (const auto c : s)
          {
              switch (c)
              {
                  case '"': oss << "\\\""; break;
                  case '\\': oss << "\\\\"; break;
                  case '\b': oss << "\\b"; break;
                  case '\f': oss << "\\f"; break;
                  case '\n': oss << "\\n"; break;
                  case '\r': oss << "\\r"; break;
                  case '\t': oss << "\\t"; break;
  
                  default:
                      if ('\x00' <= c && c <= '\x1f')
                      {
                          oss << "\\u" << std::hex << std::setw(4)
                              << std::setfill('0') << (int)(c);
                      }
                      else
                      {
                          oss << c;
                      }
              }
          }
  
          return oss.str();
      }
  
      SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT
      {
          return 1028;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= manualOrderIndicatorSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT
      {
          return 397;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT
      {
          return 1;
      }
  
      SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
      {
          std::uint8_t val;
          std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
          return ManualOrdIndReq::get((val));
      }
  
      OrderCancelReplaceReject536 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT
      {
          std::uint8_t val = (value);
          std::memcpy(m_buffer + m_offset + 397, &val, sizeof(std::uint8_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT
      {
          return 9765;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= possRetransFlagSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT
      {
          return 398;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT
      {
          return 1;
      }
  
      SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT
      {
          std::uint8_t val;
          std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
          return BooleanFlag::get((val));
      }
  
      OrderCancelReplaceReject536 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT
      {
          std::uint8_t val = (value);
          std::memcpy(m_buffer + m_offset + 398, &val, sizeof(std::uint8_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT
      {
          return 9553;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= splitMsgSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT
      {
          return 399;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT
      {
          return 1;
      }
  
      SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
      {
          std::uint8_t val;
          std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
          return SplitMsg::get((val));
      }
  
      OrderCancelReplaceReject536 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT
      {
          std::uint8_t val = (value);
          std::memcpy(m_buffer + m_offset + 399, &val, sizeof(std::uint8_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "required";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT
      {
          return 9373;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT
      {
          return 0;
      }
  
      SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= liquidityFlagSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT
      {
          return 400;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT
      {
          return 1;
      }
  
      SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
      {
          std::uint8_t val;
          std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
          return BooleanNULL::get((val));
      }
  
      OrderCancelReplaceReject536 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT
      {
          std::uint8_t val = (value);
          std::memcpy(m_buffer + m_offset + 400, &val, sizeof(std::uint8_t));
          return *this;
      }
  
      SBE_NODISCARD static const char * DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
      {
          switch (metaAttribute)
          {
              case MetaAttribute::SEMANTIC_TYPE: return "int";
              case MetaAttribute::PRESENCE: return "optional";
              default: return "";
          }
      }
  
      static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT
      {
          return 7552;
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT
      {
          return 4;
      }
  
      SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT
      {
  #if defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wtautological-compare"
  #endif
          return m_actingVersion >= delayToTimeSinceVersion();
  #if defined(__clang__)
  #pragma clang diagnostic pop
  #endif
      }
  
      SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT
      {
          return 401;
      }
  
      static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
      {
          return 0xffffffffffffffffL;
      }
  
      static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
      {
          return 0x0L;
      }
  
      static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
      {
          return 0xfffffffffffffffeL;
      }
  
      static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
      {
          return 8;
      }
  
      SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT
      {
          if (m_actingVersion < 4)
          {
              return 0xffffffffffffffffL;
          }
  
          std::uint64_t val;
          std::memcpy(&val, m_buffer + m_offset + 401, sizeof(std::uint64_t));
          return SBE_LITTLE_ENDIAN_ENCODE_64(val);
      }
  
      OrderCancelReplaceReject536 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT
      {
          std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value);
          std::memcpy(m_buffer + m_offset + 401, &val, sizeof(std::uint64_t));
          return *this;
      }
  
  template<typename CharT, typename Traits>
  friend std::basic_ostream<CharT, Traits>& operator << (
      std::basic_ostream<CharT, Traits>& builder, OrderCancelReplaceReject536 _writer)
  {
      OrderCancelReplaceReject536 writer(_writer.m_buffer, _writer.m_offset,
          _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion);
      builder << '{';
      builder << R"("Name": "OrderCancelReplaceReject536", )";
      builder << R"("sbeTemplateId": )";
      builder << writer.sbeTemplateId();
      builder << ", ";
  
      builder << R"("SeqNum": )";
      builder << +writer.seqNum();
  
      builder << ", ";
      builder << R"("UUID": )";
      builder << +writer.uUID();
  
      builder << ", ";
      builder << R"("Text": )";
      builder << '"' <<
          writer.getTextAsJsonEscapedString().c_str() << '"';
  
      builder << ", ";
      builder << R"("ExecID": )";
      builder << '"' <<
          writer.getExecIDAsJsonEscapedString().c_str() << '"';
  
      builder << ", ";
      builder << R"("SenderID": )";
      builder << '"' <<
          writer.getSenderIDAsJsonEscapedString().c_str() << '"';
  
      builder << ", ";
      builder << R"("ClOrdID": )";
      builder << '"' <<
          writer.getClOrdIDAsJsonEscapedString().c_str() << '"';
  
      builder << ", ";
      builder << R"("PartyDetailsListReqID": )";
      builder << +writer.partyDetailsListReqID();
  
      builder << ", ";
      builder << R"("OrderID": )";
      builder << +writer.orderID();
  
      builder << ", ";
      builder << R"("TransactTime": )";
      builder << +writer.transactTime();
  
      builder << ", ";
      builder << R"("SendingTimeEpoch": )";
      builder << +writer.sendingTimeEpoch();
  
      builder << ", ";
      builder << R"("OrderRequestID": )";
      builder << +writer.orderRequestID();
  
      builder << ", ";
      builder << R"("Location": )";
      builder << '"' <<
          writer.getLocationAsJsonEscapedString().c_str() << '"';
  
      builder << ", ";
      builder << R"("CxlRejReason": )";
      builder << +writer.cxlRejReason();
  
      builder << ", ";
      builder << R"("DelayDuration": )";
      builder << +writer.delayDuration();
  
      builder << ", ";
      builder << R"("ManualOrderIndicator": )";
      builder << '"' << writer.manualOrderIndicator() << '"';
  
      builder << ", ";
      builder << R"("PossRetransFlag": )";
      builder << '"' << writer.possRetransFlag() << '"';
  
      builder << ", ";
      builder << R"("SplitMsg": )";
      builder << '"' << writer.splitMsg() << '"';
  
      builder << ", ";
      builder << R"("LiquidityFlag": )";
      builder << '"' << writer.liquidityFlag() << '"';
  
      builder << ", ";
      builder << R"("DelayToTime": )";
      builder << +writer.delayToTime();
  
      builder << '}';
  
      return builder;
  }
  
  void skip()
  {
  }
  
  SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
  {
      return true;
  }
  
  SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
  {
  #if defined(__GNUG__) && !defined(__clang__)
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wtype-limits"
  #endif
      size_t length = sbeBlockLength();
  
      return length;
  #if defined(__GNUG__) && !defined(__clang__)
  #pragma GCC diagnostic pop
  #endif
  }
  };
  }
  #endif
  