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

#include "redream.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace RedreamInfo {
constexpr Value::Value(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct ValueDefaultTypeInternal {
  constexpr ValueDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ValueDefaultTypeInternal() {}
  union {
    Value _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ValueDefaultTypeInternal _Value_default_instance_;
constexpr Position::Position(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0)
  , y_(0)
  , referencecorner_(0)
  , xunits_(0)
  , yunits_(0){}
struct PositionDefaultTypeInternal {
  constexpr PositionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PositionDefaultTypeInternal() {}
  union {
    Position _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PositionDefaultTypeInternal _Position_default_instance_;
constexpr Size::Size(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : width_(0)
  , height_(0)
  , widthunits_(0)
  , heightunits_(0){}
struct SizeDefaultTypeInternal {
  constexpr SizeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SizeDefaultTypeInternal() {}
  union {
    Size _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SizeDefaultTypeInternal _Size_default_instance_;
constexpr SpriteFrame::SpriteFrame(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : spritesheet_(0)
  , spritefile_(0){}
struct SpriteFrameDefaultTypeInternal {
  constexpr SpriteFrameDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SpriteFrameDefaultTypeInternal() {}
  union {
    SpriteFrame _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SpriteFrameDefaultTypeInternal _SpriteFrame_default_instance_;
constexpr FrameSet::FrameSet(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : frames_(){}
struct FrameSetDefaultTypeInternal {
  constexpr FrameSetDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FrameSetDefaultTypeInternal() {}
  union {
    FrameSet _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FrameSetDefaultTypeInternal _FrameSet_default_instance_;
constexpr Color3::Color3(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : r_(0)
  , g_(0)
  , b_(0){}
struct Color3DefaultTypeInternal {
  constexpr Color3DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Color3DefaultTypeInternal() {}
  union {
    Color3 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Color3DefaultTypeInternal _Color3_default_instance_;
constexpr Color4::Color4(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : r_(0)
  , g_(0)
  , b_(0)
  , a_(0){}
struct Color4DefaultTypeInternal {
  constexpr Color4DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Color4DefaultTypeInternal() {}
  union {
    Color4 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Color4DefaultTypeInternal _Color4_default_instance_;
constexpr Color4FVar::Color4FVar(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : red_(0)
  , green_(0)
  , blue_(0)
  , alpha_(0)
  , redvar_(0)
  , greenvar_(0)
  , bluevar_(0)
  , alphavar_(0){}
struct Color4FVarDefaultTypeInternal {
  constexpr Color4FVarDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Color4FVarDefaultTypeInternal() {}
  union {
    Color4FVar _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Color4FVarDefaultTypeInternal _Color4FVar_default_instance_;
constexpr Flip::Flip(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : flipx_(false)
  , flipy_(false){}
struct FlipDefaultTypeInternal {
  constexpr FlipDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FlipDefaultTypeInternal() {}
  union {
    Flip _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FlipDefaultTypeInternal _Flip_default_instance_;
constexpr Blendmode::Blendmode(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : source_(0)
  , destination_(0){}
struct BlendmodeDefaultTypeInternal {
  constexpr BlendmodeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BlendmodeDefaultTypeInternal() {}
  union {
    Blendmode _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlendmodeDefaultTypeInternal _Blendmode_default_instance_;
constexpr Block::Block(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : selectorname_(0)
  , selectortarget_(0){}
struct BlockDefaultTypeInternal {
  constexpr BlockDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BlockDefaultTypeInternal() {}
  union {
    Block _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlockDefaultTypeInternal _Block_default_instance_;
constexpr BlockControl::BlockControl(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : selectorname_(0)
  , selectortarget_(0)
  , controlevents_(0){}
struct BlockControlDefaultTypeInternal {
  constexpr BlockControlDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BlockControlDefaultTypeInternal() {}
  union {
    BlockControl _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlockControlDefaultTypeInternal _BlockControl_default_instance_;
constexpr Vec2::Vec2(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0)
  , y_(0){}
struct Vec2DefaultTypeInternal {
  constexpr Vec2DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Vec2DefaultTypeInternal() {}
  union {
    Vec2 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Vec2DefaultTypeInternal _Vec2_default_instance_;
constexpr Vec3::Vec3(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0)
  , y_(0)
  , z_(0){}
struct Vec3DefaultTypeInternal {
  constexpr Vec3DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Vec3DefaultTypeInternal() {}
  union {
    Vec3 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Vec3DefaultTypeInternal _Vec3_default_instance_;
constexpr SkelFrame::SkelFrame(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : animation_(0)
  , progress_(0)
  , loop_(false){}
struct SkelFrameDefaultTypeInternal {
  constexpr SkelFrameDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SkelFrameDefaultTypeInternal() {}
  union {
    SkelFrame _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SkelFrameDefaultTypeInternal _SkelFrame_default_instance_;
constexpr MinMaxCurveData::MinMaxCurveData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : maxcurve_(nullptr)
  , mincurve_(nullptr)
  , scalar_(0)
  , minmaxstate_(0){}
struct MinMaxCurveDataDefaultTypeInternal {
  constexpr MinMaxCurveDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MinMaxCurveDataDefaultTypeInternal() {}
  union {
    MinMaxCurveData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MinMaxCurveDataDefaultTypeInternal _MinMaxCurveData_default_instance_;
constexpr AnimationCurveData::AnimationCurveData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : curve_()
  , preinfinity_(0)
  , postinfinity_(0){}
struct AnimationCurveDataDefaultTypeInternal {
  constexpr AnimationCurveDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AnimationCurveDataDefaultTypeInternal() {}
  union {
    AnimationCurveData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AnimationCurveDataDefaultTypeInternal _AnimationCurveData_default_instance_;
constexpr KeyframeData::KeyframeData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : time_(0)
  , value_(0)
  , inslope_(0)
  , outslope_(0){}
struct KeyframeDataDefaultTypeInternal {
  constexpr KeyframeDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~KeyframeDataDefaultTypeInternal() {}
  union {
    KeyframeData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT KeyframeDataDefaultTypeInternal _KeyframeData_default_instance_;
constexpr MinMaxGradientData::MinMaxGradientData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : maxgradient_(nullptr)
  , mingradient_(nullptr)
  , mincolor_(nullptr)
  , maxcolor_(nullptr)
  , minmaxstate_(0){}
struct MinMaxGradientDataDefaultTypeInternal {
  constexpr MinMaxGradientDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MinMaxGradientDataDefaultTypeInternal() {}
  union {
    MinMaxGradientData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MinMaxGradientDataDefaultTypeInternal _MinMaxGradientData_default_instance_;
constexpr GradientNEWData::GradientNEWData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : color_()
  , alpha_(){}
struct GradientNEWDataDefaultTypeInternal {
  constexpr GradientNEWDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~GradientNEWDataDefaultTypeInternal() {}
  union {
    GradientNEWData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GradientNEWDataDefaultTypeInternal _GradientNEWData_default_instance_;
constexpr Color3BData::Color3BData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : color_(nullptr)
  , time_(0u){}
struct Color3BDataDefaultTypeInternal {
  constexpr Color3BDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Color3BDataDefaultTypeInternal() {}
  union {
    Color3BData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Color3BDataDefaultTypeInternal _Color3BData_default_instance_;
constexpr AlphaData::AlphaData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : time_(0u)
  , alpha_(0u){}
struct AlphaDataDefaultTypeInternal {
  constexpr AlphaDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AlphaDataDefaultTypeInternal() {}
  union {
    AlphaData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AlphaDataDefaultTypeInternal _AlphaData_default_instance_;
constexpr EmissionData::EmissionData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : burstdata_(){}
struct EmissionDataDefaultTypeInternal {
  constexpr EmissionDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~EmissionDataDefaultTypeInternal() {}
  union {
    EmissionData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EmissionDataDefaultTypeInternal _EmissionData_default_instance_;
constexpr BurstData::BurstData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : bursttime_(0)
  , burstparticlecount_(0u){}
struct BurstDataDefaultTypeInternal {
  constexpr BurstDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BurstDataDefaultTypeInternal() {}
  union {
    BurstData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BurstDataDefaultTypeInternal _BurstData_default_instance_;
constexpr Percent::Percent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : value_(0){}
struct PercentDefaultTypeInternal {
  constexpr PercentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PercentDefaultTypeInternal() {}
  union {
    Percent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PercentDefaultTypeInternal _Percent_default_instance_;
constexpr Callbacks::Callbacks(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : selectorname_(0)
  , selectortarget_(0){}
struct CallbacksDefaultTypeInternal {
  constexpr CallbacksDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CallbacksDefaultTypeInternal() {}
  union {
    Callbacks _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CallbacksDefaultTypeInternal _Callbacks_default_instance_;
constexpr SequencePropertyMap::SequencePropertyMap(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : props_()
  , seqid_(0){}
struct SequencePropertyMapDefaultTypeInternal {
  constexpr SequencePropertyMapDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SequencePropertyMapDefaultTypeInternal() {}
  union {
    SequencePropertyMap _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SequencePropertyMapDefaultTypeInternal _SequencePropertyMap_default_instance_;
constexpr SequenceProperty::SequenceProperty(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : keyframes_()
  , type_(0)
  , name_(0){}
struct SequencePropertyDefaultTypeInternal {
  constexpr SequencePropertyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SequencePropertyDefaultTypeInternal() {}
  union {
    SequenceProperty _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SequencePropertyDefaultTypeInternal _SequenceProperty_default_instance_;
constexpr Keyframe::Keyframe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : equalpoints_()
  , easing_(nullptr)
  , value_(nullptr)
  , time_(0){}
struct KeyframeDefaultTypeInternal {
  constexpr KeyframeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~KeyframeDefaultTypeInternal() {}
  union {
    Keyframe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT KeyframeDefaultTypeInternal _Keyframe_default_instance_;
constexpr Easing::Easing(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : opt_(nullptr)
  , type_(0){}
struct EasingDefaultTypeInternal {
  constexpr EasingDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~EasingDefaultTypeInternal() {}
  union {
    Easing _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EasingDefaultTypeInternal _Easing_default_instance_;
constexpr EasingOpt::EasingOpt(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct EasingOptDefaultTypeInternal {
  constexpr EasingOptDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~EasingOptDefaultTypeInternal() {}
  union {
    EasingOpt _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EasingOptDefaultTypeInternal _EasingOpt_default_instance_;
constexpr Easing1fOpt::Easing1fOpt(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0){}
struct Easing1fOptDefaultTypeInternal {
  constexpr Easing1fOptDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Easing1fOptDefaultTypeInternal() {}
  union {
    Easing1fOpt _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Easing1fOptDefaultTypeInternal _Easing1fOpt_default_instance_;
constexpr Easing4fOpt::Easing4fOpt(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0)
  , y_(0)
  , z_(0)
  , w_(0){}
struct Easing4fOptDefaultTypeInternal {
  constexpr Easing4fOptDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Easing4fOptDefaultTypeInternal() {}
  union {
    Easing4fOpt _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Easing4fOptDefaultTypeInternal _Easing4fOpt_default_instance_;
constexpr Property::Property(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : value_(nullptr)
  , name_(0)
  , type_(0){}
struct PropertyDefaultTypeInternal {
  constexpr PropertyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PropertyDefaultTypeInternal() {}
  union {
    Property _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PropertyDefaultTypeInternal _Property_default_instance_;
constexpr CallbackKeyframe::CallbackKeyframe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : time_(0)
  , name_(0)
  , type_(0){}
struct CallbackKeyframeDefaultTypeInternal {
  constexpr CallbackKeyframeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CallbackKeyframeDefaultTypeInternal() {}
  union {
    CallbackKeyframe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CallbackKeyframeDefaultTypeInternal _CallbackKeyframe_default_instance_;
constexpr SoundKeyframe::SoundKeyframe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : time_(0)
  , soundfile_(0)
  , pitch_(0)
  , pan_(0)
  , gain_(0){}
struct SoundKeyframeDefaultTypeInternal {
  constexpr SoundKeyframeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SoundKeyframeDefaultTypeInternal() {}
  union {
    SoundKeyframe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SoundKeyframeDefaultTypeInternal _SoundKeyframe_default_instance_;
constexpr WiseKeyframeParam::WiseKeyframeParam(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , value_(0){}
struct WiseKeyframeParamDefaultTypeInternal {
  constexpr WiseKeyframeParamDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~WiseKeyframeParamDefaultTypeInternal() {}
  union {
    WiseKeyframeParam _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WiseKeyframeParamDefaultTypeInternal _WiseKeyframeParam_default_instance_;
constexpr WiseKeyframe::WiseKeyframe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : params_()
  , bnk_file_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , event_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , time_(0)
  , force_post_event_(false){}
struct WiseKeyframeDefaultTypeInternal {
  constexpr WiseKeyframeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~WiseKeyframeDefaultTypeInternal() {}
  union {
    WiseKeyframe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WiseKeyframeDefaultTypeInternal _WiseKeyframe_default_instance_;
constexpr Sequences::Sequences(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : callbackkeyframe_()
  , soundkeyframe_()
  , wisekeyframe_()
  , duration_(0)
  , name_(0)
  , sequenceid_(0)
  , chainedsequenceid_(0){}
struct SequencesDefaultTypeInternal {
  constexpr SequencesDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SequencesDefaultTypeInternal() {}
  union {
    Sequences _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SequencesDefaultTypeInternal _Sequences_default_instance_;
constexpr LocalizationModel::LocalizationModel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : customfilepath_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , islocalization_(false)
  , iscustom_(false){}
struct LocalizationModelDefaultTypeInternal {
  constexpr LocalizationModelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LocalizationModelDefaultTypeInternal() {}
  union {
    LocalizationModel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LocalizationModelDefaultTypeInternal _LocalizationModel_default_instance_;
constexpr MaterialBall_ParamsEntry_DoNotUse::MaterialBall_ParamsEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct MaterialBall_ParamsEntry_DoNotUseDefaultTypeInternal {
  constexpr MaterialBall_ParamsEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MaterialBall_ParamsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    MaterialBall_ParamsEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaterialBall_ParamsEntry_DoNotUseDefaultTypeInternal _MaterialBall_ParamsEntry_DoNotUse_default_instance_;
constexpr MaterialBall::MaterialBall(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : params_()
  , materialballpath_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct MaterialBallDefaultTypeInternal {
  constexpr MaterialBallDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MaterialBallDefaultTypeInternal() {}
  union {
    MaterialBall _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaterialBallDefaultTypeInternal _MaterialBall_default_instance_;
constexpr BakeAnimation::BakeAnimation(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : animationname_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , elapsedtime_(0)
  , loop_(false){}
struct BakeAnimationDefaultTypeInternal {
  constexpr BakeAnimationDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BakeAnimationDefaultTypeInternal() {}
  union {
    BakeAnimation _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BakeAnimationDefaultTypeInternal _BakeAnimation_default_instance_;
constexpr WiseParam::WiseParam(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , value_(0){}
struct WiseParamDefaultTypeInternal {
  constexpr WiseParamDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~WiseParamDefaultTypeInternal() {}
  union {
    WiseParam _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WiseParamDefaultTypeInternal _WiseParam_default_instance_;
constexpr Wise::Wise(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : params_()
  , bnkfile_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , eventname_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , forcepost_(false){}
struct WiseDefaultTypeInternal {
  constexpr WiseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~WiseDefaultTypeInternal() {}
  union {
    Wise _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WiseDefaultTypeInternal _Wise_default_instance_;
constexpr Node::Node(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sequences_()
  , property_()
  , customproperty_()
  , child_()
  , classname_(0)
  , membervarassignmenttype_(0)
  , membervarassignmentname_(0)
  , reboltid_(0)
  , reboltname_(0)
  , baseclassname_(0){}
struct NodeDefaultTypeInternal {
  constexpr NodeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NodeDefaultTypeInternal() {}
  union {
    Node _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NodeDefaultTypeInternal _Node_default_instance_;
constexpr Rebolt_ReboltTree::Rebolt_ReboltTree(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : treename_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , treetype_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct Rebolt_ReboltTreeDefaultTypeInternal {
  constexpr Rebolt_ReboltTreeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Rebolt_ReboltTreeDefaultTypeInternal() {}
  union {
    Rebolt_ReboltTree _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Rebolt_ReboltTreeDefaultTypeInternal _Rebolt_ReboltTree_default_instance_;
constexpr Rebolt_FuncParamInfo::Rebolt_FuncParamInfo(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : boolkeys_()
  , stringkeys_(){}
struct Rebolt_FuncParamInfoDefaultTypeInternal {
  constexpr Rebolt_FuncParamInfoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Rebolt_FuncParamInfoDefaultTypeInternal() {}
  union {
    Rebolt_FuncParamInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Rebolt_FuncParamInfoDefaultTypeInternal _Rebolt_FuncParamInfo_default_instance_;
constexpr Rebolt_ReboltTreesEntry_DoNotUse::Rebolt_ReboltTreesEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Rebolt_ReboltTreesEntry_DoNotUseDefaultTypeInternal {
  constexpr Rebolt_ReboltTreesEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Rebolt_ReboltTreesEntry_DoNotUseDefaultTypeInternal() {}
  union {
    Rebolt_ReboltTreesEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Rebolt_ReboltTreesEntry_DoNotUseDefaultTypeInternal _Rebolt_ReboltTreesEntry_DoNotUse_default_instance_;
constexpr Rebolt_FuncParamIndexsEntry_DoNotUse::Rebolt_FuncParamIndexsEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Rebolt_FuncParamIndexsEntry_DoNotUseDefaultTypeInternal {
  constexpr Rebolt_FuncParamIndexsEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Rebolt_FuncParamIndexsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    Rebolt_FuncParamIndexsEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Rebolt_FuncParamIndexsEntry_DoNotUseDefaultTypeInternal _Rebolt_FuncParamIndexsEntry_DoNotUse_default_instance_;
constexpr Rebolt_GlobalMsgEntry_DoNotUse::Rebolt_GlobalMsgEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Rebolt_GlobalMsgEntry_DoNotUseDefaultTypeInternal {
  constexpr Rebolt_GlobalMsgEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Rebolt_GlobalMsgEntry_DoNotUseDefaultTypeInternal() {}
  union {
    Rebolt_GlobalMsgEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Rebolt_GlobalMsgEntry_DoNotUseDefaultTypeInternal _Rebolt_GlobalMsgEntry_DoNotUse_default_instance_;
constexpr Rebolt::Rebolt(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rebolttrees_()
  , funcparamindexs_()
  , globalmsg_()
  , isrebolted_(false){}
struct ReboltDefaultTypeInternal {
  constexpr ReboltDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReboltDefaultTypeInternal() {}
  union {
    Rebolt _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReboltDefaultTypeInternal _Rebolt_default_instance_;
constexpr BatchRed_TextureList::BatchRed_TextureList(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : texturename_(){}
struct BatchRed_TextureListDefaultTypeInternal {
  constexpr BatchRed_TextureListDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BatchRed_TextureListDefaultTypeInternal() {}
  union {
    BatchRed_TextureList _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BatchRed_TextureListDefaultTypeInternal _BatchRed_TextureList_default_instance_;
constexpr BatchRed_FramesEntry_DoNotUse::BatchRed_FramesEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct BatchRed_FramesEntry_DoNotUseDefaultTypeInternal {
  constexpr BatchRed_FramesEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BatchRed_FramesEntry_DoNotUseDefaultTypeInternal() {}
  union {
    BatchRed_FramesEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BatchRed_FramesEntry_DoNotUseDefaultTypeInternal _BatchRed_FramesEntry_DoNotUse_default_instance_;
constexpr BatchRed::BatchRed(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : frames_()
  , textures_(nullptr){}
struct BatchRedDefaultTypeInternal {
  constexpr BatchRedDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BatchRedDefaultTypeInternal() {}
  union {
    BatchRed _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BatchRedDefaultTypeInternal _BatchRed_default_instance_;
constexpr RedFile::RedFile(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : stringcache_()
  , sequences_()
  , root_(nullptr)
  , rebolt_(nullptr)
  , batchred_(nullptr)
  , version_(0)
  , autoplaysequenceid_(0){}
struct RedFileDefaultTypeInternal {
  constexpr RedFileDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RedFileDefaultTypeInternal() {}
  union {
    RedFile _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RedFileDefaultTypeInternal _RedFile_default_instance_;
}  // namespace RedreamInfo
namespace RedreamInfo {

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

class Value::_Internal {
 public:
  static const ::RedreamInfo::Position& position(const Value* msg);
  static const ::RedreamInfo::Size& size(const Value* msg);
  static const ::RedreamInfo::SpriteFrame& spriteframe(const Value* msg);
  static const ::RedreamInfo::Color3& color3(const Value* msg);
  static const ::RedreamInfo::Color4FVar& color4fvar(const Value* msg);
  static const ::RedreamInfo::Flip& flip(const Value* msg);
  static const ::RedreamInfo::Blendmode& mode(const Value* msg);
  static const ::RedreamInfo::Block& block(const Value* msg);
  static const ::RedreamInfo::BlockControl& block_control(const Value* msg);
  static const ::RedreamInfo::Vec2& vec2(const Value* msg);
  static const ::RedreamInfo::SkelFrame& skelframe(const Value* msg);
  static const ::RedreamInfo::Vec3& vec3(const Value* msg);
  static const ::RedreamInfo::Color4& color4(const Value* msg);
  static const ::RedreamInfo::MinMaxGradientData& minmaxgradientdata(const Value* msg);
  static const ::RedreamInfo::MinMaxCurveData& minmaxcurvedata(const Value* msg);
  static const ::RedreamInfo::EmissionData& emissiondata(const Value* msg);
  static const ::RedreamInfo::FrameSet& frameset(const Value* msg);
  static const ::RedreamInfo::Percent& percent(const Value* msg);
  static const ::RedreamInfo::Callbacks& callbacks(const Value* msg);
  static const ::RedreamInfo::LocalizationModel& localization(const Value* msg);
  static const ::RedreamInfo::MaterialBall& materialball(const Value* msg);
  static const ::RedreamInfo::BakeAnimation& bakeanimation(const Value* msg);
  static const ::RedreamInfo::Wise& wise(const Value* msg);
};

const ::RedreamInfo::Position&
Value::_Internal::position(const Value* msg) {
  return *msg->attri_.position_;
}
const ::RedreamInfo::Size&
Value::_Internal::size(const Value* msg) {
  return *msg->attri_.size_;
}
const ::RedreamInfo::SpriteFrame&
Value::_Internal::spriteframe(const Value* msg) {
  return *msg->attri_.spriteframe_;
}
const ::RedreamInfo::Color3&
Value::_Internal::color3(const Value* msg) {
  return *msg->attri_.color3_;
}
const ::RedreamInfo::Color4FVar&
Value::_Internal::color4fvar(const Value* msg) {
  return *msg->attri_.color4fvar_;
}
const ::RedreamInfo::Flip&
Value::_Internal::flip(const Value* msg) {
  return *msg->attri_.flip_;
}
const ::RedreamInfo::Blendmode&
Value::_Internal::mode(const Value* msg) {
  return *msg->attri_.mode_;
}
const ::RedreamInfo::Block&
Value::_Internal::block(const Value* msg) {
  return *msg->attri_.block_;
}
const ::RedreamInfo::BlockControl&
Value::_Internal::block_control(const Value* msg) {
  return *msg->attri_.block_control_;
}
const ::RedreamInfo::Vec2&
Value::_Internal::vec2(const Value* msg) {
  return *msg->attri_.vec2_;
}
const ::RedreamInfo::SkelFrame&
Value::_Internal::skelframe(const Value* msg) {
  return *msg->attri_.skelframe_;
}
const ::RedreamInfo::Vec3&
Value::_Internal::vec3(const Value* msg) {
  return *msg->attri_.vec3_;
}
const ::RedreamInfo::Color4&
Value::_Internal::color4(const Value* msg) {
  return *msg->attri_.color4_;
}
const ::RedreamInfo::MinMaxGradientData&
Value::_Internal::minmaxgradientdata(const Value* msg) {
  return *msg->attri_.minmaxgradientdata_;
}
const ::RedreamInfo::MinMaxCurveData&
Value::_Internal::minmaxcurvedata(const Value* msg) {
  return *msg->attri_.minmaxcurvedata_;
}
const ::RedreamInfo::EmissionData&
Value::_Internal::emissiondata(const Value* msg) {
  return *msg->attri_.emissiondata_;
}
const ::RedreamInfo::FrameSet&
Value::_Internal::frameset(const Value* msg) {
  return *msg->attri_.frameset_;
}
const ::RedreamInfo::Percent&
Value::_Internal::percent(const Value* msg) {
  return *msg->attri_.percent_;
}
const ::RedreamInfo::Callbacks&
Value::_Internal::callbacks(const Value* msg) {
  return *msg->attri_.callbacks_;
}
const ::RedreamInfo::LocalizationModel&
Value::_Internal::localization(const Value* msg) {
  return *msg->attri_.localization_;
}
const ::RedreamInfo::MaterialBall&
Value::_Internal::materialball(const Value* msg) {
  return *msg->attri_.materialball_;
}
const ::RedreamInfo::BakeAnimation&
Value::_Internal::bakeanimation(const Value* msg) {
  return *msg->attri_.bakeanimation_;
}
const ::RedreamInfo::Wise&
Value::_Internal::wise(const Value* msg) {
  return *msg->attri_.wise_;
}
void Value::set_allocated_position(::RedreamInfo::Position* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(position);
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    set_has_position();
    attri_.position_ = position;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.position)
}
void Value::set_allocated_size(::RedreamInfo::Size* size) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (size) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(size);
    if (message_arena != submessage_arena) {
      size = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, size, submessage_arena);
    }
    set_has_size();
    attri_.size_ = size;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.size)
}
void Value::set_allocated_spriteframe(::RedreamInfo::SpriteFrame* spriteframe) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (spriteframe) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(spriteframe);
    if (message_arena != submessage_arena) {
      spriteframe = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, spriteframe, submessage_arena);
    }
    set_has_spriteframe();
    attri_.spriteframe_ = spriteframe;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.spriteFrame)
}
void Value::set_allocated_color3(::RedreamInfo::Color3* color3) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (color3) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(color3);
    if (message_arena != submessage_arena) {
      color3 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, color3, submessage_arena);
    }
    set_has_color3();
    attri_.color3_ = color3;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.color3)
}
void Value::set_allocated_color4fvar(::RedreamInfo::Color4FVar* color4fvar) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (color4fvar) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(color4fvar);
    if (message_arena != submessage_arena) {
      color4fvar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, color4fvar, submessage_arena);
    }
    set_has_color4fvar();
    attri_.color4fvar_ = color4fvar;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.color4FVar)
}
void Value::set_allocated_flip(::RedreamInfo::Flip* flip) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (flip) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(flip);
    if (message_arena != submessage_arena) {
      flip = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flip, submessage_arena);
    }
    set_has_flip();
    attri_.flip_ = flip;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.flip)
}
void Value::set_allocated_mode(::RedreamInfo::Blendmode* mode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (mode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(mode);
    if (message_arena != submessage_arena) {
      mode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mode, submessage_arena);
    }
    set_has_mode();
    attri_.mode_ = mode;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.mode)
}
void Value::set_allocated_block(::RedreamInfo::Block* block) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (block) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(block);
    if (message_arena != submessage_arena) {
      block = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block, submessage_arena);
    }
    set_has_block();
    attri_.block_ = block;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.block)
}
void Value::set_allocated_block_control(::RedreamInfo::BlockControl* block_control) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (block_control) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(block_control);
    if (message_arena != submessage_arena) {
      block_control = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, block_control, submessage_arena);
    }
    set_has_block_control();
    attri_.block_control_ = block_control;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.block_control)
}
void Value::set_allocated_vec2(::RedreamInfo::Vec2* vec2) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (vec2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(vec2);
    if (message_arena != submessage_arena) {
      vec2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vec2, submessage_arena);
    }
    set_has_vec2();
    attri_.vec2_ = vec2;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.vec2)
}
void Value::set_allocated_skelframe(::RedreamInfo::SkelFrame* skelframe) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (skelframe) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(skelframe);
    if (message_arena != submessage_arena) {
      skelframe = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, skelframe, submessage_arena);
    }
    set_has_skelframe();
    attri_.skelframe_ = skelframe;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.skelFrame)
}
void Value::set_allocated_vec3(::RedreamInfo::Vec3* vec3) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (vec3) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(vec3);
    if (message_arena != submessage_arena) {
      vec3 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vec3, submessage_arena);
    }
    set_has_vec3();
    attri_.vec3_ = vec3;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.vec3)
}
void Value::set_allocated_color4(::RedreamInfo::Color4* color4) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (color4) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(color4);
    if (message_arena != submessage_arena) {
      color4 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, color4, submessage_arena);
    }
    set_has_color4();
    attri_.color4_ = color4;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.color4)
}
void Value::set_allocated_minmaxgradientdata(::RedreamInfo::MinMaxGradientData* minmaxgradientdata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (minmaxgradientdata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(minmaxgradientdata);
    if (message_arena != submessage_arena) {
      minmaxgradientdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, minmaxgradientdata, submessage_arena);
    }
    set_has_minmaxgradientdata();
    attri_.minmaxgradientdata_ = minmaxgradientdata;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.minMaxGradientData)
}
void Value::set_allocated_minmaxcurvedata(::RedreamInfo::MinMaxCurveData* minmaxcurvedata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (minmaxcurvedata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(minmaxcurvedata);
    if (message_arena != submessage_arena) {
      minmaxcurvedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, minmaxcurvedata, submessage_arena);
    }
    set_has_minmaxcurvedata();
    attri_.minmaxcurvedata_ = minmaxcurvedata;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.minMaxCurveData)
}
void Value::set_allocated_emissiondata(::RedreamInfo::EmissionData* emissiondata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (emissiondata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(emissiondata);
    if (message_arena != submessage_arena) {
      emissiondata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, emissiondata, submessage_arena);
    }
    set_has_emissiondata();
    attri_.emissiondata_ = emissiondata;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.emissionData)
}
void Value::set_allocated_frameset(::RedreamInfo::FrameSet* frameset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (frameset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(frameset);
    if (message_arena != submessage_arena) {
      frameset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, frameset, submessage_arena);
    }
    set_has_frameset();
    attri_.frameset_ = frameset;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.frameSet)
}
void Value::set_allocated_percent(::RedreamInfo::Percent* percent) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (percent) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(percent);
    if (message_arena != submessage_arena) {
      percent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, percent, submessage_arena);
    }
    set_has_percent();
    attri_.percent_ = percent;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.percent)
}
void Value::set_allocated_callbacks(::RedreamInfo::Callbacks* callbacks) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (callbacks) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(callbacks);
    if (message_arena != submessage_arena) {
      callbacks = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, callbacks, submessage_arena);
    }
    set_has_callbacks();
    attri_.callbacks_ = callbacks;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.callbacks)
}
void Value::set_allocated_localization(::RedreamInfo::LocalizationModel* localization) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (localization) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(localization);
    if (message_arena != submessage_arena) {
      localization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, localization, submessage_arena);
    }
    set_has_localization();
    attri_.localization_ = localization;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.localization)
}
void Value::set_allocated_materialball(::RedreamInfo::MaterialBall* materialball) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (materialball) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(materialball);
    if (message_arena != submessage_arena) {
      materialball = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, materialball, submessage_arena);
    }
    set_has_materialball();
    attri_.materialball_ = materialball;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.materialBall)
}
void Value::set_allocated_bakeanimation(::RedreamInfo::BakeAnimation* bakeanimation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (bakeanimation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bakeanimation);
    if (message_arena != submessage_arena) {
      bakeanimation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bakeanimation, submessage_arena);
    }
    set_has_bakeanimation();
    attri_.bakeanimation_ = bakeanimation;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.bakeAnimation)
}
void Value::set_allocated_wise(::RedreamInfo::Wise* wise) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (wise) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(wise);
    if (message_arena != submessage_arena) {
      wise = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wise, submessage_arena);
    }
    set_has_wise();
    attri_.wise_ = wise;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.Value.wise)
}
Value::Value(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Value)
}
Value::Value(const Value& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_attri();
  switch (from.attri_case()) {
    case kIntValue: {
      _internal_set_intvalue(from._internal_intvalue());
      break;
    }
    case kFloatValue: {
      _internal_set_floatvalue(from._internal_floatvalue());
      break;
    }
    case kBoolValue: {
      _internal_set_boolvalue(from._internal_boolvalue());
      break;
    }
    case kByteValue: {
      _internal_set_bytevalue(from._internal_bytevalue());
      break;
    }
    case kPosition: {
      _internal_mutable_position()->::RedreamInfo::Position::MergeFrom(from._internal_position());
      break;
    }
    case kSize: {
      _internal_mutable_size()->::RedreamInfo::Size::MergeFrom(from._internal_size());
      break;
    }
    case kSpriteFrame: {
      _internal_mutable_spriteframe()->::RedreamInfo::SpriteFrame::MergeFrom(from._internal_spriteframe());
      break;
    }
    case kColor3: {
      _internal_mutable_color3()->::RedreamInfo::Color3::MergeFrom(from._internal_color3());
      break;
    }
    case kColor4FVar: {
      _internal_mutable_color4fvar()->::RedreamInfo::Color4FVar::MergeFrom(from._internal_color4fvar());
      break;
    }
    case kFlip: {
      _internal_mutable_flip()->::RedreamInfo::Flip::MergeFrom(from._internal_flip());
      break;
    }
    case kMode: {
      _internal_mutable_mode()->::RedreamInfo::Blendmode::MergeFrom(from._internal_mode());
      break;
    }
    case kBlock: {
      _internal_mutable_block()->::RedreamInfo::Block::MergeFrom(from._internal_block());
      break;
    }
    case kBlockControl: {
      _internal_mutable_block_control()->::RedreamInfo::BlockControl::MergeFrom(from._internal_block_control());
      break;
    }
    case kVec2: {
      _internal_mutable_vec2()->::RedreamInfo::Vec2::MergeFrom(from._internal_vec2());
      break;
    }
    case kSkelFrame: {
      _internal_mutable_skelframe()->::RedreamInfo::SkelFrame::MergeFrom(from._internal_skelframe());
      break;
    }
    case kVec3: {
      _internal_mutable_vec3()->::RedreamInfo::Vec3::MergeFrom(from._internal_vec3());
      break;
    }
    case kColor4: {
      _internal_mutable_color4()->::RedreamInfo::Color4::MergeFrom(from._internal_color4());
      break;
    }
    case kMinMaxGradientData: {
      _internal_mutable_minmaxgradientdata()->::RedreamInfo::MinMaxGradientData::MergeFrom(from._internal_minmaxgradientdata());
      break;
    }
    case kMinMaxCurveData: {
      _internal_mutable_minmaxcurvedata()->::RedreamInfo::MinMaxCurveData::MergeFrom(from._internal_minmaxcurvedata());
      break;
    }
    case kEmissionData: {
      _internal_mutable_emissiondata()->::RedreamInfo::EmissionData::MergeFrom(from._internal_emissiondata());
      break;
    }
    case kFrameSet: {
      _internal_mutable_frameset()->::RedreamInfo::FrameSet::MergeFrom(from._internal_frameset());
      break;
    }
    case kPercent: {
      _internal_mutable_percent()->::RedreamInfo::Percent::MergeFrom(from._internal_percent());
      break;
    }
    case kCallbacks: {
      _internal_mutable_callbacks()->::RedreamInfo::Callbacks::MergeFrom(from._internal_callbacks());
      break;
    }
    case kLocalization: {
      _internal_mutable_localization()->::RedreamInfo::LocalizationModel::MergeFrom(from._internal_localization());
      break;
    }
    case kMaterialBall: {
      _internal_mutable_materialball()->::RedreamInfo::MaterialBall::MergeFrom(from._internal_materialball());
      break;
    }
    case kBakeAnimation: {
      _internal_mutable_bakeanimation()->::RedreamInfo::BakeAnimation::MergeFrom(from._internal_bakeanimation());
      break;
    }
    case kWise: {
      _internal_mutable_wise()->::RedreamInfo::Wise::MergeFrom(from._internal_wise());
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Value)
}

void Value::SharedCtor() {
clear_has_attri();
}

Value::~Value() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Value)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Value::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (has_attri()) {
    clear_attri();
  }
}

void Value::ArenaDtor(void* object) {
  Value* _this = reinterpret_cast< Value* >(object);
  (void)_this;
}
void Value::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Value::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Value::clear_attri() {
// @@protoc_insertion_point(one_of_clear_start:RedreamInfo.Value)
  switch (attri_case()) {
    case kIntValue: {
      // No need to clear
      break;
    }
    case kFloatValue: {
      // No need to clear
      break;
    }
    case kBoolValue: {
      // No need to clear
      break;
    }
    case kByteValue: {
      attri_.bytevalue_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
      break;
    }
    case kPosition: {
      if (GetArena() == nullptr) {
        delete attri_.position_;
      }
      break;
    }
    case kSize: {
      if (GetArena() == nullptr) {
        delete attri_.size_;
      }
      break;
    }
    case kSpriteFrame: {
      if (GetArena() == nullptr) {
        delete attri_.spriteframe_;
      }
      break;
    }
    case kColor3: {
      if (GetArena() == nullptr) {
        delete attri_.color3_;
      }
      break;
    }
    case kColor4FVar: {
      if (GetArena() == nullptr) {
        delete attri_.color4fvar_;
      }
      break;
    }
    case kFlip: {
      if (GetArena() == nullptr) {
        delete attri_.flip_;
      }
      break;
    }
    case kMode: {
      if (GetArena() == nullptr) {
        delete attri_.mode_;
      }
      break;
    }
    case kBlock: {
      if (GetArena() == nullptr) {
        delete attri_.block_;
      }
      break;
    }
    case kBlockControl: {
      if (GetArena() == nullptr) {
        delete attri_.block_control_;
      }
      break;
    }
    case kVec2: {
      if (GetArena() == nullptr) {
        delete attri_.vec2_;
      }
      break;
    }
    case kSkelFrame: {
      if (GetArena() == nullptr) {
        delete attri_.skelframe_;
      }
      break;
    }
    case kVec3: {
      if (GetArena() == nullptr) {
        delete attri_.vec3_;
      }
      break;
    }
    case kColor4: {
      if (GetArena() == nullptr) {
        delete attri_.color4_;
      }
      break;
    }
    case kMinMaxGradientData: {
      if (GetArena() == nullptr) {
        delete attri_.minmaxgradientdata_;
      }
      break;
    }
    case kMinMaxCurveData: {
      if (GetArena() == nullptr) {
        delete attri_.minmaxcurvedata_;
      }
      break;
    }
    case kEmissionData: {
      if (GetArena() == nullptr) {
        delete attri_.emissiondata_;
      }
      break;
    }
    case kFrameSet: {
      if (GetArena() == nullptr) {
        delete attri_.frameset_;
      }
      break;
    }
    case kPercent: {
      if (GetArena() == nullptr) {
        delete attri_.percent_;
      }
      break;
    }
    case kCallbacks: {
      if (GetArena() == nullptr) {
        delete attri_.callbacks_;
      }
      break;
    }
    case kLocalization: {
      if (GetArena() == nullptr) {
        delete attri_.localization_;
      }
      break;
    }
    case kMaterialBall: {
      if (GetArena() == nullptr) {
        delete attri_.materialball_;
      }
      break;
    }
    case kBakeAnimation: {
      if (GetArena() == nullptr) {
        delete attri_.bakeanimation_;
      }
      break;
    }
    case kWise: {
      if (GetArena() == nullptr) {
        delete attri_.wise_;
      }
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ATTRI_NOT_SET;
}


void Value::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Value)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_attri();
  _internal_metadata_.Clear<std::string>();
}

const char* Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 intValue = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _internal_set_intvalue(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float floatValue = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _internal_set_floatvalue(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // bool boolValue = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _internal_set_boolvalue(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bytes byteValue = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_bytevalue();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Position position = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_position(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Size size = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_size(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.SpriteFrame spriteFrame = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_spriteframe(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Color3 color3 = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_color3(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Color4FVar color4FVar = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_color4fvar(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Flip flip = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_flip(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Blendmode mode = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_mode(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Block block = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_block(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.BlockControl block_control = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_block_control(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Vec2 vec2 = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_vec2(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.SkelFrame skelFrame = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_skelframe(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Vec3 vec3 = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_vec3(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Color4 color4 = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_color4(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.MinMaxGradientData minMaxGradientData = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_minmaxgradientdata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.MinMaxCurveData minMaxCurveData = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_minmaxcurvedata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.EmissionData emissionData = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_emissiondata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.FrameSet frameSet = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_frameset(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Percent percent = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_percent(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Callbacks callbacks = 23;
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) {
          ptr = ctx->ParseMessage(_internal_mutable_callbacks(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.LocalizationModel localization = 24;
      case 24:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) {
          ptr = ctx->ParseMessage(_internal_mutable_localization(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.MaterialBall materialBall = 25;
      case 25:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) {
          ptr = ctx->ParseMessage(_internal_mutable_materialball(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.BakeAnimation bakeAnimation = 26;
      case 26:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) {
          ptr = ctx->ParseMessage(_internal_mutable_bakeanimation(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Wise wise = 27;
      case 27:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) {
          ptr = ctx->ParseMessage(_internal_mutable_wise(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Value::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Value)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 intValue = 1;
  if (_internal_has_intvalue()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_intvalue(), target);
  }

  // float floatValue = 2;
  if (_internal_has_floatvalue()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_floatvalue(), target);
  }

  // bool boolValue = 3;
  if (_internal_has_boolvalue()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_boolvalue(), target);
  }

  // bytes byteValue = 4;
  if (_internal_has_bytevalue()) {
    target = stream->WriteBytesMaybeAliased(
        4, this->_internal_bytevalue(), target);
  }

  // .RedreamInfo.Position position = 5;
  if (_internal_has_position()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::position(this), target, stream);
  }

  // .RedreamInfo.Size size = 6;
  if (_internal_has_size()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::size(this), target, stream);
  }

  // .RedreamInfo.SpriteFrame spriteFrame = 7;
  if (_internal_has_spriteframe()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::spriteframe(this), target, stream);
  }

  // .RedreamInfo.Color3 color3 = 8;
  if (_internal_has_color3()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::color3(this), target, stream);
  }

  // .RedreamInfo.Color4FVar color4FVar = 9;
  if (_internal_has_color4fvar()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::color4fvar(this), target, stream);
  }

  // .RedreamInfo.Flip flip = 10;
  if (_internal_has_flip()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::flip(this), target, stream);
  }

  // .RedreamInfo.Blendmode mode = 11;
  if (_internal_has_mode()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::mode(this), target, stream);
  }

  // .RedreamInfo.Block block = 12;
  if (_internal_has_block()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::block(this), target, stream);
  }

  // .RedreamInfo.BlockControl block_control = 13;
  if (_internal_has_block_control()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        13, _Internal::block_control(this), target, stream);
  }

  // .RedreamInfo.Vec2 vec2 = 14;
  if (_internal_has_vec2()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        14, _Internal::vec2(this), target, stream);
  }

  // .RedreamInfo.SkelFrame skelFrame = 15;
  if (_internal_has_skelframe()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        15, _Internal::skelframe(this), target, stream);
  }

  // .RedreamInfo.Vec3 vec3 = 16;
  if (_internal_has_vec3()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        16, _Internal::vec3(this), target, stream);
  }

  // .RedreamInfo.Color4 color4 = 17;
  if (_internal_has_color4()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        17, _Internal::color4(this), target, stream);
  }

  // .RedreamInfo.MinMaxGradientData minMaxGradientData = 18;
  if (_internal_has_minmaxgradientdata()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        18, _Internal::minmaxgradientdata(this), target, stream);
  }

  // .RedreamInfo.MinMaxCurveData minMaxCurveData = 19;
  if (_internal_has_minmaxcurvedata()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        19, _Internal::minmaxcurvedata(this), target, stream);
  }

  // .RedreamInfo.EmissionData emissionData = 20;
  if (_internal_has_emissiondata()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        20, _Internal::emissiondata(this), target, stream);
  }

  // .RedreamInfo.FrameSet frameSet = 21;
  if (_internal_has_frameset()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        21, _Internal::frameset(this), target, stream);
  }

  // .RedreamInfo.Percent percent = 22;
  if (_internal_has_percent()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        22, _Internal::percent(this), target, stream);
  }

  // .RedreamInfo.Callbacks callbacks = 23;
  if (_internal_has_callbacks()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        23, _Internal::callbacks(this), target, stream);
  }

  // .RedreamInfo.LocalizationModel localization = 24;
  if (_internal_has_localization()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        24, _Internal::localization(this), target, stream);
  }

  // .RedreamInfo.MaterialBall materialBall = 25;
  if (_internal_has_materialball()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        25, _Internal::materialball(this), target, stream);
  }

  // .RedreamInfo.BakeAnimation bakeAnimation = 26;
  if (_internal_has_bakeanimation()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        26, _Internal::bakeanimation(this), target, stream);
  }

  // .RedreamInfo.Wise wise = 27;
  if (_internal_has_wise()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        27, _Internal::wise(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Value)
  return target;
}

size_t Value::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Value)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (attri_case()) {
    // int32 intValue = 1;
    case kIntValue: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_intvalue());
      break;
    }
    // float floatValue = 2;
    case kFloatValue: {
      total_size += 1 + 4;
      break;
    }
    // bool boolValue = 3;
    case kBoolValue: {
      total_size += 1 + 1;
      break;
    }
    // bytes byteValue = 4;
    case kByteValue: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_bytevalue());
      break;
    }
    // .RedreamInfo.Position position = 5;
    case kPosition: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.position_);
      break;
    }
    // .RedreamInfo.Size size = 6;
    case kSize: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.size_);
      break;
    }
    // .RedreamInfo.SpriteFrame spriteFrame = 7;
    case kSpriteFrame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.spriteframe_);
      break;
    }
    // .RedreamInfo.Color3 color3 = 8;
    case kColor3: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.color3_);
      break;
    }
    // .RedreamInfo.Color4FVar color4FVar = 9;
    case kColor4FVar: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.color4fvar_);
      break;
    }
    // .RedreamInfo.Flip flip = 10;
    case kFlip: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.flip_);
      break;
    }
    // .RedreamInfo.Blendmode mode = 11;
    case kMode: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.mode_);
      break;
    }
    // .RedreamInfo.Block block = 12;
    case kBlock: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.block_);
      break;
    }
    // .RedreamInfo.BlockControl block_control = 13;
    case kBlockControl: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.block_control_);
      break;
    }
    // .RedreamInfo.Vec2 vec2 = 14;
    case kVec2: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.vec2_);
      break;
    }
    // .RedreamInfo.SkelFrame skelFrame = 15;
    case kSkelFrame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.skelframe_);
      break;
    }
    // .RedreamInfo.Vec3 vec3 = 16;
    case kVec3: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.vec3_);
      break;
    }
    // .RedreamInfo.Color4 color4 = 17;
    case kColor4: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.color4_);
      break;
    }
    // .RedreamInfo.MinMaxGradientData minMaxGradientData = 18;
    case kMinMaxGradientData: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.minmaxgradientdata_);
      break;
    }
    // .RedreamInfo.MinMaxCurveData minMaxCurveData = 19;
    case kMinMaxCurveData: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.minmaxcurvedata_);
      break;
    }
    // .RedreamInfo.EmissionData emissionData = 20;
    case kEmissionData: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.emissiondata_);
      break;
    }
    // .RedreamInfo.FrameSet frameSet = 21;
    case kFrameSet: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.frameset_);
      break;
    }
    // .RedreamInfo.Percent percent = 22;
    case kPercent: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.percent_);
      break;
    }
    // .RedreamInfo.Callbacks callbacks = 23;
    case kCallbacks: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.callbacks_);
      break;
    }
    // .RedreamInfo.LocalizationModel localization = 24;
    case kLocalization: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.localization_);
      break;
    }
    // .RedreamInfo.MaterialBall materialBall = 25;
    case kMaterialBall: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.materialball_);
      break;
    }
    // .RedreamInfo.BakeAnimation bakeAnimation = 26;
    case kBakeAnimation: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.bakeanimation_);
      break;
    }
    // .RedreamInfo.Wise wise = 27;
    case kWise: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.wise_);
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Value::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Value*>(
      &from));
}

void Value::MergeFrom(const Value& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Value)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.attri_case()) {
    case kIntValue: {
      _internal_set_intvalue(from._internal_intvalue());
      break;
    }
    case kFloatValue: {
      _internal_set_floatvalue(from._internal_floatvalue());
      break;
    }
    case kBoolValue: {
      _internal_set_boolvalue(from._internal_boolvalue());
      break;
    }
    case kByteValue: {
      _internal_set_bytevalue(from._internal_bytevalue());
      break;
    }
    case kPosition: {
      _internal_mutable_position()->::RedreamInfo::Position::MergeFrom(from._internal_position());
      break;
    }
    case kSize: {
      _internal_mutable_size()->::RedreamInfo::Size::MergeFrom(from._internal_size());
      break;
    }
    case kSpriteFrame: {
      _internal_mutable_spriteframe()->::RedreamInfo::SpriteFrame::MergeFrom(from._internal_spriteframe());
      break;
    }
    case kColor3: {
      _internal_mutable_color3()->::RedreamInfo::Color3::MergeFrom(from._internal_color3());
      break;
    }
    case kColor4FVar: {
      _internal_mutable_color4fvar()->::RedreamInfo::Color4FVar::MergeFrom(from._internal_color4fvar());
      break;
    }
    case kFlip: {
      _internal_mutable_flip()->::RedreamInfo::Flip::MergeFrom(from._internal_flip());
      break;
    }
    case kMode: {
      _internal_mutable_mode()->::RedreamInfo::Blendmode::MergeFrom(from._internal_mode());
      break;
    }
    case kBlock: {
      _internal_mutable_block()->::RedreamInfo::Block::MergeFrom(from._internal_block());
      break;
    }
    case kBlockControl: {
      _internal_mutable_block_control()->::RedreamInfo::BlockControl::MergeFrom(from._internal_block_control());
      break;
    }
    case kVec2: {
      _internal_mutable_vec2()->::RedreamInfo::Vec2::MergeFrom(from._internal_vec2());
      break;
    }
    case kSkelFrame: {
      _internal_mutable_skelframe()->::RedreamInfo::SkelFrame::MergeFrom(from._internal_skelframe());
      break;
    }
    case kVec3: {
      _internal_mutable_vec3()->::RedreamInfo::Vec3::MergeFrom(from._internal_vec3());
      break;
    }
    case kColor4: {
      _internal_mutable_color4()->::RedreamInfo::Color4::MergeFrom(from._internal_color4());
      break;
    }
    case kMinMaxGradientData: {
      _internal_mutable_minmaxgradientdata()->::RedreamInfo::MinMaxGradientData::MergeFrom(from._internal_minmaxgradientdata());
      break;
    }
    case kMinMaxCurveData: {
      _internal_mutable_minmaxcurvedata()->::RedreamInfo::MinMaxCurveData::MergeFrom(from._internal_minmaxcurvedata());
      break;
    }
    case kEmissionData: {
      _internal_mutable_emissiondata()->::RedreamInfo::EmissionData::MergeFrom(from._internal_emissiondata());
      break;
    }
    case kFrameSet: {
      _internal_mutable_frameset()->::RedreamInfo::FrameSet::MergeFrom(from._internal_frameset());
      break;
    }
    case kPercent: {
      _internal_mutable_percent()->::RedreamInfo::Percent::MergeFrom(from._internal_percent());
      break;
    }
    case kCallbacks: {
      _internal_mutable_callbacks()->::RedreamInfo::Callbacks::MergeFrom(from._internal_callbacks());
      break;
    }
    case kLocalization: {
      _internal_mutable_localization()->::RedreamInfo::LocalizationModel::MergeFrom(from._internal_localization());
      break;
    }
    case kMaterialBall: {
      _internal_mutable_materialball()->::RedreamInfo::MaterialBall::MergeFrom(from._internal_materialball());
      break;
    }
    case kBakeAnimation: {
      _internal_mutable_bakeanimation()->::RedreamInfo::BakeAnimation::MergeFrom(from._internal_bakeanimation());
      break;
    }
    case kWise: {
      _internal_mutable_wise()->::RedreamInfo::Wise::MergeFrom(from._internal_wise());
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
}

void Value::CopyFrom(const Value& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Value)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Value::IsInitialized() const {
  return true;
}

void Value::InternalSwap(Value* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(attri_, other->attri_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

std::string Value::GetTypeName() const {
  return "RedreamInfo.Value";
}


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

class Position::_Internal {
 public:
};

Position::Position(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Position)
}
Position::Position(const Position& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&yunits_) -
    reinterpret_cast<char*>(&x_)) + sizeof(yunits_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Position)
}

void Position::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&yunits_) -
    reinterpret_cast<char*>(&x_)) + sizeof(yunits_));
}

Position::~Position() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Position)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Position::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Position::ArenaDtor(void* object) {
  Position* _this = reinterpret_cast< Position* >(object);
  (void)_this;
}
void Position::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Position::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Position::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Position)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&yunits_) -
      reinterpret_cast<char*>(&x_)) + sizeof(yunits_));
  _internal_metadata_.Clear<std::string>();
}

const char* Position::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // int32 referenceCorner = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          referencecorner_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 xUnits = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          xunits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 yUnits = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          yunits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Position::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Position)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), target);
  }

  // int32 referenceCorner = 3;
  if (this->referencecorner() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_referencecorner(), target);
  }

  // int32 xUnits = 4;
  if (this->xunits() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_xunits(), target);
  }

  // int32 yUnits = 5;
  if (this->yunits() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_yunits(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Position)
  return target;
}

size_t Position::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Position)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    total_size += 1 + 4;
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    total_size += 1 + 4;
  }

  // int32 referenceCorner = 3;
  if (this->referencecorner() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_referencecorner());
  }

  // int32 xUnits = 4;
  if (this->xunits() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_xunits());
  }

  // int32 yUnits = 5;
  if (this->yunits() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_yunits());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Position::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Position*>(
      &from));
}

void Position::MergeFrom(const Position& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Position)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.x() <= 0 && from.x() >= 0)) {
    _internal_set_x(from._internal_x());
  }
  if (!(from.y() <= 0 && from.y() >= 0)) {
    _internal_set_y(from._internal_y());
  }
  if (from.referencecorner() != 0) {
    _internal_set_referencecorner(from._internal_referencecorner());
  }
  if (from.xunits() != 0) {
    _internal_set_xunits(from._internal_xunits());
  }
  if (from.yunits() != 0) {
    _internal_set_yunits(from._internal_yunits());
  }
}

void Position::CopyFrom(const Position& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Position)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Position::IsInitialized() const {
  return true;
}

void Position::InternalSwap(Position* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Position, yunits_)
      + sizeof(Position::yunits_)
      - PROTOBUF_FIELD_OFFSET(Position, x_)>(
          reinterpret_cast<char*>(&x_),
          reinterpret_cast<char*>(&other->x_));
}

std::string Position::GetTypeName() const {
  return "RedreamInfo.Position";
}


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

class Size::_Internal {
 public:
};

Size::Size(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Size)
}
Size::Size(const Size& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&width_, &from.width_,
    static_cast<size_t>(reinterpret_cast<char*>(&heightunits_) -
    reinterpret_cast<char*>(&width_)) + sizeof(heightunits_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Size)
}

void Size::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&width_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&heightunits_) -
    reinterpret_cast<char*>(&width_)) + sizeof(heightunits_));
}

Size::~Size() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Size)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Size::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Size::ArenaDtor(void* object) {
  Size* _this = reinterpret_cast< Size* >(object);
  (void)_this;
}
void Size::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Size::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Size::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Size)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&width_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&heightunits_) -
      reinterpret_cast<char*>(&width_)) + sizeof(heightunits_));
  _internal_metadata_.Clear<std::string>();
}

const char* Size::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float width = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float height = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          height_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // int32 widthUnits = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          widthunits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 heightUnits = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          heightunits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Size::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Size)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float width = 1;
  if (!(this->width() <= 0 && this->width() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_width(), target);
  }

  // float height = 2;
  if (!(this->height() <= 0 && this->height() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_height(), target);
  }

  // int32 widthUnits = 3;
  if (this->widthunits() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_widthunits(), target);
  }

  // int32 heightUnits = 4;
  if (this->heightunits() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_heightunits(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Size)
  return target;
}

size_t Size::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Size)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float width = 1;
  if (!(this->width() <= 0 && this->width() >= 0)) {
    total_size += 1 + 4;
  }

  // float height = 2;
  if (!(this->height() <= 0 && this->height() >= 0)) {
    total_size += 1 + 4;
  }

  // int32 widthUnits = 3;
  if (this->widthunits() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_widthunits());
  }

  // int32 heightUnits = 4;
  if (this->heightunits() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_heightunits());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Size::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Size*>(
      &from));
}

void Size::MergeFrom(const Size& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Size)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.width() <= 0 && from.width() >= 0)) {
    _internal_set_width(from._internal_width());
  }
  if (!(from.height() <= 0 && from.height() >= 0)) {
    _internal_set_height(from._internal_height());
  }
  if (from.widthunits() != 0) {
    _internal_set_widthunits(from._internal_widthunits());
  }
  if (from.heightunits() != 0) {
    _internal_set_heightunits(from._internal_heightunits());
  }
}

void Size::CopyFrom(const Size& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Size)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Size::IsInitialized() const {
  return true;
}

void Size::InternalSwap(Size* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Size, heightunits_)
      + sizeof(Size::heightunits_)
      - PROTOBUF_FIELD_OFFSET(Size, width_)>(
          reinterpret_cast<char*>(&width_),
          reinterpret_cast<char*>(&other->width_));
}

std::string Size::GetTypeName() const {
  return "RedreamInfo.Size";
}


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

class SpriteFrame::_Internal {
 public:
};

SpriteFrame::SpriteFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.SpriteFrame)
}
SpriteFrame::SpriteFrame(const SpriteFrame& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&spritesheet_, &from.spritesheet_,
    static_cast<size_t>(reinterpret_cast<char*>(&spritefile_) -
    reinterpret_cast<char*>(&spritesheet_)) + sizeof(spritefile_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.SpriteFrame)
}

void SpriteFrame::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&spritesheet_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&spritefile_) -
    reinterpret_cast<char*>(&spritesheet_)) + sizeof(spritefile_));
}

SpriteFrame::~SpriteFrame() {
  // @@protoc_insertion_point(destructor:RedreamInfo.SpriteFrame)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void SpriteFrame::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void SpriteFrame::ArenaDtor(void* object) {
  SpriteFrame* _this = reinterpret_cast< SpriteFrame* >(object);
  (void)_this;
}
void SpriteFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SpriteFrame::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SpriteFrame::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.SpriteFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&spritesheet_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&spritefile_) -
      reinterpret_cast<char*>(&spritesheet_)) + sizeof(spritefile_));
  _internal_metadata_.Clear<std::string>();
}

const char* SpriteFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 spriteSheet = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          spritesheet_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 spriteFile = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          spritefile_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SpriteFrame::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.SpriteFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 spriteSheet = 1;
  if (this->spritesheet() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_spritesheet(), target);
  }

  // int32 spriteFile = 2;
  if (this->spritefile() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_spritefile(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.SpriteFrame)
  return target;
}

size_t SpriteFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.SpriteFrame)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 spriteSheet = 1;
  if (this->spritesheet() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_spritesheet());
  }

  // int32 spriteFile = 2;
  if (this->spritefile() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_spritefile());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SpriteFrame::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SpriteFrame*>(
      &from));
}

void SpriteFrame::MergeFrom(const SpriteFrame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.SpriteFrame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.spritesheet() != 0) {
    _internal_set_spritesheet(from._internal_spritesheet());
  }
  if (from.spritefile() != 0) {
    _internal_set_spritefile(from._internal_spritefile());
  }
}

void SpriteFrame::CopyFrom(const SpriteFrame& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.SpriteFrame)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SpriteFrame::IsInitialized() const {
  return true;
}

void SpriteFrame::InternalSwap(SpriteFrame* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SpriteFrame, spritefile_)
      + sizeof(SpriteFrame::spritefile_)
      - PROTOBUF_FIELD_OFFSET(SpriteFrame, spritesheet_)>(
          reinterpret_cast<char*>(&spritesheet_),
          reinterpret_cast<char*>(&other->spritesheet_));
}

std::string SpriteFrame::GetTypeName() const {
  return "RedreamInfo.SpriteFrame";
}


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

class FrameSet::_Internal {
 public:
};

FrameSet::FrameSet(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  frames_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.FrameSet)
}
FrameSet::FrameSet(const FrameSet& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      frames_(from.frames_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.FrameSet)
}

void FrameSet::SharedCtor() {
}

FrameSet::~FrameSet() {
  // @@protoc_insertion_point(destructor:RedreamInfo.FrameSet)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void FrameSet::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void FrameSet::ArenaDtor(void* object) {
  FrameSet* _this = reinterpret_cast< FrameSet* >(object);
  (void)_this;
}
void FrameSet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void FrameSet::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void FrameSet::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.FrameSet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  frames_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* FrameSet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .RedreamInfo.SpriteFrame frames = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_frames(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* FrameSet::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.FrameSet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .RedreamInfo.SpriteFrame frames = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_frames_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_frames(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.FrameSet)
  return target;
}

size_t FrameSet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.FrameSet)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.SpriteFrame frames = 1;
  total_size += 1UL * this->_internal_frames_size();
  for (const auto& msg : this->frames_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void FrameSet::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FrameSet*>(
      &from));
}

void FrameSet::MergeFrom(const FrameSet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.FrameSet)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  frames_.MergeFrom(from.frames_);
}

void FrameSet::CopyFrom(const FrameSet& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.FrameSet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FrameSet::IsInitialized() const {
  return true;
}

void FrameSet::InternalSwap(FrameSet* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  frames_.InternalSwap(&other->frames_);
}

std::string FrameSet::GetTypeName() const {
  return "RedreamInfo.FrameSet";
}


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

class Color3::_Internal {
 public:
};

Color3::Color3(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Color3)
}
Color3::Color3(const Color3& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&r_, &from.r_,
    static_cast<size_t>(reinterpret_cast<char*>(&b_) -
    reinterpret_cast<char*>(&r_)) + sizeof(b_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Color3)
}

void Color3::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&r_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&b_) -
    reinterpret_cast<char*>(&r_)) + sizeof(b_));
}

Color3::~Color3() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Color3)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Color3::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Color3::ArenaDtor(void* object) {
  Color3* _this = reinterpret_cast< Color3* >(object);
  (void)_this;
}
void Color3::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Color3::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Color3::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Color3)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&r_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&b_) -
      reinterpret_cast<char*>(&r_)) + sizeof(b_));
  _internal_metadata_.Clear<std::string>();
}

const char* Color3::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 r = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          r_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 g = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          g_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 b = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          b_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Color3::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Color3)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 r = 1;
  if (this->r() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_r(), target);
  }

  // int32 g = 2;
  if (this->g() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_g(), target);
  }

  // int32 b = 3;
  if (this->b() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_b(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Color3)
  return target;
}

size_t Color3::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Color3)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 r = 1;
  if (this->r() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_r());
  }

  // int32 g = 2;
  if (this->g() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_g());
  }

  // int32 b = 3;
  if (this->b() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_b());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Color3::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Color3*>(
      &from));
}

void Color3::MergeFrom(const Color3& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Color3)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.r() != 0) {
    _internal_set_r(from._internal_r());
  }
  if (from.g() != 0) {
    _internal_set_g(from._internal_g());
  }
  if (from.b() != 0) {
    _internal_set_b(from._internal_b());
  }
}

void Color3::CopyFrom(const Color3& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Color3)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Color3::IsInitialized() const {
  return true;
}

void Color3::InternalSwap(Color3* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Color3, b_)
      + sizeof(Color3::b_)
      - PROTOBUF_FIELD_OFFSET(Color3, r_)>(
          reinterpret_cast<char*>(&r_),
          reinterpret_cast<char*>(&other->r_));
}

std::string Color3::GetTypeName() const {
  return "RedreamInfo.Color3";
}


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

class Color4::_Internal {
 public:
};

Color4::Color4(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Color4)
}
Color4::Color4(const Color4& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&r_, &from.r_,
    static_cast<size_t>(reinterpret_cast<char*>(&a_) -
    reinterpret_cast<char*>(&r_)) + sizeof(a_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Color4)
}

void Color4::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&r_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&a_) -
    reinterpret_cast<char*>(&r_)) + sizeof(a_));
}

Color4::~Color4() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Color4)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Color4::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Color4::ArenaDtor(void* object) {
  Color4* _this = reinterpret_cast< Color4* >(object);
  (void)_this;
}
void Color4::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Color4::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Color4::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Color4)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&r_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&a_) -
      reinterpret_cast<char*>(&r_)) + sizeof(a_));
  _internal_metadata_.Clear<std::string>();
}

const char* Color4::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 r = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          r_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 g = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          g_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 b = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          b_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 a = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          a_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Color4::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Color4)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 r = 1;
  if (this->r() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_r(), target);
  }

  // int32 g = 2;
  if (this->g() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_g(), target);
  }

  // int32 b = 3;
  if (this->b() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_b(), target);
  }

  // int32 a = 4;
  if (this->a() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_a(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Color4)
  return target;
}

size_t Color4::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Color4)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 r = 1;
  if (this->r() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_r());
  }

  // int32 g = 2;
  if (this->g() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_g());
  }

  // int32 b = 3;
  if (this->b() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_b());
  }

  // int32 a = 4;
  if (this->a() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_a());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Color4::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Color4*>(
      &from));
}

void Color4::MergeFrom(const Color4& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Color4)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.r() != 0) {
    _internal_set_r(from._internal_r());
  }
  if (from.g() != 0) {
    _internal_set_g(from._internal_g());
  }
  if (from.b() != 0) {
    _internal_set_b(from._internal_b());
  }
  if (from.a() != 0) {
    _internal_set_a(from._internal_a());
  }
}

void Color4::CopyFrom(const Color4& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Color4)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Color4::IsInitialized() const {
  return true;
}

void Color4::InternalSwap(Color4* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Color4, a_)
      + sizeof(Color4::a_)
      - PROTOBUF_FIELD_OFFSET(Color4, r_)>(
          reinterpret_cast<char*>(&r_),
          reinterpret_cast<char*>(&other->r_));
}

std::string Color4::GetTypeName() const {
  return "RedreamInfo.Color4";
}


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

class Color4FVar::_Internal {
 public:
};

Color4FVar::Color4FVar(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Color4FVar)
}
Color4FVar::Color4FVar(const Color4FVar& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&red_, &from.red_,
    static_cast<size_t>(reinterpret_cast<char*>(&alphavar_) -
    reinterpret_cast<char*>(&red_)) + sizeof(alphavar_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Color4FVar)
}

void Color4FVar::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&red_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&alphavar_) -
    reinterpret_cast<char*>(&red_)) + sizeof(alphavar_));
}

Color4FVar::~Color4FVar() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Color4FVar)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Color4FVar::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Color4FVar::ArenaDtor(void* object) {
  Color4FVar* _this = reinterpret_cast< Color4FVar* >(object);
  (void)_this;
}
void Color4FVar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Color4FVar::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Color4FVar::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Color4FVar)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&red_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&alphavar_) -
      reinterpret_cast<char*>(&red_)) + sizeof(alphavar_));
  _internal_metadata_.Clear<std::string>();
}

const char* Color4FVar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float red = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          red_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float green = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          green_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float blue = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          blue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float alpha = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float redVar = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          redvar_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float greenVar = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 53)) {
          greenvar_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float blueVar = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) {
          bluevar_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float alphaVar = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 69)) {
          alphavar_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Color4FVar::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Color4FVar)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float red = 1;
  if (!(this->red() <= 0 && this->red() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_red(), target);
  }

  // float green = 2;
  if (!(this->green() <= 0 && this->green() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_green(), target);
  }

  // float blue = 3;
  if (!(this->blue() <= 0 && this->blue() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_blue(), target);
  }

  // float alpha = 4;
  if (!(this->alpha() <= 0 && this->alpha() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_alpha(), target);
  }

  // float redVar = 5;
  if (!(this->redvar() <= 0 && this->redvar() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_redvar(), target);
  }

  // float greenVar = 6;
  if (!(this->greenvar() <= 0 && this->greenvar() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_greenvar(), target);
  }

  // float blueVar = 7;
  if (!(this->bluevar() <= 0 && this->bluevar() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_bluevar(), target);
  }

  // float alphaVar = 8;
  if (!(this->alphavar() <= 0 && this->alphavar() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_alphavar(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Color4FVar)
  return target;
}

size_t Color4FVar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Color4FVar)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float red = 1;
  if (!(this->red() <= 0 && this->red() >= 0)) {
    total_size += 1 + 4;
  }

  // float green = 2;
  if (!(this->green() <= 0 && this->green() >= 0)) {
    total_size += 1 + 4;
  }

  // float blue = 3;
  if (!(this->blue() <= 0 && this->blue() >= 0)) {
    total_size += 1 + 4;
  }

  // float alpha = 4;
  if (!(this->alpha() <= 0 && this->alpha() >= 0)) {
    total_size += 1 + 4;
  }

  // float redVar = 5;
  if (!(this->redvar() <= 0 && this->redvar() >= 0)) {
    total_size += 1 + 4;
  }

  // float greenVar = 6;
  if (!(this->greenvar() <= 0 && this->greenvar() >= 0)) {
    total_size += 1 + 4;
  }

  // float blueVar = 7;
  if (!(this->bluevar() <= 0 && this->bluevar() >= 0)) {
    total_size += 1 + 4;
  }

  // float alphaVar = 8;
  if (!(this->alphavar() <= 0 && this->alphavar() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Color4FVar::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Color4FVar*>(
      &from));
}

void Color4FVar::MergeFrom(const Color4FVar& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Color4FVar)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.red() <= 0 && from.red() >= 0)) {
    _internal_set_red(from._internal_red());
  }
  if (!(from.green() <= 0 && from.green() >= 0)) {
    _internal_set_green(from._internal_green());
  }
  if (!(from.blue() <= 0 && from.blue() >= 0)) {
    _internal_set_blue(from._internal_blue());
  }
  if (!(from.alpha() <= 0 && from.alpha() >= 0)) {
    _internal_set_alpha(from._internal_alpha());
  }
  if (!(from.redvar() <= 0 && from.redvar() >= 0)) {
    _internal_set_redvar(from._internal_redvar());
  }
  if (!(from.greenvar() <= 0 && from.greenvar() >= 0)) {
    _internal_set_greenvar(from._internal_greenvar());
  }
  if (!(from.bluevar() <= 0 && from.bluevar() >= 0)) {
    _internal_set_bluevar(from._internal_bluevar());
  }
  if (!(from.alphavar() <= 0 && from.alphavar() >= 0)) {
    _internal_set_alphavar(from._internal_alphavar());
  }
}

void Color4FVar::CopyFrom(const Color4FVar& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Color4FVar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Color4FVar::IsInitialized() const {
  return true;
}

void Color4FVar::InternalSwap(Color4FVar* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Color4FVar, alphavar_)
      + sizeof(Color4FVar::alphavar_)
      - PROTOBUF_FIELD_OFFSET(Color4FVar, red_)>(
          reinterpret_cast<char*>(&red_),
          reinterpret_cast<char*>(&other->red_));
}

std::string Color4FVar::GetTypeName() const {
  return "RedreamInfo.Color4FVar";
}


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

class Flip::_Internal {
 public:
};

Flip::Flip(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Flip)
}
Flip::Flip(const Flip& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&flipx_, &from.flipx_,
    static_cast<size_t>(reinterpret_cast<char*>(&flipy_) -
    reinterpret_cast<char*>(&flipx_)) + sizeof(flipy_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Flip)
}

void Flip::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&flipx_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&flipy_) -
    reinterpret_cast<char*>(&flipx_)) + sizeof(flipy_));
}

Flip::~Flip() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Flip)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Flip::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Flip::ArenaDtor(void* object) {
  Flip* _this = reinterpret_cast< Flip* >(object);
  (void)_this;
}
void Flip::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Flip::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Flip::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Flip)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&flipx_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&flipy_) -
      reinterpret_cast<char*>(&flipx_)) + sizeof(flipy_));
  _internal_metadata_.Clear<std::string>();
}

const char* Flip::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool flipX = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          flipx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool flipY = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          flipy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Flip::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Flip)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool flipX = 1;
  if (this->flipx() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_flipx(), target);
  }

  // bool flipY = 2;
  if (this->flipy() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_flipy(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Flip)
  return target;
}

size_t Flip::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Flip)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // bool flipX = 1;
  if (this->flipx() != 0) {
    total_size += 1 + 1;
  }

  // bool flipY = 2;
  if (this->flipy() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Flip::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Flip*>(
      &from));
}

void Flip::MergeFrom(const Flip& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Flip)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.flipx() != 0) {
    _internal_set_flipx(from._internal_flipx());
  }
  if (from.flipy() != 0) {
    _internal_set_flipy(from._internal_flipy());
  }
}

void Flip::CopyFrom(const Flip& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Flip)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Flip::IsInitialized() const {
  return true;
}

void Flip::InternalSwap(Flip* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Flip, flipy_)
      + sizeof(Flip::flipy_)
      - PROTOBUF_FIELD_OFFSET(Flip, flipx_)>(
          reinterpret_cast<char*>(&flipx_),
          reinterpret_cast<char*>(&other->flipx_));
}

std::string Flip::GetTypeName() const {
  return "RedreamInfo.Flip";
}


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

class Blendmode::_Internal {
 public:
};

Blendmode::Blendmode(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Blendmode)
}
Blendmode::Blendmode(const Blendmode& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&source_, &from.source_,
    static_cast<size_t>(reinterpret_cast<char*>(&destination_) -
    reinterpret_cast<char*>(&source_)) + sizeof(destination_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Blendmode)
}

void Blendmode::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&source_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&destination_) -
    reinterpret_cast<char*>(&source_)) + sizeof(destination_));
}

Blendmode::~Blendmode() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Blendmode)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Blendmode::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Blendmode::ArenaDtor(void* object) {
  Blendmode* _this = reinterpret_cast< Blendmode* >(object);
  (void)_this;
}
void Blendmode::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Blendmode::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Blendmode::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Blendmode)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&source_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&destination_) -
      reinterpret_cast<char*>(&source_)) + sizeof(destination_));
  _internal_metadata_.Clear<std::string>();
}

const char* Blendmode::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 source = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          source_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 destination = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          destination_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Blendmode::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Blendmode)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 source = 1;
  if (this->source() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_source(), target);
  }

  // int32 destination = 2;
  if (this->destination() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_destination(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Blendmode)
  return target;
}

size_t Blendmode::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Blendmode)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 source = 1;
  if (this->source() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_source());
  }

  // int32 destination = 2;
  if (this->destination() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_destination());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Blendmode::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Blendmode*>(
      &from));
}

void Blendmode::MergeFrom(const Blendmode& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Blendmode)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.source() != 0) {
    _internal_set_source(from._internal_source());
  }
  if (from.destination() != 0) {
    _internal_set_destination(from._internal_destination());
  }
}

void Blendmode::CopyFrom(const Blendmode& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Blendmode)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Blendmode::IsInitialized() const {
  return true;
}

void Blendmode::InternalSwap(Blendmode* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Blendmode, destination_)
      + sizeof(Blendmode::destination_)
      - PROTOBUF_FIELD_OFFSET(Blendmode, source_)>(
          reinterpret_cast<char*>(&source_),
          reinterpret_cast<char*>(&other->source_));
}

std::string Blendmode::GetTypeName() const {
  return "RedreamInfo.Blendmode";
}


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

class Block::_Internal {
 public:
};

Block::Block(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Block)
}
Block::Block(const Block& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&selectorname_, &from.selectorname_,
    static_cast<size_t>(reinterpret_cast<char*>(&selectortarget_) -
    reinterpret_cast<char*>(&selectorname_)) + sizeof(selectortarget_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Block)
}

void Block::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&selectorname_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&selectortarget_) -
    reinterpret_cast<char*>(&selectorname_)) + sizeof(selectortarget_));
}

Block::~Block() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Block)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Block::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Block::ArenaDtor(void* object) {
  Block* _this = reinterpret_cast< Block* >(object);
  (void)_this;
}
void Block::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Block::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Block::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Block)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&selectorname_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&selectortarget_) -
      reinterpret_cast<char*>(&selectorname_)) + sizeof(selectortarget_));
  _internal_metadata_.Clear<std::string>();
}

const char* Block::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 selectorName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          selectorname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 selectorTarget = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          selectortarget_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Block::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Block)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 selectorName = 1;
  if (this->selectorname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_selectorname(), target);
  }

  // int32 selectorTarget = 2;
  if (this->selectortarget() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_selectortarget(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Block)
  return target;
}

size_t Block::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Block)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 selectorName = 1;
  if (this->selectorname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_selectorname());
  }

  // int32 selectorTarget = 2;
  if (this->selectortarget() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_selectortarget());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Block::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Block*>(
      &from));
}

void Block::MergeFrom(const Block& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Block)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.selectorname() != 0) {
    _internal_set_selectorname(from._internal_selectorname());
  }
  if (from.selectortarget() != 0) {
    _internal_set_selectortarget(from._internal_selectortarget());
  }
}

void Block::CopyFrom(const Block& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Block)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Block::IsInitialized() const {
  return true;
}

void Block::InternalSwap(Block* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Block, selectortarget_)
      + sizeof(Block::selectortarget_)
      - PROTOBUF_FIELD_OFFSET(Block, selectorname_)>(
          reinterpret_cast<char*>(&selectorname_),
          reinterpret_cast<char*>(&other->selectorname_));
}

std::string Block::GetTypeName() const {
  return "RedreamInfo.Block";
}


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

class BlockControl::_Internal {
 public:
};

BlockControl::BlockControl(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.BlockControl)
}
BlockControl::BlockControl(const BlockControl& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&selectorname_, &from.selectorname_,
    static_cast<size_t>(reinterpret_cast<char*>(&controlevents_) -
    reinterpret_cast<char*>(&selectorname_)) + sizeof(controlevents_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.BlockControl)
}

void BlockControl::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&selectorname_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&controlevents_) -
    reinterpret_cast<char*>(&selectorname_)) + sizeof(controlevents_));
}

BlockControl::~BlockControl() {
  // @@protoc_insertion_point(destructor:RedreamInfo.BlockControl)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void BlockControl::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void BlockControl::ArenaDtor(void* object) {
  BlockControl* _this = reinterpret_cast< BlockControl* >(object);
  (void)_this;
}
void BlockControl::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BlockControl::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BlockControl::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.BlockControl)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&selectorname_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&controlevents_) -
      reinterpret_cast<char*>(&selectorname_)) + sizeof(controlevents_));
  _internal_metadata_.Clear<std::string>();
}

const char* BlockControl::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 selectorName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          selectorname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 selectorTarget = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          selectortarget_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 controlEvents = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          controlevents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BlockControl::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.BlockControl)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 selectorName = 1;
  if (this->selectorname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_selectorname(), target);
  }

  // int32 selectorTarget = 2;
  if (this->selectortarget() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_selectortarget(), target);
  }

  // int32 controlEvents = 3;
  if (this->controlevents() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_controlevents(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.BlockControl)
  return target;
}

size_t BlockControl::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.BlockControl)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 selectorName = 1;
  if (this->selectorname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_selectorname());
  }

  // int32 selectorTarget = 2;
  if (this->selectortarget() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_selectortarget());
  }

  // int32 controlEvents = 3;
  if (this->controlevents() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_controlevents());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BlockControl::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BlockControl*>(
      &from));
}

void BlockControl::MergeFrom(const BlockControl& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.BlockControl)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.selectorname() != 0) {
    _internal_set_selectorname(from._internal_selectorname());
  }
  if (from.selectortarget() != 0) {
    _internal_set_selectortarget(from._internal_selectortarget());
  }
  if (from.controlevents() != 0) {
    _internal_set_controlevents(from._internal_controlevents());
  }
}

void BlockControl::CopyFrom(const BlockControl& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.BlockControl)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BlockControl::IsInitialized() const {
  return true;
}

void BlockControl::InternalSwap(BlockControl* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BlockControl, controlevents_)
      + sizeof(BlockControl::controlevents_)
      - PROTOBUF_FIELD_OFFSET(BlockControl, selectorname_)>(
          reinterpret_cast<char*>(&selectorname_),
          reinterpret_cast<char*>(&other->selectorname_));
}

std::string BlockControl::GetTypeName() const {
  return "RedreamInfo.BlockControl";
}


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

class Vec2::_Internal {
 public:
};

Vec2::Vec2(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Vec2)
}
Vec2::Vec2(const Vec2& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&y_) -
    reinterpret_cast<char*>(&x_)) + sizeof(y_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Vec2)
}

void Vec2::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&y_) -
    reinterpret_cast<char*>(&x_)) + sizeof(y_));
}

Vec2::~Vec2() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Vec2)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Vec2::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Vec2::ArenaDtor(void* object) {
  Vec2* _this = reinterpret_cast< Vec2* >(object);
  (void)_this;
}
void Vec2::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Vec2::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Vec2::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Vec2)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&y_) -
      reinterpret_cast<char*>(&x_)) + sizeof(y_));
  _internal_metadata_.Clear<std::string>();
}

const char* Vec2::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Vec2::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Vec2)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Vec2)
  return target;
}

size_t Vec2::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Vec2)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    total_size += 1 + 4;
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Vec2::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Vec2*>(
      &from));
}

void Vec2::MergeFrom(const Vec2& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Vec2)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.x() <= 0 && from.x() >= 0)) {
    _internal_set_x(from._internal_x());
  }
  if (!(from.y() <= 0 && from.y() >= 0)) {
    _internal_set_y(from._internal_y());
  }
}

void Vec2::CopyFrom(const Vec2& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Vec2)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Vec2::IsInitialized() const {
  return true;
}

void Vec2::InternalSwap(Vec2* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Vec2, y_)
      + sizeof(Vec2::y_)
      - PROTOBUF_FIELD_OFFSET(Vec2, x_)>(
          reinterpret_cast<char*>(&x_),
          reinterpret_cast<char*>(&other->x_));
}

std::string Vec2::GetTypeName() const {
  return "RedreamInfo.Vec2";
}


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

class Vec3::_Internal {
 public:
};

Vec3::Vec3(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Vec3)
}
Vec3::Vec3(const Vec3& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&z_) -
    reinterpret_cast<char*>(&x_)) + sizeof(z_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Vec3)
}

void Vec3::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&z_) -
    reinterpret_cast<char*>(&x_)) + sizeof(z_));
}

Vec3::~Vec3() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Vec3)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Vec3::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Vec3::ArenaDtor(void* object) {
  Vec3* _this = reinterpret_cast< Vec3* >(object);
  (void)_this;
}
void Vec3::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Vec3::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Vec3::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Vec3)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&z_) -
      reinterpret_cast<char*>(&x_)) + sizeof(z_));
  _internal_metadata_.Clear<std::string>();
}

const char* Vec3::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float z = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          z_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Vec3::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Vec3)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), target);
  }

  // float z = 3;
  if (!(this->z() <= 0 && this->z() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_z(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Vec3)
  return target;
}

size_t Vec3::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Vec3)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    total_size += 1 + 4;
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    total_size += 1 + 4;
  }

  // float z = 3;
  if (!(this->z() <= 0 && this->z() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Vec3::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Vec3*>(
      &from));
}

void Vec3::MergeFrom(const Vec3& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Vec3)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.x() <= 0 && from.x() >= 0)) {
    _internal_set_x(from._internal_x());
  }
  if (!(from.y() <= 0 && from.y() >= 0)) {
    _internal_set_y(from._internal_y());
  }
  if (!(from.z() <= 0 && from.z() >= 0)) {
    _internal_set_z(from._internal_z());
  }
}

void Vec3::CopyFrom(const Vec3& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Vec3)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Vec3::IsInitialized() const {
  return true;
}

void Vec3::InternalSwap(Vec3* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Vec3, z_)
      + sizeof(Vec3::z_)
      - PROTOBUF_FIELD_OFFSET(Vec3, x_)>(
          reinterpret_cast<char*>(&x_),
          reinterpret_cast<char*>(&other->x_));
}

std::string Vec3::GetTypeName() const {
  return "RedreamInfo.Vec3";
}


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

class SkelFrame::_Internal {
 public:
};

SkelFrame::SkelFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.SkelFrame)
}
SkelFrame::SkelFrame(const SkelFrame& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&animation_, &from.animation_,
    static_cast<size_t>(reinterpret_cast<char*>(&loop_) -
    reinterpret_cast<char*>(&animation_)) + sizeof(loop_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.SkelFrame)
}

void SkelFrame::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&animation_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&loop_) -
    reinterpret_cast<char*>(&animation_)) + sizeof(loop_));
}

SkelFrame::~SkelFrame() {
  // @@protoc_insertion_point(destructor:RedreamInfo.SkelFrame)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void SkelFrame::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void SkelFrame::ArenaDtor(void* object) {
  SkelFrame* _this = reinterpret_cast< SkelFrame* >(object);
  (void)_this;
}
void SkelFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SkelFrame::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SkelFrame::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.SkelFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&animation_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&loop_) -
      reinterpret_cast<char*>(&animation_)) + sizeof(loop_));
  _internal_metadata_.Clear<std::string>();
}

const char* SkelFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 animation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          animation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float progress = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          progress_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // bool loop = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          loop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SkelFrame::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.SkelFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 animation = 1;
  if (this->animation() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_animation(), target);
  }

  // float progress = 2;
  if (!(this->progress() <= 0 && this->progress() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_progress(), target);
  }

  // bool loop = 3;
  if (this->loop() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_loop(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.SkelFrame)
  return target;
}

size_t SkelFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.SkelFrame)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 animation = 1;
  if (this->animation() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_animation());
  }

  // float progress = 2;
  if (!(this->progress() <= 0 && this->progress() >= 0)) {
    total_size += 1 + 4;
  }

  // bool loop = 3;
  if (this->loop() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SkelFrame::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SkelFrame*>(
      &from));
}

void SkelFrame::MergeFrom(const SkelFrame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.SkelFrame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.animation() != 0) {
    _internal_set_animation(from._internal_animation());
  }
  if (!(from.progress() <= 0 && from.progress() >= 0)) {
    _internal_set_progress(from._internal_progress());
  }
  if (from.loop() != 0) {
    _internal_set_loop(from._internal_loop());
  }
}

void SkelFrame::CopyFrom(const SkelFrame& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.SkelFrame)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SkelFrame::IsInitialized() const {
  return true;
}

void SkelFrame::InternalSwap(SkelFrame* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SkelFrame, loop_)
      + sizeof(SkelFrame::loop_)
      - PROTOBUF_FIELD_OFFSET(SkelFrame, animation_)>(
          reinterpret_cast<char*>(&animation_),
          reinterpret_cast<char*>(&other->animation_));
}

std::string SkelFrame::GetTypeName() const {
  return "RedreamInfo.SkelFrame";
}


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

class MinMaxCurveData::_Internal {
 public:
  static const ::RedreamInfo::AnimationCurveData& maxcurve(const MinMaxCurveData* msg);
  static const ::RedreamInfo::AnimationCurveData& mincurve(const MinMaxCurveData* msg);
};

const ::RedreamInfo::AnimationCurveData&
MinMaxCurveData::_Internal::maxcurve(const MinMaxCurveData* msg) {
  return *msg->maxcurve_;
}
const ::RedreamInfo::AnimationCurveData&
MinMaxCurveData::_Internal::mincurve(const MinMaxCurveData* msg) {
  return *msg->mincurve_;
}
MinMaxCurveData::MinMaxCurveData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.MinMaxCurveData)
}
MinMaxCurveData::MinMaxCurveData(const MinMaxCurveData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_maxcurve()) {
    maxcurve_ = new ::RedreamInfo::AnimationCurveData(*from.maxcurve_);
  } else {
    maxcurve_ = nullptr;
  }
  if (from._internal_has_mincurve()) {
    mincurve_ = new ::RedreamInfo::AnimationCurveData(*from.mincurve_);
  } else {
    mincurve_ = nullptr;
  }
  ::memcpy(&scalar_, &from.scalar_,
    static_cast<size_t>(reinterpret_cast<char*>(&minmaxstate_) -
    reinterpret_cast<char*>(&scalar_)) + sizeof(minmaxstate_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.MinMaxCurveData)
}

void MinMaxCurveData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&maxcurve_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&minmaxstate_) -
    reinterpret_cast<char*>(&maxcurve_)) + sizeof(minmaxstate_));
}

MinMaxCurveData::~MinMaxCurveData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.MinMaxCurveData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void MinMaxCurveData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete maxcurve_;
  if (this != internal_default_instance()) delete mincurve_;
}

void MinMaxCurveData::ArenaDtor(void* object) {
  MinMaxCurveData* _this = reinterpret_cast< MinMaxCurveData* >(object);
  (void)_this;
}
void MinMaxCurveData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MinMaxCurveData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MinMaxCurveData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.MinMaxCurveData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArena() == nullptr && maxcurve_ != nullptr) {
    delete maxcurve_;
  }
  maxcurve_ = nullptr;
  if (GetArena() == nullptr && mincurve_ != nullptr) {
    delete mincurve_;
  }
  mincurve_ = nullptr;
  ::memset(&scalar_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&minmaxstate_) -
      reinterpret_cast<char*>(&scalar_)) + sizeof(minmaxstate_));
  _internal_metadata_.Clear<std::string>();
}

const char* MinMaxCurveData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float scalar = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          scalar_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.AnimationCurveData maxCurve = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_maxcurve(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.AnimationCurveData minCurve = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_mincurve(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 minMaxState = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          minmaxstate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MinMaxCurveData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.MinMaxCurveData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float scalar = 1;
  if (!(this->scalar() <= 0 && this->scalar() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_scalar(), target);
  }

  // .RedreamInfo.AnimationCurveData maxCurve = 2;
  if (this->has_maxcurve()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::maxcurve(this), target, stream);
  }

  // .RedreamInfo.AnimationCurveData minCurve = 3;
  if (this->has_mincurve()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::mincurve(this), target, stream);
  }

  // int32 minMaxState = 4;
  if (this->minmaxstate() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_minmaxstate(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.MinMaxCurveData)
  return target;
}

size_t MinMaxCurveData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.MinMaxCurveData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .RedreamInfo.AnimationCurveData maxCurve = 2;
  if (this->has_maxcurve()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *maxcurve_);
  }

  // .RedreamInfo.AnimationCurveData minCurve = 3;
  if (this->has_mincurve()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *mincurve_);
  }

  // float scalar = 1;
  if (!(this->scalar() <= 0 && this->scalar() >= 0)) {
    total_size += 1 + 4;
  }

  // int32 minMaxState = 4;
  if (this->minmaxstate() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_minmaxstate());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MinMaxCurveData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MinMaxCurveData*>(
      &from));
}

void MinMaxCurveData::MergeFrom(const MinMaxCurveData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.MinMaxCurveData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_maxcurve()) {
    _internal_mutable_maxcurve()->::RedreamInfo::AnimationCurveData::MergeFrom(from._internal_maxcurve());
  }
  if (from.has_mincurve()) {
    _internal_mutable_mincurve()->::RedreamInfo::AnimationCurveData::MergeFrom(from._internal_mincurve());
  }
  if (!(from.scalar() <= 0 && from.scalar() >= 0)) {
    _internal_set_scalar(from._internal_scalar());
  }
  if (from.minmaxstate() != 0) {
    _internal_set_minmaxstate(from._internal_minmaxstate());
  }
}

void MinMaxCurveData::CopyFrom(const MinMaxCurveData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.MinMaxCurveData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MinMaxCurveData::IsInitialized() const {
  return true;
}

void MinMaxCurveData::InternalSwap(MinMaxCurveData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MinMaxCurveData, minmaxstate_)
      + sizeof(MinMaxCurveData::minmaxstate_)
      - PROTOBUF_FIELD_OFFSET(MinMaxCurveData, maxcurve_)>(
          reinterpret_cast<char*>(&maxcurve_),
          reinterpret_cast<char*>(&other->maxcurve_));
}

std::string MinMaxCurveData::GetTypeName() const {
  return "RedreamInfo.MinMaxCurveData";
}


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

class AnimationCurveData::_Internal {
 public:
};

AnimationCurveData::AnimationCurveData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  curve_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.AnimationCurveData)
}
AnimationCurveData::AnimationCurveData(const AnimationCurveData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      curve_(from.curve_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&preinfinity_, &from.preinfinity_,
    static_cast<size_t>(reinterpret_cast<char*>(&postinfinity_) -
    reinterpret_cast<char*>(&preinfinity_)) + sizeof(postinfinity_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.AnimationCurveData)
}

void AnimationCurveData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&preinfinity_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&postinfinity_) -
    reinterpret_cast<char*>(&preinfinity_)) + sizeof(postinfinity_));
}

AnimationCurveData::~AnimationCurveData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.AnimationCurveData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void AnimationCurveData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void AnimationCurveData::ArenaDtor(void* object) {
  AnimationCurveData* _this = reinterpret_cast< AnimationCurveData* >(object);
  (void)_this;
}
void AnimationCurveData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AnimationCurveData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AnimationCurveData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.AnimationCurveData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  curve_.Clear();
  ::memset(&preinfinity_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&postinfinity_) -
      reinterpret_cast<char*>(&preinfinity_)) + sizeof(postinfinity_));
  _internal_metadata_.Clear<std::string>();
}

const char* AnimationCurveData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .RedreamInfo.KeyframeData curve = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_curve(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // int32 preInfinity = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          preinfinity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 postInfinity = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          postinfinity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* AnimationCurveData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.AnimationCurveData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .RedreamInfo.KeyframeData curve = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_curve_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_curve(i), target, stream);
  }

  // int32 preInfinity = 2;
  if (this->preinfinity() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_preinfinity(), target);
  }

  // int32 postInfinity = 3;
  if (this->postinfinity() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_postinfinity(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.AnimationCurveData)
  return target;
}

size_t AnimationCurveData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.AnimationCurveData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.KeyframeData curve = 1;
  total_size += 1UL * this->_internal_curve_size();
  for (const auto& msg : this->curve_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int32 preInfinity = 2;
  if (this->preinfinity() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_preinfinity());
  }

  // int32 postInfinity = 3;
  if (this->postinfinity() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_postinfinity());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AnimationCurveData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AnimationCurveData*>(
      &from));
}

void AnimationCurveData::MergeFrom(const AnimationCurveData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.AnimationCurveData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  curve_.MergeFrom(from.curve_);
  if (from.preinfinity() != 0) {
    _internal_set_preinfinity(from._internal_preinfinity());
  }
  if (from.postinfinity() != 0) {
    _internal_set_postinfinity(from._internal_postinfinity());
  }
}

void AnimationCurveData::CopyFrom(const AnimationCurveData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.AnimationCurveData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AnimationCurveData::IsInitialized() const {
  return true;
}

void AnimationCurveData::InternalSwap(AnimationCurveData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  curve_.InternalSwap(&other->curve_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(AnimationCurveData, postinfinity_)
      + sizeof(AnimationCurveData::postinfinity_)
      - PROTOBUF_FIELD_OFFSET(AnimationCurveData, preinfinity_)>(
          reinterpret_cast<char*>(&preinfinity_),
          reinterpret_cast<char*>(&other->preinfinity_));
}

std::string AnimationCurveData::GetTypeName() const {
  return "RedreamInfo.AnimationCurveData";
}


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

class KeyframeData::_Internal {
 public:
};

KeyframeData::KeyframeData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.KeyframeData)
}
KeyframeData::KeyframeData(const KeyframeData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&time_, &from.time_,
    static_cast<size_t>(reinterpret_cast<char*>(&outslope_) -
    reinterpret_cast<char*>(&time_)) + sizeof(outslope_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.KeyframeData)
}

void KeyframeData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&time_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&outslope_) -
    reinterpret_cast<char*>(&time_)) + sizeof(outslope_));
}

KeyframeData::~KeyframeData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.KeyframeData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void KeyframeData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void KeyframeData::ArenaDtor(void* object) {
  KeyframeData* _this = reinterpret_cast< KeyframeData* >(object);
  (void)_this;
}
void KeyframeData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void KeyframeData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void KeyframeData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.KeyframeData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&time_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&outslope_) -
      reinterpret_cast<char*>(&time_)) + sizeof(outslope_));
  _internal_metadata_.Clear<std::string>();
}

const char* KeyframeData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float inSlope = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          inslope_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float outSlope = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          outslope_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* KeyframeData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.KeyframeData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_time(), target);
  }

  // float value = 2;
  if (!(this->value() <= 0 && this->value() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_value(), target);
  }

  // float inSlope = 3;
  if (!(this->inslope() <= 0 && this->inslope() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_inslope(), target);
  }

  // float outSlope = 4;
  if (!(this->outslope() <= 0 && this->outslope() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_outslope(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.KeyframeData)
  return target;
}

size_t KeyframeData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.KeyframeData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    total_size += 1 + 4;
  }

  // float value = 2;
  if (!(this->value() <= 0 && this->value() >= 0)) {
    total_size += 1 + 4;
  }

  // float inSlope = 3;
  if (!(this->inslope() <= 0 && this->inslope() >= 0)) {
    total_size += 1 + 4;
  }

  // float outSlope = 4;
  if (!(this->outslope() <= 0 && this->outslope() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void KeyframeData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const KeyframeData*>(
      &from));
}

void KeyframeData::MergeFrom(const KeyframeData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.KeyframeData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.time() <= 0 && from.time() >= 0)) {
    _internal_set_time(from._internal_time());
  }
  if (!(from.value() <= 0 && from.value() >= 0)) {
    _internal_set_value(from._internal_value());
  }
  if (!(from.inslope() <= 0 && from.inslope() >= 0)) {
    _internal_set_inslope(from._internal_inslope());
  }
  if (!(from.outslope() <= 0 && from.outslope() >= 0)) {
    _internal_set_outslope(from._internal_outslope());
  }
}

void KeyframeData::CopyFrom(const KeyframeData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.KeyframeData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KeyframeData::IsInitialized() const {
  return true;
}

void KeyframeData::InternalSwap(KeyframeData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(KeyframeData, outslope_)
      + sizeof(KeyframeData::outslope_)
      - PROTOBUF_FIELD_OFFSET(KeyframeData, time_)>(
          reinterpret_cast<char*>(&time_),
          reinterpret_cast<char*>(&other->time_));
}

std::string KeyframeData::GetTypeName() const {
  return "RedreamInfo.KeyframeData";
}


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

class MinMaxGradientData::_Internal {
 public:
  static const ::RedreamInfo::GradientNEWData& maxgradient(const MinMaxGradientData* msg);
  static const ::RedreamInfo::GradientNEWData& mingradient(const MinMaxGradientData* msg);
  static const ::RedreamInfo::Color4& mincolor(const MinMaxGradientData* msg);
  static const ::RedreamInfo::Color4& maxcolor(const MinMaxGradientData* msg);
};

const ::RedreamInfo::GradientNEWData&
MinMaxGradientData::_Internal::maxgradient(const MinMaxGradientData* msg) {
  return *msg->maxgradient_;
}
const ::RedreamInfo::GradientNEWData&
MinMaxGradientData::_Internal::mingradient(const MinMaxGradientData* msg) {
  return *msg->mingradient_;
}
const ::RedreamInfo::Color4&
MinMaxGradientData::_Internal::mincolor(const MinMaxGradientData* msg) {
  return *msg->mincolor_;
}
const ::RedreamInfo::Color4&
MinMaxGradientData::_Internal::maxcolor(const MinMaxGradientData* msg) {
  return *msg->maxcolor_;
}
MinMaxGradientData::MinMaxGradientData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.MinMaxGradientData)
}
MinMaxGradientData::MinMaxGradientData(const MinMaxGradientData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_maxgradient()) {
    maxgradient_ = new ::RedreamInfo::GradientNEWData(*from.maxgradient_);
  } else {
    maxgradient_ = nullptr;
  }
  if (from._internal_has_mingradient()) {
    mingradient_ = new ::RedreamInfo::GradientNEWData(*from.mingradient_);
  } else {
    mingradient_ = nullptr;
  }
  if (from._internal_has_mincolor()) {
    mincolor_ = new ::RedreamInfo::Color4(*from.mincolor_);
  } else {
    mincolor_ = nullptr;
  }
  if (from._internal_has_maxcolor()) {
    maxcolor_ = new ::RedreamInfo::Color4(*from.maxcolor_);
  } else {
    maxcolor_ = nullptr;
  }
  minmaxstate_ = from.minmaxstate_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.MinMaxGradientData)
}

void MinMaxGradientData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&maxgradient_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&minmaxstate_) -
    reinterpret_cast<char*>(&maxgradient_)) + sizeof(minmaxstate_));
}

MinMaxGradientData::~MinMaxGradientData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.MinMaxGradientData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void MinMaxGradientData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete maxgradient_;
  if (this != internal_default_instance()) delete mingradient_;
  if (this != internal_default_instance()) delete mincolor_;
  if (this != internal_default_instance()) delete maxcolor_;
}

void MinMaxGradientData::ArenaDtor(void* object) {
  MinMaxGradientData* _this = reinterpret_cast< MinMaxGradientData* >(object);
  (void)_this;
}
void MinMaxGradientData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MinMaxGradientData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MinMaxGradientData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.MinMaxGradientData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArena() == nullptr && maxgradient_ != nullptr) {
    delete maxgradient_;
  }
  maxgradient_ = nullptr;
  if (GetArena() == nullptr && mingradient_ != nullptr) {
    delete mingradient_;
  }
  mingradient_ = nullptr;
  if (GetArena() == nullptr && mincolor_ != nullptr) {
    delete mincolor_;
  }
  mincolor_ = nullptr;
  if (GetArena() == nullptr && maxcolor_ != nullptr) {
    delete maxcolor_;
  }
  maxcolor_ = nullptr;
  minmaxstate_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* MinMaxGradientData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .RedreamInfo.GradientNEWData maxGradient = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_maxgradient(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.GradientNEWData minGradient = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_mingradient(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Color4 minColor = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_mincolor(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Color4 maxColor = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_maxcolor(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 minMaxState = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          minmaxstate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MinMaxGradientData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.MinMaxGradientData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .RedreamInfo.GradientNEWData maxGradient = 1;
  if (this->has_maxgradient()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::maxgradient(this), target, stream);
  }

  // .RedreamInfo.GradientNEWData minGradient = 2;
  if (this->has_mingradient()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::mingradient(this), target, stream);
  }

  // .RedreamInfo.Color4 minColor = 3;
  if (this->has_mincolor()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::mincolor(this), target, stream);
  }

  // .RedreamInfo.Color4 maxColor = 4;
  if (this->has_maxcolor()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::maxcolor(this), target, stream);
  }

  // int32 minMaxState = 5;
  if (this->minmaxstate() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_minmaxstate(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.MinMaxGradientData)
  return target;
}

size_t MinMaxGradientData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.MinMaxGradientData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .RedreamInfo.GradientNEWData maxGradient = 1;
  if (this->has_maxgradient()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *maxgradient_);
  }

  // .RedreamInfo.GradientNEWData minGradient = 2;
  if (this->has_mingradient()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *mingradient_);
  }

  // .RedreamInfo.Color4 minColor = 3;
  if (this->has_mincolor()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *mincolor_);
  }

  // .RedreamInfo.Color4 maxColor = 4;
  if (this->has_maxcolor()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *maxcolor_);
  }

  // int32 minMaxState = 5;
  if (this->minmaxstate() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_minmaxstate());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MinMaxGradientData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MinMaxGradientData*>(
      &from));
}

void MinMaxGradientData::MergeFrom(const MinMaxGradientData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.MinMaxGradientData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_maxgradient()) {
    _internal_mutable_maxgradient()->::RedreamInfo::GradientNEWData::MergeFrom(from._internal_maxgradient());
  }
  if (from.has_mingradient()) {
    _internal_mutable_mingradient()->::RedreamInfo::GradientNEWData::MergeFrom(from._internal_mingradient());
  }
  if (from.has_mincolor()) {
    _internal_mutable_mincolor()->::RedreamInfo::Color4::MergeFrom(from._internal_mincolor());
  }
  if (from.has_maxcolor()) {
    _internal_mutable_maxcolor()->::RedreamInfo::Color4::MergeFrom(from._internal_maxcolor());
  }
  if (from.minmaxstate() != 0) {
    _internal_set_minmaxstate(from._internal_minmaxstate());
  }
}

void MinMaxGradientData::CopyFrom(const MinMaxGradientData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.MinMaxGradientData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MinMaxGradientData::IsInitialized() const {
  return true;
}

void MinMaxGradientData::InternalSwap(MinMaxGradientData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MinMaxGradientData, minmaxstate_)
      + sizeof(MinMaxGradientData::minmaxstate_)
      - PROTOBUF_FIELD_OFFSET(MinMaxGradientData, maxgradient_)>(
          reinterpret_cast<char*>(&maxgradient_),
          reinterpret_cast<char*>(&other->maxgradient_));
}

std::string MinMaxGradientData::GetTypeName() const {
  return "RedreamInfo.MinMaxGradientData";
}


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

class GradientNEWData::_Internal {
 public:
};

GradientNEWData::GradientNEWData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  color_(arena),
  alpha_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.GradientNEWData)
}
GradientNEWData::GradientNEWData(const GradientNEWData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      color_(from.color_),
      alpha_(from.alpha_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.GradientNEWData)
}

void GradientNEWData::SharedCtor() {
}

GradientNEWData::~GradientNEWData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.GradientNEWData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void GradientNEWData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void GradientNEWData::ArenaDtor(void* object) {
  GradientNEWData* _this = reinterpret_cast< GradientNEWData* >(object);
  (void)_this;
}
void GradientNEWData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void GradientNEWData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void GradientNEWData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.GradientNEWData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  color_.Clear();
  alpha_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GradientNEWData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .RedreamInfo.Color3BData color = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_color(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.AlphaData alpha = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_alpha(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* GradientNEWData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.GradientNEWData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .RedreamInfo.Color3BData color = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_color_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_color(i), target, stream);
  }

  // repeated .RedreamInfo.AlphaData alpha = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_alpha_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_alpha(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.GradientNEWData)
  return target;
}

size_t GradientNEWData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.GradientNEWData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.Color3BData color = 1;
  total_size += 1UL * this->_internal_color_size();
  for (const auto& msg : this->color_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .RedreamInfo.AlphaData alpha = 2;
  total_size += 1UL * this->_internal_alpha_size();
  for (const auto& msg : this->alpha_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GradientNEWData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const GradientNEWData*>(
      &from));
}

void GradientNEWData::MergeFrom(const GradientNEWData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.GradientNEWData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  color_.MergeFrom(from.color_);
  alpha_.MergeFrom(from.alpha_);
}

void GradientNEWData::CopyFrom(const GradientNEWData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.GradientNEWData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GradientNEWData::IsInitialized() const {
  return true;
}

void GradientNEWData::InternalSwap(GradientNEWData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  color_.InternalSwap(&other->color_);
  alpha_.InternalSwap(&other->alpha_);
}

std::string GradientNEWData::GetTypeName() const {
  return "RedreamInfo.GradientNEWData";
}


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

class Color3BData::_Internal {
 public:
  static const ::RedreamInfo::Color3& color(const Color3BData* msg);
};

const ::RedreamInfo::Color3&
Color3BData::_Internal::color(const Color3BData* msg) {
  return *msg->color_;
}
Color3BData::Color3BData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Color3BData)
}
Color3BData::Color3BData(const Color3BData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_color()) {
    color_ = new ::RedreamInfo::Color3(*from.color_);
  } else {
    color_ = nullptr;
  }
  time_ = from.time_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Color3BData)
}

void Color3BData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&color_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&time_) -
    reinterpret_cast<char*>(&color_)) + sizeof(time_));
}

Color3BData::~Color3BData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Color3BData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Color3BData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete color_;
}

void Color3BData::ArenaDtor(void* object) {
  Color3BData* _this = reinterpret_cast< Color3BData* >(object);
  (void)_this;
}
void Color3BData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Color3BData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Color3BData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Color3BData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArena() == nullptr && color_ != nullptr) {
    delete color_;
  }
  color_ = nullptr;
  time_ = 0u;
  _internal_metadata_.Clear<std::string>();
}

const char* Color3BData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // uint32 time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Color3 color = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_color(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Color3BData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Color3BData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 time = 1;
  if (this->time() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_time(), target);
  }

  // .RedreamInfo.Color3 color = 2;
  if (this->has_color()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::color(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Color3BData)
  return target;
}

size_t Color3BData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Color3BData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .RedreamInfo.Color3 color = 2;
  if (this->has_color()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *color_);
  }

  // uint32 time = 1;
  if (this->time() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_time());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Color3BData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Color3BData*>(
      &from));
}

void Color3BData::MergeFrom(const Color3BData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Color3BData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_color()) {
    _internal_mutable_color()->::RedreamInfo::Color3::MergeFrom(from._internal_color());
  }
  if (from.time() != 0) {
    _internal_set_time(from._internal_time());
  }
}

void Color3BData::CopyFrom(const Color3BData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Color3BData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Color3BData::IsInitialized() const {
  return true;
}

void Color3BData::InternalSwap(Color3BData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Color3BData, time_)
      + sizeof(Color3BData::time_)
      - PROTOBUF_FIELD_OFFSET(Color3BData, color_)>(
          reinterpret_cast<char*>(&color_),
          reinterpret_cast<char*>(&other->color_));
}

std::string Color3BData::GetTypeName() const {
  return "RedreamInfo.Color3BData";
}


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

class AlphaData::_Internal {
 public:
};

AlphaData::AlphaData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.AlphaData)
}
AlphaData::AlphaData(const AlphaData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&time_, &from.time_,
    static_cast<size_t>(reinterpret_cast<char*>(&alpha_) -
    reinterpret_cast<char*>(&time_)) + sizeof(alpha_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.AlphaData)
}

void AlphaData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&time_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&alpha_) -
    reinterpret_cast<char*>(&time_)) + sizeof(alpha_));
}

AlphaData::~AlphaData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.AlphaData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void AlphaData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void AlphaData::ArenaDtor(void* object) {
  AlphaData* _this = reinterpret_cast< AlphaData* >(object);
  (void)_this;
}
void AlphaData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AlphaData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AlphaData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.AlphaData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&time_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&alpha_) -
      reinterpret_cast<char*>(&time_)) + sizeof(alpha_));
  _internal_metadata_.Clear<std::string>();
}

const char* AlphaData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // uint32 time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 alpha = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* AlphaData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.AlphaData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 time = 1;
  if (this->time() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_time(), target);
  }

  // uint32 alpha = 2;
  if (this->alpha() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_alpha(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.AlphaData)
  return target;
}

size_t AlphaData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.AlphaData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // uint32 time = 1;
  if (this->time() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_time());
  }

  // uint32 alpha = 2;
  if (this->alpha() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_alpha());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AlphaData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AlphaData*>(
      &from));
}

void AlphaData::MergeFrom(const AlphaData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.AlphaData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.time() != 0) {
    _internal_set_time(from._internal_time());
  }
  if (from.alpha() != 0) {
    _internal_set_alpha(from._internal_alpha());
  }
}

void AlphaData::CopyFrom(const AlphaData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.AlphaData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AlphaData::IsInitialized() const {
  return true;
}

void AlphaData::InternalSwap(AlphaData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(AlphaData, alpha_)
      + sizeof(AlphaData::alpha_)
      - PROTOBUF_FIELD_OFFSET(AlphaData, time_)>(
          reinterpret_cast<char*>(&time_),
          reinterpret_cast<char*>(&other->time_));
}

std::string AlphaData::GetTypeName() const {
  return "RedreamInfo.AlphaData";
}


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

class EmissionData::_Internal {
 public:
};

EmissionData::EmissionData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  burstdata_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.EmissionData)
}
EmissionData::EmissionData(const EmissionData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      burstdata_(from.burstdata_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.EmissionData)
}

void EmissionData::SharedCtor() {
}

EmissionData::~EmissionData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.EmissionData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void EmissionData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void EmissionData::ArenaDtor(void* object) {
  EmissionData* _this = reinterpret_cast< EmissionData* >(object);
  (void)_this;
}
void EmissionData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void EmissionData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void EmissionData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.EmissionData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  burstdata_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* EmissionData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .RedreamInfo.BurstData burstData = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_burstdata(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* EmissionData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.EmissionData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .RedreamInfo.BurstData burstData = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_burstdata_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_burstdata(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.EmissionData)
  return target;
}

size_t EmissionData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.EmissionData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.BurstData burstData = 1;
  total_size += 1UL * this->_internal_burstdata_size();
  for (const auto& msg : this->burstdata_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void EmissionData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const EmissionData*>(
      &from));
}

void EmissionData::MergeFrom(const EmissionData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.EmissionData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  burstdata_.MergeFrom(from.burstdata_);
}

void EmissionData::CopyFrom(const EmissionData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.EmissionData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EmissionData::IsInitialized() const {
  return true;
}

void EmissionData::InternalSwap(EmissionData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  burstdata_.InternalSwap(&other->burstdata_);
}

std::string EmissionData::GetTypeName() const {
  return "RedreamInfo.EmissionData";
}


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

class BurstData::_Internal {
 public:
};

BurstData::BurstData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.BurstData)
}
BurstData::BurstData(const BurstData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&bursttime_, &from.bursttime_,
    static_cast<size_t>(reinterpret_cast<char*>(&burstparticlecount_) -
    reinterpret_cast<char*>(&bursttime_)) + sizeof(burstparticlecount_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.BurstData)
}

void BurstData::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&bursttime_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&burstparticlecount_) -
    reinterpret_cast<char*>(&bursttime_)) + sizeof(burstparticlecount_));
}

BurstData::~BurstData() {
  // @@protoc_insertion_point(destructor:RedreamInfo.BurstData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void BurstData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void BurstData::ArenaDtor(void* object) {
  BurstData* _this = reinterpret_cast< BurstData* >(object);
  (void)_this;
}
void BurstData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BurstData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BurstData::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.BurstData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&bursttime_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&burstparticlecount_) -
      reinterpret_cast<char*>(&bursttime_)) + sizeof(burstparticlecount_));
  _internal_metadata_.Clear<std::string>();
}

const char* BurstData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float burstTime = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          bursttime_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // uint32 burstParticleCount = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          burstparticlecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BurstData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.BurstData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float burstTime = 1;
  if (!(this->bursttime() <= 0 && this->bursttime() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_bursttime(), target);
  }

  // uint32 burstParticleCount = 2;
  if (this->burstparticlecount() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_burstparticlecount(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.BurstData)
  return target;
}

size_t BurstData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.BurstData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float burstTime = 1;
  if (!(this->bursttime() <= 0 && this->bursttime() >= 0)) {
    total_size += 1 + 4;
  }

  // uint32 burstParticleCount = 2;
  if (this->burstparticlecount() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_burstparticlecount());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BurstData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BurstData*>(
      &from));
}

void BurstData::MergeFrom(const BurstData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.BurstData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.bursttime() <= 0 && from.bursttime() >= 0)) {
    _internal_set_bursttime(from._internal_bursttime());
  }
  if (from.burstparticlecount() != 0) {
    _internal_set_burstparticlecount(from._internal_burstparticlecount());
  }
}

void BurstData::CopyFrom(const BurstData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.BurstData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BurstData::IsInitialized() const {
  return true;
}

void BurstData::InternalSwap(BurstData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BurstData, burstparticlecount_)
      + sizeof(BurstData::burstparticlecount_)
      - PROTOBUF_FIELD_OFFSET(BurstData, bursttime_)>(
          reinterpret_cast<char*>(&bursttime_),
          reinterpret_cast<char*>(&other->bursttime_));
}

std::string BurstData::GetTypeName() const {
  return "RedreamInfo.BurstData";
}


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

class Percent::_Internal {
 public:
};

Percent::Percent(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Percent)
}
Percent::Percent(const Percent& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  value_ = from.value_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Percent)
}

void Percent::SharedCtor() {
value_ = 0;
}

Percent::~Percent() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Percent)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Percent::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Percent::ArenaDtor(void* object) {
  Percent* _this = reinterpret_cast< Percent* >(object);
  (void)_this;
}
void Percent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Percent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Percent::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Percent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  value_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* Percent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 value = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Percent::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Percent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 value = 1;
  if (this->value() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Percent)
  return target;
}

size_t Percent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Percent)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 value = 1;
  if (this->value() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_value());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Percent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Percent*>(
      &from));
}

void Percent::MergeFrom(const Percent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Percent)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.value() != 0) {
    _internal_set_value(from._internal_value());
  }
}

void Percent::CopyFrom(const Percent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Percent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Percent::IsInitialized() const {
  return true;
}

void Percent::InternalSwap(Percent* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(value_, other->value_);
}

std::string Percent::GetTypeName() const {
  return "RedreamInfo.Percent";
}


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

class Callbacks::_Internal {
 public:
};

Callbacks::Callbacks(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Callbacks)
}
Callbacks::Callbacks(const Callbacks& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&selectorname_, &from.selectorname_,
    static_cast<size_t>(reinterpret_cast<char*>(&selectortarget_) -
    reinterpret_cast<char*>(&selectorname_)) + sizeof(selectortarget_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Callbacks)
}

void Callbacks::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&selectorname_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&selectortarget_) -
    reinterpret_cast<char*>(&selectorname_)) + sizeof(selectortarget_));
}

Callbacks::~Callbacks() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Callbacks)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Callbacks::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Callbacks::ArenaDtor(void* object) {
  Callbacks* _this = reinterpret_cast< Callbacks* >(object);
  (void)_this;
}
void Callbacks::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Callbacks::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Callbacks::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Callbacks)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&selectorname_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&selectortarget_) -
      reinterpret_cast<char*>(&selectorname_)) + sizeof(selectortarget_));
  _internal_metadata_.Clear<std::string>();
}

const char* Callbacks::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 selectorName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          selectorname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 selectorTarget = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          selectortarget_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Callbacks::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Callbacks)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 selectorName = 1;
  if (this->selectorname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_selectorname(), target);
  }

  // int32 selectorTarget = 2;
  if (this->selectortarget() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_selectortarget(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Callbacks)
  return target;
}

size_t Callbacks::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Callbacks)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 selectorName = 1;
  if (this->selectorname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_selectorname());
  }

  // int32 selectorTarget = 2;
  if (this->selectortarget() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_selectortarget());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Callbacks::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Callbacks*>(
      &from));
}

void Callbacks::MergeFrom(const Callbacks& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Callbacks)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.selectorname() != 0) {
    _internal_set_selectorname(from._internal_selectorname());
  }
  if (from.selectortarget() != 0) {
    _internal_set_selectortarget(from._internal_selectortarget());
  }
}

void Callbacks::CopyFrom(const Callbacks& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Callbacks)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Callbacks::IsInitialized() const {
  return true;
}

void Callbacks::InternalSwap(Callbacks* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Callbacks, selectortarget_)
      + sizeof(Callbacks::selectortarget_)
      - PROTOBUF_FIELD_OFFSET(Callbacks, selectorname_)>(
          reinterpret_cast<char*>(&selectorname_),
          reinterpret_cast<char*>(&other->selectorname_));
}

std::string Callbacks::GetTypeName() const {
  return "RedreamInfo.Callbacks";
}


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

class SequencePropertyMap::_Internal {
 public:
};

SequencePropertyMap::SequencePropertyMap(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  props_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.SequencePropertyMap)
}
SequencePropertyMap::SequencePropertyMap(const SequencePropertyMap& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      props_(from.props_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  seqid_ = from.seqid_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.SequencePropertyMap)
}

void SequencePropertyMap::SharedCtor() {
seqid_ = 0;
}

SequencePropertyMap::~SequencePropertyMap() {
  // @@protoc_insertion_point(destructor:RedreamInfo.SequencePropertyMap)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void SequencePropertyMap::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void SequencePropertyMap::ArenaDtor(void* object) {
  SequencePropertyMap* _this = reinterpret_cast< SequencePropertyMap* >(object);
  (void)_this;
}
void SequencePropertyMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SequencePropertyMap::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SequencePropertyMap::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.SequencePropertyMap)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  props_.Clear();
  seqid_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* SequencePropertyMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 seqId = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          seqid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.SequenceProperty props = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_props(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SequencePropertyMap::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.SequencePropertyMap)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 seqId = 1;
  if (this->seqid() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_seqid(), target);
  }

  // repeated .RedreamInfo.SequenceProperty props = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_props_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_props(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.SequencePropertyMap)
  return target;
}

size_t SequencePropertyMap::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.SequencePropertyMap)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.SequenceProperty props = 2;
  total_size += 1UL * this->_internal_props_size();
  for (const auto& msg : this->props_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int32 seqId = 1;
  if (this->seqid() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_seqid());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SequencePropertyMap::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SequencePropertyMap*>(
      &from));
}

void SequencePropertyMap::MergeFrom(const SequencePropertyMap& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.SequencePropertyMap)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  props_.MergeFrom(from.props_);
  if (from.seqid() != 0) {
    _internal_set_seqid(from._internal_seqid());
  }
}

void SequencePropertyMap::CopyFrom(const SequencePropertyMap& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.SequencePropertyMap)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SequencePropertyMap::IsInitialized() const {
  return true;
}

void SequencePropertyMap::InternalSwap(SequencePropertyMap* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  props_.InternalSwap(&other->props_);
  swap(seqid_, other->seqid_);
}

std::string SequencePropertyMap::GetTypeName() const {
  return "RedreamInfo.SequencePropertyMap";
}


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

class SequenceProperty::_Internal {
 public:
};

SequenceProperty::SequenceProperty(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  keyframes_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.SequenceProperty)
}
SequenceProperty::SequenceProperty(const SequenceProperty& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      keyframes_(from.keyframes_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&type_, &from.type_,
    static_cast<size_t>(reinterpret_cast<char*>(&name_) -
    reinterpret_cast<char*>(&type_)) + sizeof(name_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.SequenceProperty)
}

void SequenceProperty::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&name_) -
    reinterpret_cast<char*>(&type_)) + sizeof(name_));
}

SequenceProperty::~SequenceProperty() {
  // @@protoc_insertion_point(destructor:RedreamInfo.SequenceProperty)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void SequenceProperty::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void SequenceProperty::ArenaDtor(void* object) {
  SequenceProperty* _this = reinterpret_cast< SequenceProperty* >(object);
  (void)_this;
}
void SequenceProperty::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SequenceProperty::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SequenceProperty::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.SequenceProperty)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  keyframes_.Clear();
  ::memset(&type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&name_) -
      reinterpret_cast<char*>(&type_)) + sizeof(name_));
  _internal_metadata_.Clear<std::string>();
}

const char* SequenceProperty::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          name_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.Keyframe keyframes = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_keyframes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SequenceProperty::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.SequenceProperty)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 type = 1;
  if (this->type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_type(), target);
  }

  // int32 name = 2;
  if (this->name() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_name(), target);
  }

  // repeated .RedreamInfo.Keyframe keyframes = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_keyframes_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_keyframes(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.SequenceProperty)
  return target;
}

size_t SequenceProperty::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.SequenceProperty)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.Keyframe keyframes = 3;
  total_size += 1UL * this->_internal_keyframes_size();
  for (const auto& msg : this->keyframes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int32 type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_type());
  }

  // int32 name = 2;
  if (this->name() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_name());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SequenceProperty::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SequenceProperty*>(
      &from));
}

void SequenceProperty::MergeFrom(const SequenceProperty& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.SequenceProperty)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  keyframes_.MergeFrom(from.keyframes_);
  if (from.type() != 0) {
    _internal_set_type(from._internal_type());
  }
  if (from.name() != 0) {
    _internal_set_name(from._internal_name());
  }
}

void SequenceProperty::CopyFrom(const SequenceProperty& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.SequenceProperty)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SequenceProperty::IsInitialized() const {
  return true;
}

void SequenceProperty::InternalSwap(SequenceProperty* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  keyframes_.InternalSwap(&other->keyframes_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SequenceProperty, name_)
      + sizeof(SequenceProperty::name_)
      - PROTOBUF_FIELD_OFFSET(SequenceProperty, type_)>(
          reinterpret_cast<char*>(&type_),
          reinterpret_cast<char*>(&other->type_));
}

std::string SequenceProperty::GetTypeName() const {
  return "RedreamInfo.SequenceProperty";
}


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

class Keyframe::_Internal {
 public:
  static const ::RedreamInfo::Easing& easing(const Keyframe* msg);
  static const ::RedreamInfo::Value& value(const Keyframe* msg);
};

const ::RedreamInfo::Easing&
Keyframe::_Internal::easing(const Keyframe* msg) {
  return *msg->easing_;
}
const ::RedreamInfo::Value&
Keyframe::_Internal::value(const Keyframe* msg) {
  return *msg->value_;
}
Keyframe::Keyframe(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  equalpoints_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Keyframe)
}
Keyframe::Keyframe(const Keyframe& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      equalpoints_(from.equalpoints_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_easing()) {
    easing_ = new ::RedreamInfo::Easing(*from.easing_);
  } else {
    easing_ = nullptr;
  }
  if (from._internal_has_value()) {
    value_ = new ::RedreamInfo::Value(*from.value_);
  } else {
    value_ = nullptr;
  }
  time_ = from.time_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Keyframe)
}

void Keyframe::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&easing_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&time_) -
    reinterpret_cast<char*>(&easing_)) + sizeof(time_));
}

Keyframe::~Keyframe() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Keyframe)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Keyframe::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete easing_;
  if (this != internal_default_instance()) delete value_;
}

void Keyframe::ArenaDtor(void* object) {
  Keyframe* _this = reinterpret_cast< Keyframe* >(object);
  (void)_this;
}
void Keyframe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Keyframe::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Keyframe::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Keyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  equalpoints_.Clear();
  if (GetArena() == nullptr && easing_ != nullptr) {
    delete easing_;
  }
  easing_ = nullptr;
  if (GetArena() == nullptr && value_ != nullptr) {
    delete value_;
  }
  value_ = nullptr;
  time_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* Keyframe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Easing easing = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_easing(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Value value = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.Vec2 equalPoints = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_equalpoints(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Keyframe::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Keyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_time(), target);
  }

  // .RedreamInfo.Easing easing = 2;
  if (this->has_easing()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::easing(this), target, stream);
  }

  // .RedreamInfo.Value value = 3;
  if (this->has_value()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::value(this), target, stream);
  }

  // repeated .RedreamInfo.Vec2 equalPoints = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_equalpoints_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_equalpoints(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Keyframe)
  return target;
}

size_t Keyframe::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Keyframe)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.Vec2 equalPoints = 4;
  total_size += 1UL * this->_internal_equalpoints_size();
  for (const auto& msg : this->equalpoints_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .RedreamInfo.Easing easing = 2;
  if (this->has_easing()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *easing_);
  }

  // .RedreamInfo.Value value = 3;
  if (this->has_value()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *value_);
  }

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Keyframe::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Keyframe*>(
      &from));
}

void Keyframe::MergeFrom(const Keyframe& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Keyframe)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  equalpoints_.MergeFrom(from.equalpoints_);
  if (from.has_easing()) {
    _internal_mutable_easing()->::RedreamInfo::Easing::MergeFrom(from._internal_easing());
  }
  if (from.has_value()) {
    _internal_mutable_value()->::RedreamInfo::Value::MergeFrom(from._internal_value());
  }
  if (!(from.time() <= 0 && from.time() >= 0)) {
    _internal_set_time(from._internal_time());
  }
}

void Keyframe::CopyFrom(const Keyframe& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Keyframe)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Keyframe::IsInitialized() const {
  return true;
}

void Keyframe::InternalSwap(Keyframe* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  equalpoints_.InternalSwap(&other->equalpoints_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Keyframe, time_)
      + sizeof(Keyframe::time_)
      - PROTOBUF_FIELD_OFFSET(Keyframe, easing_)>(
          reinterpret_cast<char*>(&easing_),
          reinterpret_cast<char*>(&other->easing_));
}

std::string Keyframe::GetTypeName() const {
  return "RedreamInfo.Keyframe";
}


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

class Easing::_Internal {
 public:
  static const ::RedreamInfo::EasingOpt& opt(const Easing* msg);
};

const ::RedreamInfo::EasingOpt&
Easing::_Internal::opt(const Easing* msg) {
  return *msg->opt_;
}
Easing::Easing(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Easing)
}
Easing::Easing(const Easing& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_opt()) {
    opt_ = new ::RedreamInfo::EasingOpt(*from.opt_);
  } else {
    opt_ = nullptr;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Easing)
}

void Easing::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&opt_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&opt_)) + sizeof(type_));
}

Easing::~Easing() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Easing)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Easing::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete opt_;
}

void Easing::ArenaDtor(void* object) {
  Easing* _this = reinterpret_cast< Easing* >(object);
  (void)_this;
}
void Easing::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Easing::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Easing::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Easing)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArena() == nullptr && opt_ != nullptr) {
    delete opt_;
  }
  opt_ = nullptr;
  type_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* Easing::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.EasingOpt opt = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_opt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Easing::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Easing)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 type = 1;
  if (this->type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_type(), target);
  }

  // .RedreamInfo.EasingOpt opt = 2;
  if (this->has_opt()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::opt(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Easing)
  return target;
}

size_t Easing::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Easing)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .RedreamInfo.EasingOpt opt = 2;
  if (this->has_opt()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *opt_);
  }

  // int32 type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Easing::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Easing*>(
      &from));
}

void Easing::MergeFrom(const Easing& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Easing)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_opt()) {
    _internal_mutable_opt()->::RedreamInfo::EasingOpt::MergeFrom(from._internal_opt());
  }
  if (from.type() != 0) {
    _internal_set_type(from._internal_type());
  }
}

void Easing::CopyFrom(const Easing& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Easing)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Easing::IsInitialized() const {
  return true;
}

void Easing::InternalSwap(Easing* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Easing, type_)
      + sizeof(Easing::type_)
      - PROTOBUF_FIELD_OFFSET(Easing, opt_)>(
          reinterpret_cast<char*>(&opt_),
          reinterpret_cast<char*>(&other->opt_));
}

std::string Easing::GetTypeName() const {
  return "RedreamInfo.Easing";
}


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

class EasingOpt::_Internal {
 public:
  static const ::RedreamInfo::Easing1fOpt& easing1fopt(const EasingOpt* msg);
  static const ::RedreamInfo::Easing4fOpt& easing4fopt(const EasingOpt* msg);
};

const ::RedreamInfo::Easing1fOpt&
EasingOpt::_Internal::easing1fopt(const EasingOpt* msg) {
  return *msg->attri_.easing1fopt_;
}
const ::RedreamInfo::Easing4fOpt&
EasingOpt::_Internal::easing4fopt(const EasingOpt* msg) {
  return *msg->attri_.easing4fopt_;
}
void EasingOpt::set_allocated_easing1fopt(::RedreamInfo::Easing1fOpt* easing1fopt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (easing1fopt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(easing1fopt);
    if (message_arena != submessage_arena) {
      easing1fopt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, easing1fopt, submessage_arena);
    }
    set_has_easing1fopt();
    attri_.easing1fopt_ = easing1fopt;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.EasingOpt.easing1fopt)
}
void EasingOpt::set_allocated_easing4fopt(::RedreamInfo::Easing4fOpt* easing4fopt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_attri();
  if (easing4fopt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(easing4fopt);
    if (message_arena != submessage_arena) {
      easing4fopt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, easing4fopt, submessage_arena);
    }
    set_has_easing4fopt();
    attri_.easing4fopt_ = easing4fopt;
  }
  // @@protoc_insertion_point(field_set_allocated:RedreamInfo.EasingOpt.easing4fopt)
}
EasingOpt::EasingOpt(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.EasingOpt)
}
EasingOpt::EasingOpt(const EasingOpt& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_attri();
  switch (from.attri_case()) {
    case kEasing1Fopt: {
      _internal_mutable_easing1fopt()->::RedreamInfo::Easing1fOpt::MergeFrom(from._internal_easing1fopt());
      break;
    }
    case kEasing4Fopt: {
      _internal_mutable_easing4fopt()->::RedreamInfo::Easing4fOpt::MergeFrom(from._internal_easing4fopt());
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.EasingOpt)
}

void EasingOpt::SharedCtor() {
clear_has_attri();
}

EasingOpt::~EasingOpt() {
  // @@protoc_insertion_point(destructor:RedreamInfo.EasingOpt)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void EasingOpt::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (has_attri()) {
    clear_attri();
  }
}

void EasingOpt::ArenaDtor(void* object) {
  EasingOpt* _this = reinterpret_cast< EasingOpt* >(object);
  (void)_this;
}
void EasingOpt::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void EasingOpt::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void EasingOpt::clear_attri() {
// @@protoc_insertion_point(one_of_clear_start:RedreamInfo.EasingOpt)
  switch (attri_case()) {
    case kEasing1Fopt: {
      if (GetArena() == nullptr) {
        delete attri_.easing1fopt_;
      }
      break;
    }
    case kEasing4Fopt: {
      if (GetArena() == nullptr) {
        delete attri_.easing4fopt_;
      }
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ATTRI_NOT_SET;
}


void EasingOpt::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.EasingOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_attri();
  _internal_metadata_.Clear<std::string>();
}

const char* EasingOpt::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .RedreamInfo.Easing1fOpt easing1fopt = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_easing1fopt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Easing4fOpt easing4fopt = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_easing4fopt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* EasingOpt::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.EasingOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .RedreamInfo.Easing1fOpt easing1fopt = 1;
  if (_internal_has_easing1fopt()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::easing1fopt(this), target, stream);
  }

  // .RedreamInfo.Easing4fOpt easing4fopt = 2;
  if (_internal_has_easing4fopt()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::easing4fopt(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.EasingOpt)
  return target;
}

size_t EasingOpt::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.EasingOpt)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (attri_case()) {
    // .RedreamInfo.Easing1fOpt easing1fopt = 1;
    case kEasing1Fopt: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.easing1fopt_);
      break;
    }
    // .RedreamInfo.Easing4fOpt easing4fopt = 2;
    case kEasing4Fopt: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *attri_.easing4fopt_);
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void EasingOpt::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const EasingOpt*>(
      &from));
}

void EasingOpt::MergeFrom(const EasingOpt& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.EasingOpt)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.attri_case()) {
    case kEasing1Fopt: {
      _internal_mutable_easing1fopt()->::RedreamInfo::Easing1fOpt::MergeFrom(from._internal_easing1fopt());
      break;
    }
    case kEasing4Fopt: {
      _internal_mutable_easing4fopt()->::RedreamInfo::Easing4fOpt::MergeFrom(from._internal_easing4fopt());
      break;
    }
    case ATTRI_NOT_SET: {
      break;
    }
  }
}

void EasingOpt::CopyFrom(const EasingOpt& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.EasingOpt)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EasingOpt::IsInitialized() const {
  return true;
}

void EasingOpt::InternalSwap(EasingOpt* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(attri_, other->attri_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

std::string EasingOpt::GetTypeName() const {
  return "RedreamInfo.EasingOpt";
}


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

class Easing1fOpt::_Internal {
 public:
};

Easing1fOpt::Easing1fOpt(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Easing1fOpt)
}
Easing1fOpt::Easing1fOpt(const Easing1fOpt& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  x_ = from.x_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Easing1fOpt)
}

void Easing1fOpt::SharedCtor() {
x_ = 0;
}

Easing1fOpt::~Easing1fOpt() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Easing1fOpt)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Easing1fOpt::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Easing1fOpt::ArenaDtor(void* object) {
  Easing1fOpt* _this = reinterpret_cast< Easing1fOpt* >(object);
  (void)_this;
}
void Easing1fOpt::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Easing1fOpt::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Easing1fOpt::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Easing1fOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  x_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* Easing1fOpt::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Easing1fOpt::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Easing1fOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Easing1fOpt)
  return target;
}

size_t Easing1fOpt::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Easing1fOpt)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Easing1fOpt::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Easing1fOpt*>(
      &from));
}

void Easing1fOpt::MergeFrom(const Easing1fOpt& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Easing1fOpt)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.x() <= 0 && from.x() >= 0)) {
    _internal_set_x(from._internal_x());
  }
}

void Easing1fOpt::CopyFrom(const Easing1fOpt& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Easing1fOpt)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Easing1fOpt::IsInitialized() const {
  return true;
}

void Easing1fOpt::InternalSwap(Easing1fOpt* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(x_, other->x_);
}

std::string Easing1fOpt::GetTypeName() const {
  return "RedreamInfo.Easing1fOpt";
}


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

class Easing4fOpt::_Internal {
 public:
};

Easing4fOpt::Easing4fOpt(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Easing4fOpt)
}
Easing4fOpt::Easing4fOpt(const Easing4fOpt& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&w_) -
    reinterpret_cast<char*>(&x_)) + sizeof(w_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Easing4fOpt)
}

void Easing4fOpt::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&w_) -
    reinterpret_cast<char*>(&x_)) + sizeof(w_));
}

Easing4fOpt::~Easing4fOpt() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Easing4fOpt)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Easing4fOpt::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Easing4fOpt::ArenaDtor(void* object) {
  Easing4fOpt* _this = reinterpret_cast< Easing4fOpt* >(object);
  (void)_this;
}
void Easing4fOpt::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Easing4fOpt::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Easing4fOpt::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Easing4fOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&w_) -
      reinterpret_cast<char*>(&x_)) + sizeof(w_));
  _internal_metadata_.Clear<std::string>();
}

const char* Easing4fOpt::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float z = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          z_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float w = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          w_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Easing4fOpt::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Easing4fOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), target);
  }

  // float z = 3;
  if (!(this->z() <= 0 && this->z() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_z(), target);
  }

  // float w = 4;
  if (!(this->w() <= 0 && this->w() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_w(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Easing4fOpt)
  return target;
}

size_t Easing4fOpt::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Easing4fOpt)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    total_size += 1 + 4;
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    total_size += 1 + 4;
  }

  // float z = 3;
  if (!(this->z() <= 0 && this->z() >= 0)) {
    total_size += 1 + 4;
  }

  // float w = 4;
  if (!(this->w() <= 0 && this->w() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Easing4fOpt::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Easing4fOpt*>(
      &from));
}

void Easing4fOpt::MergeFrom(const Easing4fOpt& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Easing4fOpt)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.x() <= 0 && from.x() >= 0)) {
    _internal_set_x(from._internal_x());
  }
  if (!(from.y() <= 0 && from.y() >= 0)) {
    _internal_set_y(from._internal_y());
  }
  if (!(from.z() <= 0 && from.z() >= 0)) {
    _internal_set_z(from._internal_z());
  }
  if (!(from.w() <= 0 && from.w() >= 0)) {
    _internal_set_w(from._internal_w());
  }
}

void Easing4fOpt::CopyFrom(const Easing4fOpt& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Easing4fOpt)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Easing4fOpt::IsInitialized() const {
  return true;
}

void Easing4fOpt::InternalSwap(Easing4fOpt* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Easing4fOpt, w_)
      + sizeof(Easing4fOpt::w_)
      - PROTOBUF_FIELD_OFFSET(Easing4fOpt, x_)>(
          reinterpret_cast<char*>(&x_),
          reinterpret_cast<char*>(&other->x_));
}

std::string Easing4fOpt::GetTypeName() const {
  return "RedreamInfo.Easing4fOpt";
}


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

class Property::_Internal {
 public:
  static const ::RedreamInfo::Value& value(const Property* msg);
};

const ::RedreamInfo::Value&
Property::_Internal::value(const Property* msg) {
  return *msg->value_;
}
Property::Property(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Property)
}
Property::Property(const Property& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_value()) {
    value_ = new ::RedreamInfo::Value(*from.value_);
  } else {
    value_ = nullptr;
  }
  ::memcpy(&name_, &from.name_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&name_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Property)
}

void Property::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&value_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&value_)) + sizeof(type_));
}

Property::~Property() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Property)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Property::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete value_;
}

void Property::ArenaDtor(void* object) {
  Property* _this = reinterpret_cast< Property* >(object);
  (void)_this;
}
void Property::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Property::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Property::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Property)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArena() == nullptr && value_ != nullptr) {
    delete value_;
  }
  value_ = nullptr;
  ::memset(&name_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&name_)) + sizeof(type_));
  _internal_metadata_.Clear<std::string>();
}

const char* Property::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          name_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Value value = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Property::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Property)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 name = 1;
  if (this->name() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_name(), target);
  }

  // int32 type = 2;
  if (this->type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_type(), target);
  }

  // .RedreamInfo.Value value = 3;
  if (this->has_value()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::value(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Property)
  return target;
}

size_t Property::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Property)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .RedreamInfo.Value value = 3;
  if (this->has_value()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *value_);
  }

  // int32 name = 1;
  if (this->name() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_name());
  }

  // int32 type = 2;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Property::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Property*>(
      &from));
}

void Property::MergeFrom(const Property& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Property)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_value()) {
    _internal_mutable_value()->::RedreamInfo::Value::MergeFrom(from._internal_value());
  }
  if (from.name() != 0) {
    _internal_set_name(from._internal_name());
  }
  if (from.type() != 0) {
    _internal_set_type(from._internal_type());
  }
}

void Property::CopyFrom(const Property& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Property)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Property::IsInitialized() const {
  return true;
}

void Property::InternalSwap(Property* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Property, type_)
      + sizeof(Property::type_)
      - PROTOBUF_FIELD_OFFSET(Property, value_)>(
          reinterpret_cast<char*>(&value_),
          reinterpret_cast<char*>(&other->value_));
}

std::string Property::GetTypeName() const {
  return "RedreamInfo.Property";
}


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

class CallbackKeyframe::_Internal {
 public:
};

CallbackKeyframe::CallbackKeyframe(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.CallbackKeyframe)
}
CallbackKeyframe::CallbackKeyframe(const CallbackKeyframe& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&time_, &from.time_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&time_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.CallbackKeyframe)
}

void CallbackKeyframe::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&time_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&time_)) + sizeof(type_));
}

CallbackKeyframe::~CallbackKeyframe() {
  // @@protoc_insertion_point(destructor:RedreamInfo.CallbackKeyframe)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void CallbackKeyframe::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void CallbackKeyframe::ArenaDtor(void* object) {
  CallbackKeyframe* _this = reinterpret_cast< CallbackKeyframe* >(object);
  (void)_this;
}
void CallbackKeyframe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CallbackKeyframe::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void CallbackKeyframe::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.CallbackKeyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&time_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&time_)) + sizeof(type_));
  _internal_metadata_.Clear<std::string>();
}

const char* CallbackKeyframe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // int32 name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          name_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* CallbackKeyframe::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.CallbackKeyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_time(), target);
  }

  // int32 name = 2;
  if (this->name() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_name(), target);
  }

  // int32 type = 3;
  if (this->type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.CallbackKeyframe)
  return target;
}

size_t CallbackKeyframe::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.CallbackKeyframe)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    total_size += 1 + 4;
  }

  // int32 name = 2;
  if (this->name() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_name());
  }

  // int32 type = 3;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CallbackKeyframe::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const CallbackKeyframe*>(
      &from));
}

void CallbackKeyframe::MergeFrom(const CallbackKeyframe& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.CallbackKeyframe)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.time() <= 0 && from.time() >= 0)) {
    _internal_set_time(from._internal_time());
  }
  if (from.name() != 0) {
    _internal_set_name(from._internal_name());
  }
  if (from.type() != 0) {
    _internal_set_type(from._internal_type());
  }
}

void CallbackKeyframe::CopyFrom(const CallbackKeyframe& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.CallbackKeyframe)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CallbackKeyframe::IsInitialized() const {
  return true;
}

void CallbackKeyframe::InternalSwap(CallbackKeyframe* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CallbackKeyframe, type_)
      + sizeof(CallbackKeyframe::type_)
      - PROTOBUF_FIELD_OFFSET(CallbackKeyframe, time_)>(
          reinterpret_cast<char*>(&time_),
          reinterpret_cast<char*>(&other->time_));
}

std::string CallbackKeyframe::GetTypeName() const {
  return "RedreamInfo.CallbackKeyframe";
}


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

class SoundKeyframe::_Internal {
 public:
};

SoundKeyframe::SoundKeyframe(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.SoundKeyframe)
}
SoundKeyframe::SoundKeyframe(const SoundKeyframe& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&time_, &from.time_,
    static_cast<size_t>(reinterpret_cast<char*>(&gain_) -
    reinterpret_cast<char*>(&time_)) + sizeof(gain_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.SoundKeyframe)
}

void SoundKeyframe::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&time_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&gain_) -
    reinterpret_cast<char*>(&time_)) + sizeof(gain_));
}

SoundKeyframe::~SoundKeyframe() {
  // @@protoc_insertion_point(destructor:RedreamInfo.SoundKeyframe)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void SoundKeyframe::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void SoundKeyframe::ArenaDtor(void* object) {
  SoundKeyframe* _this = reinterpret_cast< SoundKeyframe* >(object);
  (void)_this;
}
void SoundKeyframe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SoundKeyframe::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SoundKeyframe::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.SoundKeyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&time_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&gain_) -
      reinterpret_cast<char*>(&time_)) + sizeof(gain_));
  _internal_metadata_.Clear<std::string>();
}

const char* SoundKeyframe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // int32 soundFile = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          soundfile_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float pitch = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          pitch_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float pan = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          pan_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float gain = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          gain_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SoundKeyframe::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.SoundKeyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_time(), target);
  }

  // int32 soundFile = 2;
  if (this->soundfile() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_soundfile(), target);
  }

  // float pitch = 3;
  if (!(this->pitch() <= 0 && this->pitch() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_pitch(), target);
  }

  // float pan = 4;
  if (!(this->pan() <= 0 && this->pan() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_pan(), target);
  }

  // float gain = 5;
  if (!(this->gain() <= 0 && this->gain() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_gain(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.SoundKeyframe)
  return target;
}

size_t SoundKeyframe::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.SoundKeyframe)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    total_size += 1 + 4;
  }

  // int32 soundFile = 2;
  if (this->soundfile() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_soundfile());
  }

  // float pitch = 3;
  if (!(this->pitch() <= 0 && this->pitch() >= 0)) {
    total_size += 1 + 4;
  }

  // float pan = 4;
  if (!(this->pan() <= 0 && this->pan() >= 0)) {
    total_size += 1 + 4;
  }

  // float gain = 5;
  if (!(this->gain() <= 0 && this->gain() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SoundKeyframe::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SoundKeyframe*>(
      &from));
}

void SoundKeyframe::MergeFrom(const SoundKeyframe& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.SoundKeyframe)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.time() <= 0 && from.time() >= 0)) {
    _internal_set_time(from._internal_time());
  }
  if (from.soundfile() != 0) {
    _internal_set_soundfile(from._internal_soundfile());
  }
  if (!(from.pitch() <= 0 && from.pitch() >= 0)) {
    _internal_set_pitch(from._internal_pitch());
  }
  if (!(from.pan() <= 0 && from.pan() >= 0)) {
    _internal_set_pan(from._internal_pan());
  }
  if (!(from.gain() <= 0 && from.gain() >= 0)) {
    _internal_set_gain(from._internal_gain());
  }
}

void SoundKeyframe::CopyFrom(const SoundKeyframe& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.SoundKeyframe)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SoundKeyframe::IsInitialized() const {
  return true;
}

void SoundKeyframe::InternalSwap(SoundKeyframe* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SoundKeyframe, gain_)
      + sizeof(SoundKeyframe::gain_)
      - PROTOBUF_FIELD_OFFSET(SoundKeyframe, time_)>(
          reinterpret_cast<char*>(&time_),
          reinterpret_cast<char*>(&other->time_));
}

std::string SoundKeyframe::GetTypeName() const {
  return "RedreamInfo.SoundKeyframe";
}


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

class WiseKeyframeParam::_Internal {
 public:
};

WiseKeyframeParam::WiseKeyframeParam(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.WiseKeyframeParam)
}
WiseKeyframeParam::WiseKeyframeParam(const WiseKeyframeParam& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_key().empty()) {
    key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), 
      GetArena());
  }
  value_ = from.value_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.WiseKeyframeParam)
}

void WiseKeyframeParam::SharedCtor() {
key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
value_ = 0;
}

WiseKeyframeParam::~WiseKeyframeParam() {
  // @@protoc_insertion_point(destructor:RedreamInfo.WiseKeyframeParam)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void WiseKeyframeParam::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void WiseKeyframeParam::ArenaDtor(void* object) {
  WiseKeyframeParam* _this = reinterpret_cast< WiseKeyframeParam* >(object);
  (void)_this;
}
void WiseKeyframeParam::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void WiseKeyframeParam::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void WiseKeyframeParam::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.WiseKeyframeParam)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  key_.ClearToEmpty();
  value_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* WiseKeyframeParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* WiseKeyframeParam::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.WiseKeyframeParam)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string key = 1;
  if (this->key().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.WiseKeyframeParam.key");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_key(), target);
  }

  // float value = 2;
  if (!(this->value() <= 0 && this->value() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.WiseKeyframeParam)
  return target;
}

size_t WiseKeyframeParam::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.WiseKeyframeParam)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string key = 1;
  if (this->key().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_key());
  }

  // float value = 2;
  if (!(this->value() <= 0 && this->value() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void WiseKeyframeParam::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const WiseKeyframeParam*>(
      &from));
}

void WiseKeyframeParam::MergeFrom(const WiseKeyframeParam& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.WiseKeyframeParam)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.key().size() > 0) {
    _internal_set_key(from._internal_key());
  }
  if (!(from.value() <= 0 && from.value() >= 0)) {
    _internal_set_value(from._internal_value());
  }
}

void WiseKeyframeParam::CopyFrom(const WiseKeyframeParam& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.WiseKeyframeParam)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WiseKeyframeParam::IsInitialized() const {
  return true;
}

void WiseKeyframeParam::InternalSwap(WiseKeyframeParam* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(value_, other->value_);
}

std::string WiseKeyframeParam::GetTypeName() const {
  return "RedreamInfo.WiseKeyframeParam";
}


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

class WiseKeyframe::_Internal {
 public:
};

WiseKeyframe::WiseKeyframe(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  params_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.WiseKeyframe)
}
WiseKeyframe::WiseKeyframe(const WiseKeyframe& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      params_(from.params_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  bnk_file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_bnk_file_name().empty()) {
    bnk_file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_bnk_file_name(), 
      GetArena());
  }
  event_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_event_name().empty()) {
    event_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_event_name(), 
      GetArena());
  }
  ::memcpy(&time_, &from.time_,
    static_cast<size_t>(reinterpret_cast<char*>(&force_post_event_) -
    reinterpret_cast<char*>(&time_)) + sizeof(force_post_event_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.WiseKeyframe)
}

void WiseKeyframe::SharedCtor() {
bnk_file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
event_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&time_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&force_post_event_) -
    reinterpret_cast<char*>(&time_)) + sizeof(force_post_event_));
}

WiseKeyframe::~WiseKeyframe() {
  // @@protoc_insertion_point(destructor:RedreamInfo.WiseKeyframe)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void WiseKeyframe::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  bnk_file_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  event_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void WiseKeyframe::ArenaDtor(void* object) {
  WiseKeyframe* _this = reinterpret_cast< WiseKeyframe* >(object);
  (void)_this;
}
void WiseKeyframe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void WiseKeyframe::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void WiseKeyframe::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.WiseKeyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  params_.Clear();
  bnk_file_name_.ClearToEmpty();
  event_name_.ClearToEmpty();
  ::memset(&time_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&force_post_event_) -
      reinterpret_cast<char*>(&time_)) + sizeof(force_post_event_));
  _internal_metadata_.Clear<std::string>();
}

const char* WiseKeyframe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // string bnk_file_name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_bnk_file_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string event_name = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_event_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool force_post_event = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          force_post_event_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.WiseKeyframeParam params = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_params(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* WiseKeyframe::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.WiseKeyframe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_time(), target);
  }

  // string bnk_file_name = 2;
  if (this->bnk_file_name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_bnk_file_name().data(), static_cast<int>(this->_internal_bnk_file_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.WiseKeyframe.bnk_file_name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_bnk_file_name(), target);
  }

  // string event_name = 3;
  if (this->event_name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_event_name().data(), static_cast<int>(this->_internal_event_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.WiseKeyframe.event_name");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_event_name(), target);
  }

  // bool force_post_event = 4;
  if (this->force_post_event() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_force_post_event(), target);
  }

  // repeated .RedreamInfo.WiseKeyframeParam params = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_params_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_params(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.WiseKeyframe)
  return target;
}

size_t WiseKeyframe::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.WiseKeyframe)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.WiseKeyframeParam params = 5;
  total_size += 1UL * this->_internal_params_size();
  for (const auto& msg : this->params_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // string bnk_file_name = 2;
  if (this->bnk_file_name().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_bnk_file_name());
  }

  // string event_name = 3;
  if (this->event_name().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_event_name());
  }

  // float time = 1;
  if (!(this->time() <= 0 && this->time() >= 0)) {
    total_size += 1 + 4;
  }

  // bool force_post_event = 4;
  if (this->force_post_event() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void WiseKeyframe::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const WiseKeyframe*>(
      &from));
}

void WiseKeyframe::MergeFrom(const WiseKeyframe& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.WiseKeyframe)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  params_.MergeFrom(from.params_);
  if (from.bnk_file_name().size() > 0) {
    _internal_set_bnk_file_name(from._internal_bnk_file_name());
  }
  if (from.event_name().size() > 0) {
    _internal_set_event_name(from._internal_event_name());
  }
  if (!(from.time() <= 0 && from.time() >= 0)) {
    _internal_set_time(from._internal_time());
  }
  if (from.force_post_event() != 0) {
    _internal_set_force_post_event(from._internal_force_post_event());
  }
}

void WiseKeyframe::CopyFrom(const WiseKeyframe& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.WiseKeyframe)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WiseKeyframe::IsInitialized() const {
  return true;
}

void WiseKeyframe::InternalSwap(WiseKeyframe* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  params_.InternalSwap(&other->params_);
  bnk_file_name_.Swap(&other->bnk_file_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  event_name_.Swap(&other->event_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(WiseKeyframe, force_post_event_)
      + sizeof(WiseKeyframe::force_post_event_)
      - PROTOBUF_FIELD_OFFSET(WiseKeyframe, time_)>(
          reinterpret_cast<char*>(&time_),
          reinterpret_cast<char*>(&other->time_));
}

std::string WiseKeyframe::GetTypeName() const {
  return "RedreamInfo.WiseKeyframe";
}


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

class Sequences::_Internal {
 public:
};

Sequences::Sequences(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  callbackkeyframe_(arena),
  soundkeyframe_(arena),
  wisekeyframe_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Sequences)
}
Sequences::Sequences(const Sequences& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      callbackkeyframe_(from.callbackkeyframe_),
      soundkeyframe_(from.soundkeyframe_),
      wisekeyframe_(from.wisekeyframe_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&duration_, &from.duration_,
    static_cast<size_t>(reinterpret_cast<char*>(&chainedsequenceid_) -
    reinterpret_cast<char*>(&duration_)) + sizeof(chainedsequenceid_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Sequences)
}

void Sequences::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&duration_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&chainedsequenceid_) -
    reinterpret_cast<char*>(&duration_)) + sizeof(chainedsequenceid_));
}

Sequences::~Sequences() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Sequences)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Sequences::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Sequences::ArenaDtor(void* object) {
  Sequences* _this = reinterpret_cast< Sequences* >(object);
  (void)_this;
}
void Sequences::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Sequences::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Sequences::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Sequences)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  callbackkeyframe_.Clear();
  soundkeyframe_.Clear();
  wisekeyframe_.Clear();
  ::memset(&duration_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&chainedsequenceid_) -
      reinterpret_cast<char*>(&duration_)) + sizeof(chainedsequenceid_));
  _internal_metadata_.Clear<std::string>();
}

const char* Sequences::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float duration = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          duration_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // int32 name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          name_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 sequenceId = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          sequenceid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 chainedSequenceId = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          chainedsequenceid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.CallbackKeyframe callbackKeyframe = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_callbackkeyframe(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.SoundKeyframe soundKeyframe = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_soundkeyframe(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.WiseKeyframe wiseKeyFrame = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_wisekeyframe(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Sequences::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Sequences)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float duration = 1;
  if (!(this->duration() <= 0 && this->duration() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_duration(), target);
  }

  // int32 name = 2;
  if (this->name() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_name(), target);
  }

  // int32 sequenceId = 3;
  if (this->sequenceid() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_sequenceid(), target);
  }

  // int32 chainedSequenceId = 4;
  if (this->chainedsequenceid() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_chainedsequenceid(), target);
  }

  // repeated .RedreamInfo.CallbackKeyframe callbackKeyframe = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_callbackkeyframe_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_callbackkeyframe(i), target, stream);
  }

  // repeated .RedreamInfo.SoundKeyframe soundKeyframe = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_soundkeyframe_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_soundkeyframe(i), target, stream);
  }

  // repeated .RedreamInfo.WiseKeyframe wiseKeyFrame = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_wisekeyframe_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, this->_internal_wisekeyframe(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Sequences)
  return target;
}

size_t Sequences::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Sequences)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.CallbackKeyframe callbackKeyframe = 5;
  total_size += 1UL * this->_internal_callbackkeyframe_size();
  for (const auto& msg : this->callbackkeyframe_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .RedreamInfo.SoundKeyframe soundKeyframe = 6;
  total_size += 1UL * this->_internal_soundkeyframe_size();
  for (const auto& msg : this->soundkeyframe_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .RedreamInfo.WiseKeyframe wiseKeyFrame = 7;
  total_size += 1UL * this->_internal_wisekeyframe_size();
  for (const auto& msg : this->wisekeyframe_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // float duration = 1;
  if (!(this->duration() <= 0 && this->duration() >= 0)) {
    total_size += 1 + 4;
  }

  // int32 name = 2;
  if (this->name() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_name());
  }

  // int32 sequenceId = 3;
  if (this->sequenceid() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_sequenceid());
  }

  // int32 chainedSequenceId = 4;
  if (this->chainedsequenceid() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_chainedsequenceid());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Sequences::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Sequences*>(
      &from));
}

void Sequences::MergeFrom(const Sequences& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Sequences)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  callbackkeyframe_.MergeFrom(from.callbackkeyframe_);
  soundkeyframe_.MergeFrom(from.soundkeyframe_);
  wisekeyframe_.MergeFrom(from.wisekeyframe_);
  if (!(from.duration() <= 0 && from.duration() >= 0)) {
    _internal_set_duration(from._internal_duration());
  }
  if (from.name() != 0) {
    _internal_set_name(from._internal_name());
  }
  if (from.sequenceid() != 0) {
    _internal_set_sequenceid(from._internal_sequenceid());
  }
  if (from.chainedsequenceid() != 0) {
    _internal_set_chainedsequenceid(from._internal_chainedsequenceid());
  }
}

void Sequences::CopyFrom(const Sequences& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Sequences)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Sequences::IsInitialized() const {
  return true;
}

void Sequences::InternalSwap(Sequences* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  callbackkeyframe_.InternalSwap(&other->callbackkeyframe_);
  soundkeyframe_.InternalSwap(&other->soundkeyframe_);
  wisekeyframe_.InternalSwap(&other->wisekeyframe_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Sequences, chainedsequenceid_)
      + sizeof(Sequences::chainedsequenceid_)
      - PROTOBUF_FIELD_OFFSET(Sequences, duration_)>(
          reinterpret_cast<char*>(&duration_),
          reinterpret_cast<char*>(&other->duration_));
}

std::string Sequences::GetTypeName() const {
  return "RedreamInfo.Sequences";
}


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

class LocalizationModel::_Internal {
 public:
};

LocalizationModel::LocalizationModel(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.LocalizationModel)
}
LocalizationModel::LocalizationModel(const LocalizationModel& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  customfilepath_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_customfilepath().empty()) {
    customfilepath_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_customfilepath(), 
      GetArena());
  }
  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_key().empty()) {
    key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), 
      GetArena());
  }
  ::memcpy(&islocalization_, &from.islocalization_,
    static_cast<size_t>(reinterpret_cast<char*>(&iscustom_) -
    reinterpret_cast<char*>(&islocalization_)) + sizeof(iscustom_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.LocalizationModel)
}

void LocalizationModel::SharedCtor() {
customfilepath_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&islocalization_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&iscustom_) -
    reinterpret_cast<char*>(&islocalization_)) + sizeof(iscustom_));
}

LocalizationModel::~LocalizationModel() {
  // @@protoc_insertion_point(destructor:RedreamInfo.LocalizationModel)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void LocalizationModel::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  customfilepath_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void LocalizationModel::ArenaDtor(void* object) {
  LocalizationModel* _this = reinterpret_cast< LocalizationModel* >(object);
  (void)_this;
}
void LocalizationModel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LocalizationModel::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LocalizationModel::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.LocalizationModel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  customfilepath_.ClearToEmpty();
  key_.ClearToEmpty();
  ::memset(&islocalization_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&iscustom_) -
      reinterpret_cast<char*>(&islocalization_)) + sizeof(iscustom_));
  _internal_metadata_.Clear<std::string>();
}

const char* LocalizationModel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool isLocalization = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          islocalization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isCustom = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          iscustom_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string customFilePath = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_customfilepath();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string key = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* LocalizationModel::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.LocalizationModel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool isLocalization = 1;
  if (this->islocalization() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_islocalization(), target);
  }

  // bool isCustom = 2;
  if (this->iscustom() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_iscustom(), target);
  }

  // string customFilePath = 3;
  if (this->customfilepath().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_customfilepath().data(), static_cast<int>(this->_internal_customfilepath().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.LocalizationModel.customFilePath");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_customfilepath(), target);
  }

  // string key = 4;
  if (this->key().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.LocalizationModel.key");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_key(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.LocalizationModel)
  return target;
}

size_t LocalizationModel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.LocalizationModel)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string customFilePath = 3;
  if (this->customfilepath().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_customfilepath());
  }

  // string key = 4;
  if (this->key().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_key());
  }

  // bool isLocalization = 1;
  if (this->islocalization() != 0) {
    total_size += 1 + 1;
  }

  // bool isCustom = 2;
  if (this->iscustom() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LocalizationModel::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LocalizationModel*>(
      &from));
}

void LocalizationModel::MergeFrom(const LocalizationModel& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.LocalizationModel)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.customfilepath().size() > 0) {
    _internal_set_customfilepath(from._internal_customfilepath());
  }
  if (from.key().size() > 0) {
    _internal_set_key(from._internal_key());
  }
  if (from.islocalization() != 0) {
    _internal_set_islocalization(from._internal_islocalization());
  }
  if (from.iscustom() != 0) {
    _internal_set_iscustom(from._internal_iscustom());
  }
}

void LocalizationModel::CopyFrom(const LocalizationModel& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.LocalizationModel)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LocalizationModel::IsInitialized() const {
  return true;
}

void LocalizationModel::InternalSwap(LocalizationModel* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  customfilepath_.Swap(&other->customfilepath_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(LocalizationModel, iscustom_)
      + sizeof(LocalizationModel::iscustom_)
      - PROTOBUF_FIELD_OFFSET(LocalizationModel, islocalization_)>(
          reinterpret_cast<char*>(&islocalization_),
          reinterpret_cast<char*>(&other->islocalization_));
}

std::string LocalizationModel::GetTypeName() const {
  return "RedreamInfo.LocalizationModel";
}


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

MaterialBall_ParamsEntry_DoNotUse::MaterialBall_ParamsEntry_DoNotUse() {}
MaterialBall_ParamsEntry_DoNotUse::MaterialBall_ParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void MaterialBall_ParamsEntry_DoNotUse::MergeFrom(const MaterialBall_ParamsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

class MaterialBall::_Internal {
 public:
};

MaterialBall::MaterialBall(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  params_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.MaterialBall)
}
MaterialBall::MaterialBall(const MaterialBall& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  params_.MergeFrom(from.params_);
  materialballpath_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_materialballpath().empty()) {
    materialballpath_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_materialballpath(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.MaterialBall)
}

void MaterialBall::SharedCtor() {
materialballpath_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

MaterialBall::~MaterialBall() {
  // @@protoc_insertion_point(destructor:RedreamInfo.MaterialBall)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void MaterialBall::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  materialballpath_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void MaterialBall::ArenaDtor(void* object) {
  MaterialBall* _this = reinterpret_cast< MaterialBall* >(object);
  (void)_this;
}
void MaterialBall::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MaterialBall::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MaterialBall::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.MaterialBall)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  params_.Clear();
  materialballpath_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* MaterialBall::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string materialBallPath = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_materialballpath();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // map<string, float> params = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&params_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MaterialBall::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.MaterialBall)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string materialBallPath = 1;
  if (this->materialballpath().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_materialballpath().data(), static_cast<int>(this->_internal_materialballpath().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.MaterialBall.materialBallPath");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_materialballpath(), target);
  }

  // map<string, float> params = 2;
  if (!this->_internal_params().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, float >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "RedreamInfo.MaterialBall.ParamsEntry.key");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_params().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_params().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, float >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, float >::const_iterator
          it = this->_internal_params().begin();
          it != this->_internal_params().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = MaterialBall_ParamsEntry_DoNotUse::Funcs::InternalSerialize(2, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, float >::const_iterator
          it = this->_internal_params().begin();
          it != this->_internal_params().end(); ++it) {
        target = MaterialBall_ParamsEntry_DoNotUse::Funcs::InternalSerialize(2, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.MaterialBall)
  return target;
}

size_t MaterialBall::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.MaterialBall)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // map<string, float> params = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_params_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, float >::const_iterator
      it = this->_internal_params().begin();
      it != this->_internal_params().end(); ++it) {
    total_size += MaterialBall_ParamsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // string materialBallPath = 1;
  if (this->materialballpath().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_materialballpath());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MaterialBall::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MaterialBall*>(
      &from));
}

void MaterialBall::MergeFrom(const MaterialBall& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.MaterialBall)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  params_.MergeFrom(from.params_);
  if (from.materialballpath().size() > 0) {
    _internal_set_materialballpath(from._internal_materialballpath());
  }
}

void MaterialBall::CopyFrom(const MaterialBall& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.MaterialBall)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MaterialBall::IsInitialized() const {
  return true;
}

void MaterialBall::InternalSwap(MaterialBall* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  params_.Swap(&other->params_);
  materialballpath_.Swap(&other->materialballpath_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string MaterialBall::GetTypeName() const {
  return "RedreamInfo.MaterialBall";
}


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

class BakeAnimation::_Internal {
 public:
};

BakeAnimation::BakeAnimation(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.BakeAnimation)
}
BakeAnimation::BakeAnimation(const BakeAnimation& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  animationname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_animationname().empty()) {
    animationname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_animationname(), 
      GetArena());
  }
  ::memcpy(&elapsedtime_, &from.elapsedtime_,
    static_cast<size_t>(reinterpret_cast<char*>(&loop_) -
    reinterpret_cast<char*>(&elapsedtime_)) + sizeof(loop_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.BakeAnimation)
}

void BakeAnimation::SharedCtor() {
animationname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&elapsedtime_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&loop_) -
    reinterpret_cast<char*>(&elapsedtime_)) + sizeof(loop_));
}

BakeAnimation::~BakeAnimation() {
  // @@protoc_insertion_point(destructor:RedreamInfo.BakeAnimation)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void BakeAnimation::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  animationname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void BakeAnimation::ArenaDtor(void* object) {
  BakeAnimation* _this = reinterpret_cast< BakeAnimation* >(object);
  (void)_this;
}
void BakeAnimation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BakeAnimation::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BakeAnimation::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.BakeAnimation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  animationname_.ClearToEmpty();
  ::memset(&elapsedtime_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&loop_) -
      reinterpret_cast<char*>(&elapsedtime_)) + sizeof(loop_));
  _internal_metadata_.Clear<std::string>();
}

const char* BakeAnimation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string animationName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_animationname();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float elapsedTime = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          elapsedtime_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // bool loop = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          loop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BakeAnimation::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.BakeAnimation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string animationName = 1;
  if (this->animationname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_animationname().data(), static_cast<int>(this->_internal_animationname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.BakeAnimation.animationName");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_animationname(), target);
  }

  // float elapsedTime = 2;
  if (!(this->elapsedtime() <= 0 && this->elapsedtime() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_elapsedtime(), target);
  }

  // bool loop = 3;
  if (this->loop() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_loop(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.BakeAnimation)
  return target;
}

size_t BakeAnimation::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.BakeAnimation)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string animationName = 1;
  if (this->animationname().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_animationname());
  }

  // float elapsedTime = 2;
  if (!(this->elapsedtime() <= 0 && this->elapsedtime() >= 0)) {
    total_size += 1 + 4;
  }

  // bool loop = 3;
  if (this->loop() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BakeAnimation::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BakeAnimation*>(
      &from));
}

void BakeAnimation::MergeFrom(const BakeAnimation& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.BakeAnimation)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.animationname().size() > 0) {
    _internal_set_animationname(from._internal_animationname());
  }
  if (!(from.elapsedtime() <= 0 && from.elapsedtime() >= 0)) {
    _internal_set_elapsedtime(from._internal_elapsedtime());
  }
  if (from.loop() != 0) {
    _internal_set_loop(from._internal_loop());
  }
}

void BakeAnimation::CopyFrom(const BakeAnimation& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.BakeAnimation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BakeAnimation::IsInitialized() const {
  return true;
}

void BakeAnimation::InternalSwap(BakeAnimation* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  animationname_.Swap(&other->animationname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BakeAnimation, loop_)
      + sizeof(BakeAnimation::loop_)
      - PROTOBUF_FIELD_OFFSET(BakeAnimation, elapsedtime_)>(
          reinterpret_cast<char*>(&elapsedtime_),
          reinterpret_cast<char*>(&other->elapsedtime_));
}

std::string BakeAnimation::GetTypeName() const {
  return "RedreamInfo.BakeAnimation";
}


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

class WiseParam::_Internal {
 public:
};

WiseParam::WiseParam(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.WiseParam)
}
WiseParam::WiseParam(const WiseParam& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_key().empty()) {
    key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), 
      GetArena());
  }
  value_ = from.value_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.WiseParam)
}

void WiseParam::SharedCtor() {
key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
value_ = 0;
}

WiseParam::~WiseParam() {
  // @@protoc_insertion_point(destructor:RedreamInfo.WiseParam)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void WiseParam::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void WiseParam::ArenaDtor(void* object) {
  WiseParam* _this = reinterpret_cast< WiseParam* >(object);
  (void)_this;
}
void WiseParam::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void WiseParam::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void WiseParam::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.WiseParam)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  key_.ClearToEmpty();
  value_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* WiseParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* WiseParam::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.WiseParam)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string key = 1;
  if (this->key().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.WiseParam.key");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_key(), target);
  }

  // float value = 2;
  if (!(this->value() <= 0 && this->value() >= 0)) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.WiseParam)
  return target;
}

size_t WiseParam::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.WiseParam)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string key = 1;
  if (this->key().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_key());
  }

  // float value = 2;
  if (!(this->value() <= 0 && this->value() >= 0)) {
    total_size += 1 + 4;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void WiseParam::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const WiseParam*>(
      &from));
}

void WiseParam::MergeFrom(const WiseParam& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.WiseParam)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.key().size() > 0) {
    _internal_set_key(from._internal_key());
  }
  if (!(from.value() <= 0 && from.value() >= 0)) {
    _internal_set_value(from._internal_value());
  }
}

void WiseParam::CopyFrom(const WiseParam& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.WiseParam)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WiseParam::IsInitialized() const {
  return true;
}

void WiseParam::InternalSwap(WiseParam* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(value_, other->value_);
}

std::string WiseParam::GetTypeName() const {
  return "RedreamInfo.WiseParam";
}


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

class Wise::_Internal {
 public:
};

Wise::Wise(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  params_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Wise)
}
Wise::Wise(const Wise& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      params_(from.params_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  bnkfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_bnkfile().empty()) {
    bnkfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_bnkfile(), 
      GetArena());
  }
  eventname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_eventname().empty()) {
    eventname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_eventname(), 
      GetArena());
  }
  forcepost_ = from.forcepost_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Wise)
}

void Wise::SharedCtor() {
bnkfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
eventname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
forcepost_ = false;
}

Wise::~Wise() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Wise)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Wise::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  bnkfile_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  eventname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Wise::ArenaDtor(void* object) {
  Wise* _this = reinterpret_cast< Wise* >(object);
  (void)_this;
}
void Wise::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Wise::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Wise::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Wise)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  params_.Clear();
  bnkfile_.ClearToEmpty();
  eventname_.ClearToEmpty();
  forcepost_ = false;
  _internal_metadata_.Clear<std::string>();
}

const char* Wise::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string bnkFile = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_bnkfile();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string eventName = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_eventname();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool forcePost = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          forcepost_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.WiseParam params = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_params(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Wise::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Wise)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string bnkFile = 1;
  if (this->bnkfile().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_bnkfile().data(), static_cast<int>(this->_internal_bnkfile().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.Wise.bnkFile");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_bnkfile(), target);
  }

  // string eventName = 2;
  if (this->eventname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_eventname().data(), static_cast<int>(this->_internal_eventname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.Wise.eventName");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_eventname(), target);
  }

  // bool forcePost = 3;
  if (this->forcepost() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_forcepost(), target);
  }

  // repeated .RedreamInfo.WiseParam params = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_params_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_params(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Wise)
  return target;
}

size_t Wise::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Wise)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.WiseParam params = 4;
  total_size += 1UL * this->_internal_params_size();
  for (const auto& msg : this->params_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // string bnkFile = 1;
  if (this->bnkfile().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_bnkfile());
  }

  // string eventName = 2;
  if (this->eventname().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_eventname());
  }

  // bool forcePost = 3;
  if (this->forcepost() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Wise::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Wise*>(
      &from));
}

void Wise::MergeFrom(const Wise& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Wise)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  params_.MergeFrom(from.params_);
  if (from.bnkfile().size() > 0) {
    _internal_set_bnkfile(from._internal_bnkfile());
  }
  if (from.eventname().size() > 0) {
    _internal_set_eventname(from._internal_eventname());
  }
  if (from.forcepost() != 0) {
    _internal_set_forcepost(from._internal_forcepost());
  }
}

void Wise::CopyFrom(const Wise& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Wise)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Wise::IsInitialized() const {
  return true;
}

void Wise::InternalSwap(Wise* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  params_.InternalSwap(&other->params_);
  bnkfile_.Swap(&other->bnkfile_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  eventname_.Swap(&other->eventname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(forcepost_, other->forcepost_);
}

std::string Wise::GetTypeName() const {
  return "RedreamInfo.Wise";
}


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

class Node::_Internal {
 public:
};

Node::Node(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  sequences_(arena),
  property_(arena),
  customproperty_(arena),
  child_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Node)
}
Node::Node(const Node& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      sequences_(from.sequences_),
      property_(from.property_),
      customproperty_(from.customproperty_),
      child_(from.child_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&classname_, &from.classname_,
    static_cast<size_t>(reinterpret_cast<char*>(&baseclassname_) -
    reinterpret_cast<char*>(&classname_)) + sizeof(baseclassname_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Node)
}

void Node::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&classname_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&baseclassname_) -
    reinterpret_cast<char*>(&classname_)) + sizeof(baseclassname_));
}

Node::~Node() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Node)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Node::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Node::ArenaDtor(void* object) {
  Node* _this = reinterpret_cast< Node* >(object);
  (void)_this;
}
void Node::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Node::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Node::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Node)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  sequences_.Clear();
  property_.Clear();
  customproperty_.Clear();
  child_.Clear();
  ::memset(&classname_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&baseclassname_) -
      reinterpret_cast<char*>(&classname_)) + sizeof(baseclassname_));
  _internal_metadata_.Clear<std::string>();
}

const char* Node::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 className = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          classname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 memberVarAssignmentType = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          membervarassignmenttype_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 memberVarAssignmentName = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          membervarassignmentname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.SequencePropertyMap sequences = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_sequences(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.Property property = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_property(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.Property customProperty = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_customproperty(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      // int32 reboltId = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          reboltid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 reboltName = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          reboltname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 baseClassName = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          baseclassname_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.Node child = 101;
      case 101:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 2;
          do {
            ptr += 2;
            ptr = ctx->ParseMessage(_internal_add_child(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<810>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Node::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Node)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 className = 1;
  if (this->classname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_classname(), target);
  }

  // int32 memberVarAssignmentType = 2;
  if (this->membervarassignmenttype() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_membervarassignmenttype(), target);
  }

  // int32 memberVarAssignmentName = 3;
  if (this->membervarassignmentname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_membervarassignmentname(), target);
  }

  // repeated .RedreamInfo.SequencePropertyMap sequences = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_sequences_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_sequences(i), target, stream);
  }

  // repeated .RedreamInfo.Property property = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_property_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_property(i), target, stream);
  }

  // repeated .RedreamInfo.Property customProperty = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_customproperty_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_customproperty(i), target, stream);
  }

  // int32 reboltId = 8;
  if (this->reboltid() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_reboltid(), target);
  }

  // int32 reboltName = 9;
  if (this->reboltname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_reboltname(), target);
  }

  // int32 baseClassName = 10;
  if (this->baseclassname() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(10, this->_internal_baseclassname(), target);
  }

  // repeated .RedreamInfo.Node child = 101;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_child_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(101, this->_internal_child(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Node)
  return target;
}

size_t Node::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Node)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .RedreamInfo.SequencePropertyMap sequences = 4;
  total_size += 1UL * this->_internal_sequences_size();
  for (const auto& msg : this->sequences_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .RedreamInfo.Property property = 5;
  total_size += 1UL * this->_internal_property_size();
  for (const auto& msg : this->property_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .RedreamInfo.Property customProperty = 6;
  total_size += 1UL * this->_internal_customproperty_size();
  for (const auto& msg : this->customproperty_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .RedreamInfo.Node child = 101;
  total_size += 2UL * this->_internal_child_size();
  for (const auto& msg : this->child_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int32 className = 1;
  if (this->classname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_classname());
  }

  // int32 memberVarAssignmentType = 2;
  if (this->membervarassignmenttype() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_membervarassignmenttype());
  }

  // int32 memberVarAssignmentName = 3;
  if (this->membervarassignmentname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_membervarassignmentname());
  }

  // int32 reboltId = 8;
  if (this->reboltid() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_reboltid());
  }

  // int32 reboltName = 9;
  if (this->reboltname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_reboltname());
  }

  // int32 baseClassName = 10;
  if (this->baseclassname() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_baseclassname());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Node::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Node*>(
      &from));
}

void Node::MergeFrom(const Node& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Node)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  sequences_.MergeFrom(from.sequences_);
  property_.MergeFrom(from.property_);
  customproperty_.MergeFrom(from.customproperty_);
  child_.MergeFrom(from.child_);
  if (from.classname() != 0) {
    _internal_set_classname(from._internal_classname());
  }
  if (from.membervarassignmenttype() != 0) {
    _internal_set_membervarassignmenttype(from._internal_membervarassignmenttype());
  }
  if (from.membervarassignmentname() != 0) {
    _internal_set_membervarassignmentname(from._internal_membervarassignmentname());
  }
  if (from.reboltid() != 0) {
    _internal_set_reboltid(from._internal_reboltid());
  }
  if (from.reboltname() != 0) {
    _internal_set_reboltname(from._internal_reboltname());
  }
  if (from.baseclassname() != 0) {
    _internal_set_baseclassname(from._internal_baseclassname());
  }
}

void Node::CopyFrom(const Node& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Node)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Node::IsInitialized() const {
  return true;
}

void Node::InternalSwap(Node* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  sequences_.InternalSwap(&other->sequences_);
  property_.InternalSwap(&other->property_);
  customproperty_.InternalSwap(&other->customproperty_);
  child_.InternalSwap(&other->child_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Node, baseclassname_)
      + sizeof(Node::baseclassname_)
      - PROTOBUF_FIELD_OFFSET(Node, classname_)>(
          reinterpret_cast<char*>(&classname_),
          reinterpret_cast<char*>(&other->classname_));
}

std::string Node::GetTypeName() const {
  return "RedreamInfo.Node";
}


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

class Rebolt_ReboltTree::_Internal {
 public:
};

Rebolt_ReboltTree::Rebolt_ReboltTree(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Rebolt.ReboltTree)
}
Rebolt_ReboltTree::Rebolt_ReboltTree(const Rebolt_ReboltTree& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  treename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_treename().empty()) {
    treename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_treename(), 
      GetArena());
  }
  treetype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_treetype().empty()) {
    treetype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_treetype(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Rebolt.ReboltTree)
}

void Rebolt_ReboltTree::SharedCtor() {
treename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
treetype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Rebolt_ReboltTree::~Rebolt_ReboltTree() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Rebolt.ReboltTree)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Rebolt_ReboltTree::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  treename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  treetype_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Rebolt_ReboltTree::ArenaDtor(void* object) {
  Rebolt_ReboltTree* _this = reinterpret_cast< Rebolt_ReboltTree* >(object);
  (void)_this;
}
void Rebolt_ReboltTree::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Rebolt_ReboltTree::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Rebolt_ReboltTree::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Rebolt.ReboltTree)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  treename_.ClearToEmpty();
  treetype_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* Rebolt_ReboltTree::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string treeName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_treename();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string treeType = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_treetype();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Rebolt_ReboltTree::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Rebolt.ReboltTree)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string treeName = 1;
  if (this->treename().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_treename().data(), static_cast<int>(this->_internal_treename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.Rebolt.ReboltTree.treeName");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_treename(), target);
  }

  // string treeType = 2;
  if (this->treetype().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_treetype().data(), static_cast<int>(this->_internal_treetype().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.Rebolt.ReboltTree.treeType");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_treetype(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Rebolt.ReboltTree)
  return target;
}

size_t Rebolt_ReboltTree::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Rebolt.ReboltTree)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string treeName = 1;
  if (this->treename().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_treename());
  }

  // string treeType = 2;
  if (this->treetype().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_treetype());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Rebolt_ReboltTree::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Rebolt_ReboltTree*>(
      &from));
}

void Rebolt_ReboltTree::MergeFrom(const Rebolt_ReboltTree& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Rebolt.ReboltTree)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.treename().size() > 0) {
    _internal_set_treename(from._internal_treename());
  }
  if (from.treetype().size() > 0) {
    _internal_set_treetype(from._internal_treetype());
  }
}

void Rebolt_ReboltTree::CopyFrom(const Rebolt_ReboltTree& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Rebolt.ReboltTree)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Rebolt_ReboltTree::IsInitialized() const {
  return true;
}

void Rebolt_ReboltTree::InternalSwap(Rebolt_ReboltTree* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  treename_.Swap(&other->treename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  treetype_.Swap(&other->treetype_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string Rebolt_ReboltTree::GetTypeName() const {
  return "RedreamInfo.Rebolt.ReboltTree";
}


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

class Rebolt_FuncParamInfo::_Internal {
 public:
};

Rebolt_FuncParamInfo::Rebolt_FuncParamInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  boolkeys_(arena),
  stringkeys_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Rebolt.FuncParamInfo)
}
Rebolt_FuncParamInfo::Rebolt_FuncParamInfo(const Rebolt_FuncParamInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      boolkeys_(from.boolkeys_),
      stringkeys_(from.stringkeys_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Rebolt.FuncParamInfo)
}

void Rebolt_FuncParamInfo::SharedCtor() {
}

Rebolt_FuncParamInfo::~Rebolt_FuncParamInfo() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Rebolt.FuncParamInfo)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Rebolt_FuncParamInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Rebolt_FuncParamInfo::ArenaDtor(void* object) {
  Rebolt_FuncParamInfo* _this = reinterpret_cast< Rebolt_FuncParamInfo* >(object);
  (void)_this;
}
void Rebolt_FuncParamInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Rebolt_FuncParamInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Rebolt_FuncParamInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Rebolt.FuncParamInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  boolkeys_.Clear();
  stringkeys_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Rebolt_FuncParamInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string boolKeys = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_boolkeys();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated string stringKeys = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_stringkeys();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Rebolt_FuncParamInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Rebolt.FuncParamInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string boolKeys = 1;
  for (int i = 0, n = this->_internal_boolkeys_size(); i < n; i++) {
    const auto& s = this->_internal_boolkeys(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.Rebolt.FuncParamInfo.boolKeys");
    target = stream->WriteString(1, s, target);
  }

  // repeated string stringKeys = 2;
  for (int i = 0, n = this->_internal_stringkeys_size(); i < n; i++) {
    const auto& s = this->_internal_stringkeys(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.Rebolt.FuncParamInfo.stringKeys");
    target = stream->WriteString(2, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Rebolt.FuncParamInfo)
  return target;
}

size_t Rebolt_FuncParamInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Rebolt.FuncParamInfo)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string boolKeys = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(boolkeys_.size());
  for (int i = 0, n = boolkeys_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      boolkeys_.Get(i));
  }

  // repeated string stringKeys = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(stringkeys_.size());
  for (int i = 0, n = stringkeys_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      stringkeys_.Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Rebolt_FuncParamInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Rebolt_FuncParamInfo*>(
      &from));
}

void Rebolt_FuncParamInfo::MergeFrom(const Rebolt_FuncParamInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Rebolt.FuncParamInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  boolkeys_.MergeFrom(from.boolkeys_);
  stringkeys_.MergeFrom(from.stringkeys_);
}

void Rebolt_FuncParamInfo::CopyFrom(const Rebolt_FuncParamInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Rebolt.FuncParamInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Rebolt_FuncParamInfo::IsInitialized() const {
  return true;
}

void Rebolt_FuncParamInfo::InternalSwap(Rebolt_FuncParamInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  boolkeys_.InternalSwap(&other->boolkeys_);
  stringkeys_.InternalSwap(&other->stringkeys_);
}

std::string Rebolt_FuncParamInfo::GetTypeName() const {
  return "RedreamInfo.Rebolt.FuncParamInfo";
}


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

Rebolt_ReboltTreesEntry_DoNotUse::Rebolt_ReboltTreesEntry_DoNotUse() {}
Rebolt_ReboltTreesEntry_DoNotUse::Rebolt_ReboltTreesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void Rebolt_ReboltTreesEntry_DoNotUse::MergeFrom(const Rebolt_ReboltTreesEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

Rebolt_FuncParamIndexsEntry_DoNotUse::Rebolt_FuncParamIndexsEntry_DoNotUse() {}
Rebolt_FuncParamIndexsEntry_DoNotUse::Rebolt_FuncParamIndexsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void Rebolt_FuncParamIndexsEntry_DoNotUse::MergeFrom(const Rebolt_FuncParamIndexsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

Rebolt_GlobalMsgEntry_DoNotUse::Rebolt_GlobalMsgEntry_DoNotUse() {}
Rebolt_GlobalMsgEntry_DoNotUse::Rebolt_GlobalMsgEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void Rebolt_GlobalMsgEntry_DoNotUse::MergeFrom(const Rebolt_GlobalMsgEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

class Rebolt::_Internal {
 public:
};

Rebolt::Rebolt(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  rebolttrees_(arena),
  funcparamindexs_(arena),
  globalmsg_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.Rebolt)
}
Rebolt::Rebolt(const Rebolt& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  rebolttrees_.MergeFrom(from.rebolttrees_);
  funcparamindexs_.MergeFrom(from.funcparamindexs_);
  globalmsg_.MergeFrom(from.globalmsg_);
  isrebolted_ = from.isrebolted_;
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.Rebolt)
}

void Rebolt::SharedCtor() {
isrebolted_ = false;
}

Rebolt::~Rebolt() {
  // @@protoc_insertion_point(destructor:RedreamInfo.Rebolt)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Rebolt::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void Rebolt::ArenaDtor(void* object) {
  Rebolt* _this = reinterpret_cast< Rebolt* >(object);
  (void)_this;
}
void Rebolt::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Rebolt::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Rebolt::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.Rebolt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  rebolttrees_.Clear();
  funcparamindexs_.Clear();
  globalmsg_.Clear();
  isrebolted_ = false;
  _internal_metadata_.Clear<std::string>();
}

const char* Rebolt::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool isRebolted = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          isrebolted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // map<string, .RedreamInfo.Rebolt.ReboltTree> reboltTrees = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&rebolttrees_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // map<string, .RedreamInfo.Rebolt.FuncParamInfo> funcParamIndexs = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&funcparamindexs_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // map<string, string> globalMsg = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&globalmsg_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Rebolt::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.Rebolt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool isRebolted = 1;
  if (this->isrebolted() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_isrebolted(), target);
  }

  // map<string, .RedreamInfo.Rebolt.ReboltTree> reboltTrees = 2;
  if (!this->_internal_rebolttrees().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_ReboltTree >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "RedreamInfo.Rebolt.ReboltTreesEntry.key");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_rebolttrees().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_rebolttrees().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_ReboltTree >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_ReboltTree >::const_iterator
          it = this->_internal_rebolttrees().begin();
          it != this->_internal_rebolttrees().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = Rebolt_ReboltTreesEntry_DoNotUse::Funcs::InternalSerialize(2, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_ReboltTree >::const_iterator
          it = this->_internal_rebolttrees().begin();
          it != this->_internal_rebolttrees().end(); ++it) {
        target = Rebolt_ReboltTreesEntry_DoNotUse::Funcs::InternalSerialize(2, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  // map<string, .RedreamInfo.Rebolt.FuncParamInfo> funcParamIndexs = 3;
  if (!this->_internal_funcparamindexs().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_FuncParamInfo >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "RedreamInfo.Rebolt.FuncParamIndexsEntry.key");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_funcparamindexs().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_funcparamindexs().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_FuncParamInfo >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_FuncParamInfo >::const_iterator
          it = this->_internal_funcparamindexs().begin();
          it != this->_internal_funcparamindexs().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = Rebolt_FuncParamIndexsEntry_DoNotUse::Funcs::InternalSerialize(3, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_FuncParamInfo >::const_iterator
          it = this->_internal_funcparamindexs().begin();
          it != this->_internal_funcparamindexs().end(); ++it) {
        target = Rebolt_FuncParamIndexsEntry_DoNotUse::Funcs::InternalSerialize(3, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  // map<string, string> globalMsg = 4;
  if (!this->_internal_globalmsg().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "RedreamInfo.Rebolt.GlobalMsgEntry.key");
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), static_cast<int>(p->second.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "RedreamInfo.Rebolt.GlobalMsgEntry.value");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_globalmsg().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_globalmsg().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
          it = this->_internal_globalmsg().begin();
          it != this->_internal_globalmsg().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = Rebolt_GlobalMsgEntry_DoNotUse::Funcs::InternalSerialize(4, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
          it = this->_internal_globalmsg().begin();
          it != this->_internal_globalmsg().end(); ++it) {
        target = Rebolt_GlobalMsgEntry_DoNotUse::Funcs::InternalSerialize(4, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.Rebolt)
  return target;
}

size_t Rebolt::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.Rebolt)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // map<string, .RedreamInfo.Rebolt.ReboltTree> reboltTrees = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_rebolttrees_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_ReboltTree >::const_iterator
      it = this->_internal_rebolttrees().begin();
      it != this->_internal_rebolttrees().end(); ++it) {
    total_size += Rebolt_ReboltTreesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // map<string, .RedreamInfo.Rebolt.FuncParamInfo> funcParamIndexs = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_funcparamindexs_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::Rebolt_FuncParamInfo >::const_iterator
      it = this->_internal_funcparamindexs().begin();
      it != this->_internal_funcparamindexs().end(); ++it) {
    total_size += Rebolt_FuncParamIndexsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // map<string, string> globalMsg = 4;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_globalmsg_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
      it = this->_internal_globalmsg().begin();
      it != this->_internal_globalmsg().end(); ++it) {
    total_size += Rebolt_GlobalMsgEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // bool isRebolted = 1;
  if (this->isrebolted() != 0) {
    total_size += 1 + 1;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Rebolt::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Rebolt*>(
      &from));
}

void Rebolt::MergeFrom(const Rebolt& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.Rebolt)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  rebolttrees_.MergeFrom(from.rebolttrees_);
  funcparamindexs_.MergeFrom(from.funcparamindexs_);
  globalmsg_.MergeFrom(from.globalmsg_);
  if (from.isrebolted() != 0) {
    _internal_set_isrebolted(from._internal_isrebolted());
  }
}

void Rebolt::CopyFrom(const Rebolt& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.Rebolt)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Rebolt::IsInitialized() const {
  return true;
}

void Rebolt::InternalSwap(Rebolt* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  rebolttrees_.Swap(&other->rebolttrees_);
  funcparamindexs_.Swap(&other->funcparamindexs_);
  globalmsg_.Swap(&other->globalmsg_);
  swap(isrebolted_, other->isrebolted_);
}

std::string Rebolt::GetTypeName() const {
  return "RedreamInfo.Rebolt";
}


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

class BatchRed_TextureList::_Internal {
 public:
};

BatchRed_TextureList::BatchRed_TextureList(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  texturename_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.BatchRed.TextureList)
}
BatchRed_TextureList::BatchRed_TextureList(const BatchRed_TextureList& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      texturename_(from.texturename_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.BatchRed.TextureList)
}

void BatchRed_TextureList::SharedCtor() {
}

BatchRed_TextureList::~BatchRed_TextureList() {
  // @@protoc_insertion_point(destructor:RedreamInfo.BatchRed.TextureList)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void BatchRed_TextureList::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void BatchRed_TextureList::ArenaDtor(void* object) {
  BatchRed_TextureList* _this = reinterpret_cast< BatchRed_TextureList* >(object);
  (void)_this;
}
void BatchRed_TextureList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BatchRed_TextureList::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BatchRed_TextureList::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.BatchRed.TextureList)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  texturename_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* BatchRed_TextureList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string textureName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_texturename();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BatchRed_TextureList::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.BatchRed.TextureList)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string textureName = 1;
  for (int i = 0, n = this->_internal_texturename_size(); i < n; i++) {
    const auto& s = this->_internal_texturename(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.BatchRed.TextureList.textureName");
    target = stream->WriteString(1, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.BatchRed.TextureList)
  return target;
}

size_t BatchRed_TextureList::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.BatchRed.TextureList)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string textureName = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(texturename_.size());
  for (int i = 0, n = texturename_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      texturename_.Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BatchRed_TextureList::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BatchRed_TextureList*>(
      &from));
}

void BatchRed_TextureList::MergeFrom(const BatchRed_TextureList& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.BatchRed.TextureList)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  texturename_.MergeFrom(from.texturename_);
}

void BatchRed_TextureList::CopyFrom(const BatchRed_TextureList& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.BatchRed.TextureList)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BatchRed_TextureList::IsInitialized() const {
  return true;
}

void BatchRed_TextureList::InternalSwap(BatchRed_TextureList* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  texturename_.InternalSwap(&other->texturename_);
}

std::string BatchRed_TextureList::GetTypeName() const {
  return "RedreamInfo.BatchRed.TextureList";
}


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

BatchRed_FramesEntry_DoNotUse::BatchRed_FramesEntry_DoNotUse() {}
BatchRed_FramesEntry_DoNotUse::BatchRed_FramesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void BatchRed_FramesEntry_DoNotUse::MergeFrom(const BatchRed_FramesEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

class BatchRed::_Internal {
 public:
  static const ::RedreamInfo::BatchRed_TextureList& textures(const BatchRed* msg);
};

const ::RedreamInfo::BatchRed_TextureList&
BatchRed::_Internal::textures(const BatchRed* msg) {
  return *msg->textures_;
}
BatchRed::BatchRed(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  frames_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.BatchRed)
}
BatchRed::BatchRed(const BatchRed& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  frames_.MergeFrom(from.frames_);
  if (from._internal_has_textures()) {
    textures_ = new ::RedreamInfo::BatchRed_TextureList(*from.textures_);
  } else {
    textures_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.BatchRed)
}

void BatchRed::SharedCtor() {
textures_ = nullptr;
}

BatchRed::~BatchRed() {
  // @@protoc_insertion_point(destructor:RedreamInfo.BatchRed)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void BatchRed::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete textures_;
}

void BatchRed::ArenaDtor(void* object) {
  BatchRed* _this = reinterpret_cast< BatchRed* >(object);
  (void)_this;
}
void BatchRed::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BatchRed::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BatchRed::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.BatchRed)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  frames_.Clear();
  if (GetArena() == nullptr && textures_ != nullptr) {
    delete textures_;
  }
  textures_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* BatchRed::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // map<string, .RedreamInfo.BatchRed.TextureList> frames = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&frames_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.BatchRed.TextureList textures = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_textures(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BatchRed::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.BatchRed)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // map<string, .RedreamInfo.BatchRed.TextureList> frames = 1;
  if (!this->_internal_frames().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::BatchRed_TextureList >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "RedreamInfo.BatchRed.FramesEntry.key");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_frames().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_frames().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::BatchRed_TextureList >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::BatchRed_TextureList >::const_iterator
          it = this->_internal_frames().begin();
          it != this->_internal_frames().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = BatchRed_FramesEntry_DoNotUse::Funcs::InternalSerialize(1, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::BatchRed_TextureList >::const_iterator
          it = this->_internal_frames().begin();
          it != this->_internal_frames().end(); ++it) {
        target = BatchRed_FramesEntry_DoNotUse::Funcs::InternalSerialize(1, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  // .RedreamInfo.BatchRed.TextureList textures = 2;
  if (this->has_textures()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::textures(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.BatchRed)
  return target;
}

size_t BatchRed::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.BatchRed)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // map<string, .RedreamInfo.BatchRed.TextureList> frames = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_frames_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::RedreamInfo::BatchRed_TextureList >::const_iterator
      it = this->_internal_frames().begin();
      it != this->_internal_frames().end(); ++it) {
    total_size += BatchRed_FramesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // .RedreamInfo.BatchRed.TextureList textures = 2;
  if (this->has_textures()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *textures_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BatchRed::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BatchRed*>(
      &from));
}

void BatchRed::MergeFrom(const BatchRed& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.BatchRed)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  frames_.MergeFrom(from.frames_);
  if (from.has_textures()) {
    _internal_mutable_textures()->::RedreamInfo::BatchRed_TextureList::MergeFrom(from._internal_textures());
  }
}

void BatchRed::CopyFrom(const BatchRed& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.BatchRed)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BatchRed::IsInitialized() const {
  return true;
}

void BatchRed::InternalSwap(BatchRed* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  frames_.Swap(&other->frames_);
  swap(textures_, other->textures_);
}

std::string BatchRed::GetTypeName() const {
  return "RedreamInfo.BatchRed";
}


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

class RedFile::_Internal {
 public:
  static const ::RedreamInfo::Node& root(const RedFile* msg);
  static const ::RedreamInfo::Rebolt& rebolt(const RedFile* msg);
  static const ::RedreamInfo::BatchRed& batchred(const RedFile* msg);
};

const ::RedreamInfo::Node&
RedFile::_Internal::root(const RedFile* msg) {
  return *msg->root_;
}
const ::RedreamInfo::Rebolt&
RedFile::_Internal::rebolt(const RedFile* msg) {
  return *msg->rebolt_;
}
const ::RedreamInfo::BatchRed&
RedFile::_Internal::batchred(const RedFile* msg) {
  return *msg->batchred_;
}
RedFile::RedFile(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  stringcache_(arena),
  sequences_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RedreamInfo.RedFile)
}
RedFile::RedFile(const RedFile& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      stringcache_(from.stringcache_),
      sequences_(from.sequences_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_root()) {
    root_ = new ::RedreamInfo::Node(*from.root_);
  } else {
    root_ = nullptr;
  }
  if (from._internal_has_rebolt()) {
    rebolt_ = new ::RedreamInfo::Rebolt(*from.rebolt_);
  } else {
    rebolt_ = nullptr;
  }
  if (from._internal_has_batchred()) {
    batchred_ = new ::RedreamInfo::BatchRed(*from.batchred_);
  } else {
    batchred_ = nullptr;
  }
  ::memcpy(&version_, &from.version_,
    static_cast<size_t>(reinterpret_cast<char*>(&autoplaysequenceid_) -
    reinterpret_cast<char*>(&version_)) + sizeof(autoplaysequenceid_));
  // @@protoc_insertion_point(copy_constructor:RedreamInfo.RedFile)
}

void RedFile::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&root_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&autoplaysequenceid_) -
    reinterpret_cast<char*>(&root_)) + sizeof(autoplaysequenceid_));
}

RedFile::~RedFile() {
  // @@protoc_insertion_point(destructor:RedreamInfo.RedFile)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void RedFile::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete root_;
  if (this != internal_default_instance()) delete rebolt_;
  if (this != internal_default_instance()) delete batchred_;
}

void RedFile::ArenaDtor(void* object) {
  RedFile* _this = reinterpret_cast< RedFile* >(object);
  (void)_this;
}
void RedFile::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RedFile::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RedFile::Clear() {
// @@protoc_insertion_point(message_clear_start:RedreamInfo.RedFile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  stringcache_.Clear();
  sequences_.Clear();
  if (GetArena() == nullptr && root_ != nullptr) {
    delete root_;
  }
  root_ = nullptr;
  if (GetArena() == nullptr && rebolt_ != nullptr) {
    delete rebolt_;
  }
  rebolt_ = nullptr;
  if (GetArena() == nullptr && batchred_ != nullptr) {
    delete batchred_;
  }
  batchred_ = nullptr;
  ::memset(&version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&autoplaysequenceid_) -
      reinterpret_cast<char*>(&version_)) + sizeof(autoplaysequenceid_));
  _internal_metadata_.Clear<std::string>();
}

const char* RedFile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string stringCache = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_stringcache();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .RedreamInfo.Sequences sequences = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_sequences(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // int32 autoPlaySequenceId = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          autoplaysequenceid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Node root = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_root(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.Rebolt rebolt = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_rebolt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .RedreamInfo.BatchRed batchRed = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_batchred(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RedFile::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RedreamInfo.RedFile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 version = 1;
  if (this->version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_version(), target);
  }

  // repeated string stringCache = 2;
  for (int i = 0, n = this->_internal_stringcache_size(); i < n; i++) {
    const auto& s = this->_internal_stringcache(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "RedreamInfo.RedFile.stringCache");
    target = stream->WriteString(2, s, target);
  }

  // repeated .RedreamInfo.Sequences sequences = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_sequences_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_sequences(i), target, stream);
  }

  // int32 autoPlaySequenceId = 4;
  if (this->autoplaysequenceid() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_autoplaysequenceid(), target);
  }

  // .RedreamInfo.Node root = 5;
  if (this->has_root()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::root(this), target, stream);
  }

  // .RedreamInfo.Rebolt rebolt = 6;
  if (this->has_rebolt()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::rebolt(this), target, stream);
  }

  // .RedreamInfo.BatchRed batchRed = 7;
  if (this->has_batchred()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::batchred(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RedreamInfo.RedFile)
  return target;
}

size_t RedFile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RedreamInfo.RedFile)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string stringCache = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(stringcache_.size());
  for (int i = 0, n = stringcache_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      stringcache_.Get(i));
  }

  // repeated .RedreamInfo.Sequences sequences = 3;
  total_size += 1UL * this->_internal_sequences_size();
  for (const auto& msg : this->sequences_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .RedreamInfo.Node root = 5;
  if (this->has_root()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *root_);
  }

  // .RedreamInfo.Rebolt rebolt = 6;
  if (this->has_rebolt()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *rebolt_);
  }

  // .RedreamInfo.BatchRed batchRed = 7;
  if (this->has_batchred()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *batchred_);
  }

  // int32 version = 1;
  if (this->version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_version());
  }

  // int32 autoPlaySequenceId = 4;
  if (this->autoplaysequenceid() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_autoplaysequenceid());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RedFile::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RedFile*>(
      &from));
}

void RedFile::MergeFrom(const RedFile& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RedreamInfo.RedFile)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  stringcache_.MergeFrom(from.stringcache_);
  sequences_.MergeFrom(from.sequences_);
  if (from.has_root()) {
    _internal_mutable_root()->::RedreamInfo::Node::MergeFrom(from._internal_root());
  }
  if (from.has_rebolt()) {
    _internal_mutable_rebolt()->::RedreamInfo::Rebolt::MergeFrom(from._internal_rebolt());
  }
  if (from.has_batchred()) {
    _internal_mutable_batchred()->::RedreamInfo::BatchRed::MergeFrom(from._internal_batchred());
  }
  if (from.version() != 0) {
    _internal_set_version(from._internal_version());
  }
  if (from.autoplaysequenceid() != 0) {
    _internal_set_autoplaysequenceid(from._internal_autoplaysequenceid());
  }
}

void RedFile::CopyFrom(const RedFile& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RedreamInfo.RedFile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedFile::IsInitialized() const {
  return true;
}

void RedFile::InternalSwap(RedFile* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  stringcache_.InternalSwap(&other->stringcache_);
  sequences_.InternalSwap(&other->sequences_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RedFile, autoplaysequenceid_)
      + sizeof(RedFile::autoplaysequenceid_)
      - PROTOBUF_FIELD_OFFSET(RedFile, root_)>(
          reinterpret_cast<char*>(&root_),
          reinterpret_cast<char*>(&other->root_));
}

std::string RedFile::GetTypeName() const {
  return "RedreamInfo.RedFile";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace RedreamInfo
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::RedreamInfo::Value* Arena::CreateMaybeMessage< ::RedreamInfo::Value >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Value >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Position* Arena::CreateMaybeMessage< ::RedreamInfo::Position >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Position >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Size* Arena::CreateMaybeMessage< ::RedreamInfo::Size >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Size >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::SpriteFrame* Arena::CreateMaybeMessage< ::RedreamInfo::SpriteFrame >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::SpriteFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::FrameSet* Arena::CreateMaybeMessage< ::RedreamInfo::FrameSet >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::FrameSet >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Color3* Arena::CreateMaybeMessage< ::RedreamInfo::Color3 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Color3 >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Color4* Arena::CreateMaybeMessage< ::RedreamInfo::Color4 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Color4 >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Color4FVar* Arena::CreateMaybeMessage< ::RedreamInfo::Color4FVar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Color4FVar >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Flip* Arena::CreateMaybeMessage< ::RedreamInfo::Flip >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Flip >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Blendmode* Arena::CreateMaybeMessage< ::RedreamInfo::Blendmode >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Blendmode >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Block* Arena::CreateMaybeMessage< ::RedreamInfo::Block >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Block >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::BlockControl* Arena::CreateMaybeMessage< ::RedreamInfo::BlockControl >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::BlockControl >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Vec2* Arena::CreateMaybeMessage< ::RedreamInfo::Vec2 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Vec2 >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Vec3* Arena::CreateMaybeMessage< ::RedreamInfo::Vec3 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Vec3 >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::SkelFrame* Arena::CreateMaybeMessage< ::RedreamInfo::SkelFrame >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::SkelFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::MinMaxCurveData* Arena::CreateMaybeMessage< ::RedreamInfo::MinMaxCurveData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::MinMaxCurveData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::AnimationCurveData* Arena::CreateMaybeMessage< ::RedreamInfo::AnimationCurveData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::AnimationCurveData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::KeyframeData* Arena::CreateMaybeMessage< ::RedreamInfo::KeyframeData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::KeyframeData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::MinMaxGradientData* Arena::CreateMaybeMessage< ::RedreamInfo::MinMaxGradientData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::MinMaxGradientData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::GradientNEWData* Arena::CreateMaybeMessage< ::RedreamInfo::GradientNEWData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::GradientNEWData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Color3BData* Arena::CreateMaybeMessage< ::RedreamInfo::Color3BData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Color3BData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::AlphaData* Arena::CreateMaybeMessage< ::RedreamInfo::AlphaData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::AlphaData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::EmissionData* Arena::CreateMaybeMessage< ::RedreamInfo::EmissionData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::EmissionData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::BurstData* Arena::CreateMaybeMessage< ::RedreamInfo::BurstData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::BurstData >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Percent* Arena::CreateMaybeMessage< ::RedreamInfo::Percent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Percent >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Callbacks* Arena::CreateMaybeMessage< ::RedreamInfo::Callbacks >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Callbacks >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::SequencePropertyMap* Arena::CreateMaybeMessage< ::RedreamInfo::SequencePropertyMap >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::SequencePropertyMap >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::SequenceProperty* Arena::CreateMaybeMessage< ::RedreamInfo::SequenceProperty >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::SequenceProperty >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Keyframe* Arena::CreateMaybeMessage< ::RedreamInfo::Keyframe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Keyframe >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Easing* Arena::CreateMaybeMessage< ::RedreamInfo::Easing >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Easing >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::EasingOpt* Arena::CreateMaybeMessage< ::RedreamInfo::EasingOpt >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::EasingOpt >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Easing1fOpt* Arena::CreateMaybeMessage< ::RedreamInfo::Easing1fOpt >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Easing1fOpt >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Easing4fOpt* Arena::CreateMaybeMessage< ::RedreamInfo::Easing4fOpt >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Easing4fOpt >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Property* Arena::CreateMaybeMessage< ::RedreamInfo::Property >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Property >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::CallbackKeyframe* Arena::CreateMaybeMessage< ::RedreamInfo::CallbackKeyframe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::CallbackKeyframe >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::SoundKeyframe* Arena::CreateMaybeMessage< ::RedreamInfo::SoundKeyframe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::SoundKeyframe >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::WiseKeyframeParam* Arena::CreateMaybeMessage< ::RedreamInfo::WiseKeyframeParam >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::WiseKeyframeParam >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::WiseKeyframe* Arena::CreateMaybeMessage< ::RedreamInfo::WiseKeyframe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::WiseKeyframe >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Sequences* Arena::CreateMaybeMessage< ::RedreamInfo::Sequences >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Sequences >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::LocalizationModel* Arena::CreateMaybeMessage< ::RedreamInfo::LocalizationModel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::LocalizationModel >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::MaterialBall_ParamsEntry_DoNotUse* Arena::CreateMaybeMessage< ::RedreamInfo::MaterialBall_ParamsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::MaterialBall_ParamsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::MaterialBall* Arena::CreateMaybeMessage< ::RedreamInfo::MaterialBall >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::MaterialBall >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::BakeAnimation* Arena::CreateMaybeMessage< ::RedreamInfo::BakeAnimation >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::BakeAnimation >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::WiseParam* Arena::CreateMaybeMessage< ::RedreamInfo::WiseParam >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::WiseParam >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Wise* Arena::CreateMaybeMessage< ::RedreamInfo::Wise >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Wise >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Node* Arena::CreateMaybeMessage< ::RedreamInfo::Node >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Node >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Rebolt_ReboltTree* Arena::CreateMaybeMessage< ::RedreamInfo::Rebolt_ReboltTree >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Rebolt_ReboltTree >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Rebolt_FuncParamInfo* Arena::CreateMaybeMessage< ::RedreamInfo::Rebolt_FuncParamInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Rebolt_FuncParamInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Rebolt_ReboltTreesEntry_DoNotUse* Arena::CreateMaybeMessage< ::RedreamInfo::Rebolt_ReboltTreesEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Rebolt_ReboltTreesEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Rebolt_FuncParamIndexsEntry_DoNotUse* Arena::CreateMaybeMessage< ::RedreamInfo::Rebolt_FuncParamIndexsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Rebolt_FuncParamIndexsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Rebolt_GlobalMsgEntry_DoNotUse* Arena::CreateMaybeMessage< ::RedreamInfo::Rebolt_GlobalMsgEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Rebolt_GlobalMsgEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::Rebolt* Arena::CreateMaybeMessage< ::RedreamInfo::Rebolt >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::Rebolt >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::BatchRed_TextureList* Arena::CreateMaybeMessage< ::RedreamInfo::BatchRed_TextureList >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::BatchRed_TextureList >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::BatchRed_FramesEntry_DoNotUse* Arena::CreateMaybeMessage< ::RedreamInfo::BatchRed_FramesEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::BatchRed_FramesEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::BatchRed* Arena::CreateMaybeMessage< ::RedreamInfo::BatchRed >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::BatchRed >(arena);
}
template<> PROTOBUF_NOINLINE ::RedreamInfo::RedFile* Arena::CreateMaybeMessage< ::RedreamInfo::RedFile >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RedreamInfo::RedFile >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>