diff --git a/api/converter/from_pb.go b/api/converter/from_pb.go
index a1b3f623e..4f928573b 100644
--- a/api/converter/from_pb.go
+++ b/api/converter/from_pb.go
@@ -432,11 +432,11 @@ func fromStyle(pbStyle *api.Operation_Style) (*operations.Style, error) {
 	if err != nil {
 		return nil, err
 	}
-	from, err := fromTextNodePos(pbStyle.From)
+	from, err := fromTextNodeBoundary(pbStyle.From)
 	if err != nil {
 		return nil, err
 	}
-	to, err := fromTextNodePos(pbStyle.To)
+	to, err := fromTextNodeBoundary(pbStyle.To)
 	if err != nil {
 		return nil, err
 	}
@@ -580,6 +580,34 @@ func fromTextNodePos(
 	), nil
 }
 
+func fromTextNodeBoundary(
+	pbBoundary *api.TextNodeBoundary,
+) (*crdt.RGATreeSplitNodeBoundary, error) {
+	createdAt, err := fromTimeTicket(pbBoundary.CreatedAt)
+	if err != nil {
+		return nil, err
+	}
+
+	var boundaryType crdt.BoundaryType
+	switch pbType := pbBoundary.Type; pbType {
+	case api.BoundaryType_BOUNDARY_TYPE_BEFORE:
+		boundaryType = crdt.Before
+	case api.BoundaryType_BOUNDARY_TYPE_AFTER:
+		boundaryType = crdt.After
+	case api.BoundaryType_BOUNDARY_TYPE_START:
+		boundaryType = crdt.Start
+	case api.BoundaryType_BOUNDARY_TYPE_END:
+		boundaryType = crdt.End
+	default:
+		boundaryType = ""
+	}
+
+	return crdt.NewRGATreeSplitNodeBoundary(
+		crdt.NewRGATreeSplitNodeID(createdAt, int(pbBoundary.Offset)),
+		boundaryType,
+	), nil
+}
+
 // FromTreeNodes converts protobuf tree nodes to crdt.TreeNode. The last node
 // in the slice is the root node, because the slice is in post-order.
 func FromTreeNodes(pbNodes []*api.TreeNode) (*crdt.TreeNode, error) {
diff --git a/api/converter/to_pb.go b/api/converter/to_pb.go
index 7a603157e..a0c310501 100644
--- a/api/converter/to_pb.go
+++ b/api/converter/to_pb.go
@@ -355,8 +355,8 @@ func toStyle(style *operations.Style) (*api.Operation_Style_, error) {
 	return &api.Operation_Style_{
 		Style: &api.Operation_Style{
 			ParentCreatedAt:     ToTimeTicket(style.ParentCreatedAt()),
-			From:                toTextNodePos(style.From()),
-			To:                  toTextNodePos(style.To()),
+			From:                toTextNodeBoundary(style.From()),
+			To:                  toTextNodeBoundary(style.To()),
 			CreatedAtMapByActor: toCreatedAtMapByActor(style.CreatedAtMapByActor()),
 			Attributes:          style.Attributes(),
 			ExecutedAt:          ToTimeTicket(style.ExecutedAt()),
@@ -470,6 +470,40 @@ func toTextNodePos(pos *crdt.RGATreeSplitNodePos) *api.TextNodePos {
 	}
 }
 
+func toTextNodeBoundary(boundary *crdt.RGATreeSplitNodeBoundary) *api.TextNodeBoundary {
+	switch boundary.Type() {
+	case crdt.Before:
+		return &api.TextNodeBoundary{
+			CreatedAt: ToTimeTicket(boundary.ID().CreatedAt()),
+			Offset:    int32(boundary.ID().Offset()),
+			Type:      api.BoundaryType_BOUNDARY_TYPE_BEFORE,
+		}
+	case crdt.After:
+		return &api.TextNodeBoundary{
+			CreatedAt: ToTimeTicket(boundary.ID().CreatedAt()),
+			Offset:    int32(boundary.ID().Offset()),
+			Type:      api.BoundaryType_BOUNDARY_TYPE_AFTER,
+		}
+	case crdt.Start:
+		return &api.TextNodeBoundary{
+			CreatedAt: ToTimeTicket(boundary.ID().CreatedAt()),
+			Offset:    int32(boundary.ID().Offset()),
+			Type:      api.BoundaryType_BOUNDARY_TYPE_START,
+		}
+	case crdt.End:
+		return &api.TextNodeBoundary{
+			CreatedAt: ToTimeTicket(boundary.ID().CreatedAt()),
+			Offset:    int32(boundary.ID().Offset()),
+			Type:      api.BoundaryType_BOUNDARY_TYPE_END,
+		}
+	default:
+		return &api.TextNodeBoundary{
+			CreatedAt: ToTimeTicket(boundary.ID().CreatedAt()),
+			Offset:    int32(boundary.ID().Offset()),
+		}
+	}
+}
+
 func toCreatedAtMapByActor(
 	createdAtMapByActor map[string]*time.Ticket,
 ) map[string]*api.TimeTicket {
diff --git a/api/yorkie/v1/resources.pb.go b/api/yorkie/v1/resources.pb.go
index 77c2f9696..9c3dbd8c9 100644
--- a/api/yorkie/v1/resources.pb.go
+++ b/api/yorkie/v1/resources.pb.go
@@ -23,6 +23,37 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
+type BoundaryType int32
+
+const (
+	BoundaryType_BOUNDARY_TYPE_BEFORE BoundaryType = 0
+	BoundaryType_BOUNDARY_TYPE_AFTER  BoundaryType = 1
+	BoundaryType_BOUNDARY_TYPE_START  BoundaryType = 2
+	BoundaryType_BOUNDARY_TYPE_END    BoundaryType = 3
+)
+
+var BoundaryType_name = map[int32]string{
+	0: "BOUNDARY_TYPE_BEFORE",
+	1: "BOUNDARY_TYPE_AFTER",
+	2: "BOUNDARY_TYPE_START",
+	3: "BOUNDARY_TYPE_END",
+}
+
+var BoundaryType_value = map[string]int32{
+	"BOUNDARY_TYPE_BEFORE": 0,
+	"BOUNDARY_TYPE_AFTER":  1,
+	"BOUNDARY_TYPE_START":  2,
+	"BOUNDARY_TYPE_END":    3,
+}
+
+func (x BoundaryType) String() string {
+	return proto.EnumName(BoundaryType_name, int32(x))
+}
+
+func (BoundaryType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_36361b2f5d0f0896, []int{0}
+}
+
 type ValueType int32
 
 const (
@@ -81,7 +112,7 @@ func (x ValueType) String() string {
 }
 
 func (ValueType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_36361b2f5d0f0896, []int{0}
+	return fileDescriptor_36361b2f5d0f0896, []int{1}
 }
 
 type DocEventType int32
@@ -109,7 +140,7 @@ func (x DocEventType) String() string {
 }
 
 func (DocEventType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_36361b2f5d0f0896, []int{1}
+	return fileDescriptor_36361b2f5d0f0896, []int{2}
 }
 
 type PresenceChange_ChangeType int32
@@ -1073,8 +1104,8 @@ func (m *Operation_Select) GetExecutedAt() *TimeTicket {
 
 type Operation_Style struct {
 	ParentCreatedAt      *TimeTicket            `protobuf:"bytes,1,opt,name=parent_created_at,json=parentCreatedAt,proto3" json:"parent_created_at,omitempty"`
-	From                 *TextNodePos           `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
-	To                   *TextNodePos           `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
+	From                 *TextNodeBoundary      `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
+	To                   *TextNodeBoundary      `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
 	Attributes           map[string]string      `protobuf:"bytes,4,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	ExecutedAt           *TimeTicket            `protobuf:"bytes,5,opt,name=executed_at,json=executedAt,proto3" json:"executed_at,omitempty"`
 	CreatedAtMapByActor  map[string]*TimeTicket `protobuf:"bytes,6,rep,name=created_at_map_by_actor,json=createdAtMapByActor,proto3" json:"created_at_map_by_actor,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
@@ -1123,14 +1154,14 @@ func (m *Operation_Style) GetParentCreatedAt() *TimeTicket {
 	return nil
 }
 
-func (m *Operation_Style) GetFrom() *TextNodePos {
+func (m *Operation_Style) GetFrom() *TextNodeBoundary {
 	if m != nil {
 		return m.From
 	}
 	return nil
 }
 
-func (m *Operation_Style) GetTo() *TextNodePos {
+func (m *Operation_Style) GetTo() *TextNodeBoundary {
 	if m != nil {
 		return m.To
 	}
@@ -3211,6 +3242,69 @@ func (m *TextNodePos) GetRelativeOffset() int32 {
 	return 0
 }
 
+type TextNodeBoundary struct {
+	CreatedAt            *TimeTicket  `protobuf:"bytes,1,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
+	Offset               int32        `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
+	Type                 BoundaryType `protobuf:"varint,3,opt,name=type,proto3,enum=yorkie.v1.BoundaryType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *TextNodeBoundary) Reset()         { *m = TextNodeBoundary{} }
+func (m *TextNodeBoundary) String() string { return proto.CompactTextString(m) }
+func (*TextNodeBoundary) ProtoMessage()    {}
+func (*TextNodeBoundary) Descriptor() ([]byte, []int) {
+	return fileDescriptor_36361b2f5d0f0896, []int{24}
+}
+func (m *TextNodeBoundary) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TextNodeBoundary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TextNodeBoundary.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *TextNodeBoundary) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TextNodeBoundary.Merge(m, src)
+}
+func (m *TextNodeBoundary) XXX_Size() int {
+	return m.Size()
+}
+func (m *TextNodeBoundary) XXX_DiscardUnknown() {
+	xxx_messageInfo_TextNodeBoundary.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TextNodeBoundary proto.InternalMessageInfo
+
+func (m *TextNodeBoundary) GetCreatedAt() *TimeTicket {
+	if m != nil {
+		return m.CreatedAt
+	}
+	return nil
+}
+
+func (m *TextNodeBoundary) GetOffset() int32 {
+	if m != nil {
+		return m.Offset
+	}
+	return 0
+}
+
+func (m *TextNodeBoundary) GetType() BoundaryType {
+	if m != nil {
+		return m.Type
+	}
+	return BoundaryType_BOUNDARY_TYPE_BEFORE
+}
+
 type TimeTicket struct {
 	Lamport              int64    `protobuf:"varint,1,opt,name=lamport,proto3" json:"lamport,omitempty"`
 	Delimiter            uint32   `protobuf:"varint,2,opt,name=delimiter,proto3" json:"delimiter,omitempty"`
@@ -3224,7 +3318,7 @@ func (m *TimeTicket) Reset()         { *m = TimeTicket{} }
 func (m *TimeTicket) String() string { return proto.CompactTextString(m) }
 func (*TimeTicket) ProtoMessage()    {}
 func (*TimeTicket) Descriptor() ([]byte, []int) {
-	return fileDescriptor_36361b2f5d0f0896, []int{24}
+	return fileDescriptor_36361b2f5d0f0896, []int{25}
 }
 func (m *TimeTicket) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3286,7 +3380,7 @@ func (m *DocEvent) Reset()         { *m = DocEvent{} }
 func (m *DocEvent) String() string { return proto.CompactTextString(m) }
 func (*DocEvent) ProtoMessage()    {}
 func (*DocEvent) Descriptor() ([]byte, []int) {
-	return fileDescriptor_36361b2f5d0f0896, []int{25}
+	return fileDescriptor_36361b2f5d0f0896, []int{26}
 }
 func (m *DocEvent) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3330,6 +3424,7 @@ func (m *DocEvent) GetPublisher() string {
 }
 
 func init() {
+	proto.RegisterEnum("yorkie.v1.BoundaryType", BoundaryType_name, BoundaryType_value)
 	proto.RegisterEnum("yorkie.v1.ValueType", ValueType_name, ValueType_value)
 	proto.RegisterEnum("yorkie.v1.DocEventType", DocEventType_name, DocEventType_value)
 	proto.RegisterEnum("yorkie.v1.PresenceChange_ChangeType", PresenceChange_ChangeType_name, PresenceChange_ChangeType_value)
@@ -3384,6 +3479,7 @@ func init() {
 	proto.RegisterMapType((map[string]string)(nil), "yorkie.v1.Presence.DataEntry")
 	proto.RegisterType((*Checkpoint)(nil), "yorkie.v1.Checkpoint")
 	proto.RegisterType((*TextNodePos)(nil), "yorkie.v1.TextNodePos")
+	proto.RegisterType((*TextNodeBoundary)(nil), "yorkie.v1.TextNodeBoundary")
 	proto.RegisterType((*TimeTicket)(nil), "yorkie.v1.TimeTicket")
 	proto.RegisterType((*DocEvent)(nil), "yorkie.v1.DocEvent")
 }
@@ -3391,171 +3487,177 @@ func init() {
 func init() { proto.RegisterFile("yorkie/v1/resources.proto", fileDescriptor_36361b2f5d0f0896) }
 
 var fileDescriptor_36361b2f5d0f0896 = []byte{
-	// 2620 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xdb, 0x6f, 0xdb, 0xc8,
-	0xd5, 0x37, 0x29, 0xea, 0xc2, 0xe3, 0xc4, 0x56, 0xc6, 0xb9, 0x28, 0x4a, 0xe2, 0x4d, 0xb4, 0xdf,
-	0xee, 0xe7, 0x4d, 0x5a, 0xf9, 0xb2, 0x97, 0x6e, 0x77, 0x9b, 0xb6, 0xb2, 0xc4, 0xc4, 0xca, 0x3a,
-	0xb2, 0x4b, 0xc9, 0xd9, 0x66, 0xd1, 0x82, 0xa0, 0xc9, 0xb1, 0xcd, 0xb5, 0x44, 0x6a, 0x49, 0x4a,
-	0x1b, 0x01, 0x05, 0x0a, 0x14, 0x2d, 0xd0, 0xd7, 0xbe, 0xf5, 0x5f, 0x28, 0x0a, 0xf4, 0x7d, 0x1f,
-	0xdb, 0x87, 0xa2, 0x40, 0x51, 0x74, 0x81, 0x2e, 0xd0, 0xd7, 0x36, 0xfb, 0x50, 0xb4, 0x6f, 0x45,
-	0x81, 0xbe, 0x15, 0x28, 0xe6, 0x42, 0x8a, 0x92, 0x28, 0x59, 0xd6, 0x3a, 0x8b, 0x04, 0x7d, 0xe3,
-	0xcc, 0xfc, 0xce, 0xcc, 0x39, 0x73, 0x7e, 0x67, 0xe6, 0x0c, 0x67, 0xe0, 0x6a, 0xcf, 0x71, 0x8f,
-	0x2d, 0xbc, 0xda, 0x5d, 0x5f, 0x75, 0xb1, 0xe7, 0x74, 0x5c, 0x03, 0x7b, 0xc5, 0xb6, 0xeb, 0xf8,
-	0x0e, 0x92, 0x59, 0x53, 0xb1, 0xbb, 0x9e, 0x7f, 0xe9, 0xd0, 0x71, 0x0e, 0x9b, 0x78, 0x95, 0x36,
-	0xec, 0x77, 0x0e, 0x56, 0x7d, 0xab, 0x85, 0x3d, 0x5f, 0x6f, 0xb5, 0x19, 0x36, 0xbf, 0x3c, 0x0c,
-	0xf8, 0xd8, 0xd5, 0xdb, 0x6d, 0xec, 0xf2, 0xbe, 0x0a, 0xbf, 0x17, 0x20, 0x53, 0xb7, 0xf5, 0xb6,
-	0x77, 0xe4, 0xf8, 0xe8, 0x36, 0x48, 0xae, 0xe3, 0xf8, 0x39, 0xe1, 0xa6, 0xb0, 0x32, 0xbf, 0x71,
-	0xb9, 0x18, 0x8e, 0x53, 0x7c, 0x50, 0xdf, 0xa9, 0x29, 0x4d, 0xdc, 0xc2, 0xb6, 0xaf, 0x52, 0x0c,
-	0xfa, 0x36, 0xc8, 0x6d, 0x17, 0x7b, 0xd8, 0x36, 0xb0, 0x97, 0x13, 0x6f, 0x26, 0x56, 0xe6, 0x37,
-	0x0a, 0x11, 0x81, 0xa0, 0xcf, 0xe2, 0x6e, 0x00, 0x52, 0x6c, 0xdf, 0xed, 0xa9, 0x7d, 0xa1, 0xfc,
-	0x77, 0x60, 0x61, 0xb0, 0x11, 0x65, 0x21, 0x71, 0x8c, 0x7b, 0x74, 0x78, 0x59, 0x25, 0x9f, 0xe8,
-	0x35, 0x48, 0x76, 0xf5, 0x66, 0x07, 0xe7, 0x44, 0xaa, 0xd2, 0x52, 0x64, 0x84, 0x40, 0x56, 0x65,
-	0x88, 0x77, 0xc4, 0xb7, 0x85, 0xc2, 0xcf, 0x44, 0x80, 0xf2, 0x91, 0x6e, 0x1f, 0xe2, 0x5d, 0xdd,
-	0x38, 0x46, 0xb7, 0xe0, 0x9c, 0xe9, 0x18, 0x1d, 0xa2, 0xb5, 0xd6, 0xef, 0x78, 0x3e, 0xa8, 0x7b,
-	0x0f, 0xf7, 0xd0, 0x9b, 0x00, 0xc6, 0x11, 0x36, 0x8e, 0xdb, 0x8e, 0x65, 0xfb, 0x7c, 0x94, 0x4b,
-	0x91, 0x51, 0xca, 0x61, 0xa3, 0x1a, 0x01, 0xa2, 0x3c, 0x64, 0x3c, 0x6e, 0x61, 0x2e, 0x71, 0x53,
-	0x58, 0x39, 0xa7, 0x86, 0x65, 0x74, 0x07, 0xd2, 0x06, 0xd5, 0xc1, 0xcb, 0x49, 0x74, 0x5e, 0x2e,
-	0x0c, 0xf4, 0x47, 0x5a, 0xd4, 0x00, 0x81, 0x4a, 0x70, 0xa1, 0x65, 0xd9, 0x9a, 0xd7, 0xb3, 0x0d,
-	0x6c, 0x6a, 0xbe, 0x65, 0x1c, 0x63, 0x3f, 0x97, 0x1c, 0x51, 0xa3, 0x61, 0xb5, 0x70, 0x83, 0x36,
-	0xaa, 0x8b, 0x2d, 0xcb, 0xae, 0x53, 0x38, 0xab, 0x40, 0x37, 0x00, 0x2c, 0x4f, 0x73, 0x71, 0xcb,
-	0xe9, 0x62, 0x33, 0x97, 0xba, 0x29, 0xac, 0x64, 0x54, 0xd9, 0xf2, 0x54, 0x56, 0x51, 0xf8, 0xb5,
-	0x00, 0x29, 0x36, 0x2a, 0x7a, 0x19, 0x44, 0xcb, 0xe4, 0xde, 0x5d, 0x1a, 0x51, 0xaa, 0x5a, 0x51,
-	0x45, 0xcb, 0x44, 0x39, 0x48, 0xb7, 0xb0, 0xe7, 0xe9, 0x87, 0x6c, 0xd2, 0x65, 0x35, 0x28, 0xa2,
-	0x37, 0x00, 0x9c, 0x36, 0x76, 0x75, 0xdf, 0x72, 0x6c, 0x2f, 0x97, 0xa0, 0xb6, 0x5d, 0x8c, 0x74,
-	0xb3, 0x13, 0x34, 0xaa, 0x11, 0x1c, 0xda, 0x84, 0xc5, 0xc0, 0xe7, 0x1a, 0xb3, 0x3a, 0x27, 0x51,
-	0x0d, 0xae, 0xc6, 0x38, 0x93, 0x4f, 0xcf, 0x42, 0x7b, 0xa0, 0x5c, 0xf8, 0x89, 0x00, 0x99, 0x40,
-	0x49, 0x62, 0xaf, 0xd1, 0xb4, 0x88, 0x4f, 0x3d, 0xfc, 0x11, 0xb5, 0xe6, 0xbc, 0x2a, 0xb3, 0x9a,
-	0x3a, 0xfe, 0x08, 0xdd, 0x02, 0xf0, 0xb0, 0xdb, 0xc5, 0x2e, 0x6d, 0x26, 0x26, 0x24, 0x36, 0xc5,
-	0x35, 0x41, 0x95, 0x59, 0x2d, 0x81, 0x5c, 0x87, 0x74, 0x53, 0x6f, 0xb5, 0x1d, 0x97, 0x39, 0x8f,
-	0xb5, 0x07, 0x55, 0xe8, 0x2a, 0x64, 0x74, 0xc3, 0x77, 0x5c, 0xcd, 0x32, 0xa9, 0xa6, 0xe7, 0xd4,
-	0x34, 0x2d, 0x57, 0xcd, 0xc2, 0xe7, 0x37, 0x40, 0x0e, 0xad, 0x44, 0x5f, 0x81, 0x84, 0x87, 0x83,
-	0x68, 0xc9, 0xc5, 0x4d, 0x44, 0xb1, 0x8e, 0xfd, 0xad, 0x39, 0x95, 0xc0, 0x08, 0x5a, 0x37, 0x4d,
-	0x4e, 0xb1, 0x78, 0x74, 0xc9, 0x34, 0x09, 0x5a, 0x37, 0x4d, 0xb4, 0x0a, 0x12, 0x71, 0x1f, 0xd5,
-	0x6f, 0x70, 0xaa, 0xfa, 0xf0, 0x87, 0x4e, 0x17, 0x6f, 0xcd, 0xa9, 0x14, 0x88, 0xde, 0x84, 0x14,
-	0xa3, 0x00, 0x9f, 0xdd, 0x6b, 0xb1, 0x22, 0x8c, 0x14, 0x5b, 0x73, 0x2a, 0x07, 0x93, 0x71, 0xb0,
-	0x69, 0x05, 0x94, 0x8b, 0x1f, 0x47, 0x31, 0x2d, 0x62, 0x05, 0x05, 0x92, 0x71, 0x3c, 0xdc, 0xc4,
-	0x86, 0x4f, 0x99, 0x36, 0x6e, 0x9c, 0x3a, 0x85, 0x90, 0x71, 0x18, 0x18, 0x6d, 0x40, 0xd2, 0xf3,
-	0x7b, 0x4d, 0x9c, 0x4b, 0x53, 0xa9, 0x7c, 0xbc, 0x14, 0x41, 0x6c, 0xcd, 0xa9, 0x0c, 0x8a, 0xde,
-	0x85, 0x8c, 0x65, 0x1b, 0x2e, 0xd6, 0x3d, 0x9c, 0xcb, 0x50, 0xb1, 0x1b, 0xb1, 0x62, 0x55, 0x0e,
-	0xda, 0x9a, 0x53, 0x43, 0x01, 0xf4, 0x0d, 0x90, 0x7d, 0x17, 0x63, 0x8d, 0x5a, 0x27, 0x4f, 0x90,
-	0x6e, 0xb8, 0x18, 0x73, 0x0b, 0x33, 0x3e, 0xff, 0x46, 0xdf, 0x02, 0xa0, 0xd2, 0x4c, 0x67, 0xa0,
-	0xe2, 0xcb, 0x63, 0xc5, 0x03, 0xbd, 0xe9, 0x88, 0xb4, 0x90, 0xff, 0xad, 0x00, 0x89, 0x3a, 0xf6,
-	0x49, 0x7c, 0xb7, 0x75, 0x97, 0x90, 0x95, 0xe8, 0xe5, 0x63, 0x53, 0xd3, 0x03, 0xc6, 0x8c, 0x8b,
-	0x6f, 0x86, 0x2f, 0x33, 0x78, 0xc9, 0x0f, 0x56, 0x45, 0xb1, 0xbf, 0x2a, 0x6e, 0x04, 0xab, 0x22,
-	0x63, 0xc7, 0xf5, 0xf8, 0x85, 0xba, 0x6e, 0xb5, 0xda, 0xcd, 0x60, 0x79, 0x44, 0x6f, 0xc1, 0x3c,
-	0x7e, 0x82, 0x8d, 0x0e, 0x57, 0x41, 0x9a, 0xa4, 0x02, 0x04, 0xc8, 0x92, 0x9f, 0xff, 0x97, 0x00,
-	0x89, 0x92, 0x69, 0x9e, 0x85, 0x21, 0x77, 0xe9, 0x4a, 0xd0, 0x8d, 0x76, 0x20, 0x4e, 0xea, 0xe0,
-	0x3c, 0x41, 0xf7, 0xc5, 0xbf, 0x4c, 0xab, 0xff, 0x2d, 0x80, 0x44, 0xc2, 0xeb, 0x39, 0x30, 0xfb,
-	0x0d, 0x80, 0x88, 0x64, 0x62, 0x92, 0xa4, 0x6c, 0x84, 0x52, 0xb3, 0x1a, 0xfe, 0x89, 0x00, 0x29,
-	0xb6, 0x48, 0x9c, 0x85, 0xe9, 0x83, 0xba, 0x8b, 0xb3, 0xe9, 0x9e, 0x98, 0x56, 0xf7, 0xdf, 0x48,
-	0x20, 0xd1, 0xe8, 0x3d, 0x03, 0xcd, 0x6f, 0x83, 0x74, 0xe0, 0x3a, 0x2d, 0xae, 0x73, 0x34, 0x15,
-	0x6a, 0xe0, 0x27, 0x7e, 0xcd, 0x31, 0xf1, 0xae, 0xe3, 0xa9, 0x14, 0x83, 0x5e, 0x05, 0xd1, 0x77,
-	0xb8, 0x9a, 0xe3, 0x90, 0xa2, 0xef, 0xa0, 0x23, 0xb8, 0xd2, 0xd7, 0x47, 0x6b, 0xe9, 0x6d, 0x6d,
-	0xbf, 0xa7, 0xd1, 0xad, 0x85, 0x27, 0x0a, 0x1b, 0x63, 0x97, 0xdf, 0x62, 0xa8, 0xd9, 0x43, 0xbd,
-	0xbd, 0xd9, 0x2b, 0x11, 0x21, 0x96, 0x50, 0x2d, 0x19, 0xa3, 0x2d, 0x64, 0x0f, 0x37, 0x1c, 0xdb,
-	0xc7, 0x36, 0x5b, 0xd8, 0x65, 0x35, 0x28, 0x0e, 0xcf, 0x6d, 0x6a, 0xca, 0xb9, 0x45, 0x55, 0x00,
-	0xdd, 0xf7, 0x5d, 0x6b, 0xbf, 0xe3, 0x63, 0x2f, 0x97, 0xa6, 0xea, 0xbe, 0x36, 0x5e, 0xdd, 0x52,
-	0x88, 0x65, 0x5a, 0x46, 0x84, 0xf3, 0xdf, 0x87, 0xdc, 0x38, 0x6b, 0x62, 0x32, 0xc0, 0x3b, 0x83,
-	0x19, 0xe0, 0x18, 0x55, 0xfb, 0x39, 0x60, 0xfe, 0x2e, 0x2c, 0x0e, 0x8d, 0x1e, 0xd3, 0xeb, 0xc5,
-	0x68, 0xaf, 0x72, 0x54, 0xfc, 0xcf, 0x02, 0xa4, 0xd8, 0xee, 0xf5, 0xbc, 0xd2, 0x68, 0xd6, 0xd0,
-	0xfe, 0xa5, 0x04, 0x49, 0xba, 0x39, 0x3d, 0xaf, 0x86, 0x3d, 0x18, 0xe0, 0x18, 0x0b, 0x89, 0xdb,
-	0xe3, 0x13, 0x85, 0x49, 0x24, 0x1b, 0x9e, 0xa4, 0xe4, 0xb4, 0x3c, 0xb7, 0xc6, 0xc7, 0x68, 0x8a,
-	0x2a, 0xf4, 0xfa, 0x04, 0x85, 0x4e, 0x15, 0xa4, 0x5f, 0x94, 0xa8, 0xcf, 0x38, 0x8c, 0x3e, 0x11,
-	0x20, 0x13, 0x24, 0x56, 0x67, 0x41, 0x98, 0x8d, 0x41, 0x05, 0x66, 0xd9, 0xbd, 0xa7, 0xde, 0x08,
-	0x3e, 0x4d, 0x40, 0x26, 0x48, 0xeb, 0xce, 0x42, 0xf7, 0x57, 0x07, 0xc8, 0x8e, 0xa2, 0x52, 0x2e,
-	0x8e, 0x10, 0xbd, 0x10, 0x21, 0x7a, 0x1c, 0x8a, 0x90, 0xbc, 0x79, 0xd2, 0x26, 0xf0, 0xd6, 0xc4,
-	0x2c, 0xf5, 0x94, 0x1b, 0xc1, 0x1a, 0x64, 0xf8, 0xca, 0xef, 0xe5, 0x92, 0x23, 0x07, 0x36, 0xd2,
-	0x29, 0x09, 0x40, 0x4f, 0x0d, 0x51, 0xb3, 0x6e, 0x10, 0xcf, 0x9a, 0x8e, 0x7f, 0x15, 0x41, 0x0e,
-	0x53, 0xed, 0xe7, 0xcd, 0xa7, 0xb5, 0x98, 0x85, 0xab, 0x38, 0xf9, 0xb4, 0xf0, 0x2c, 0x16, 0xaf,
-	0x2f, 0xb8, 0xa2, 0x6c, 0xa6, 0x40, 0xda, 0x77, 0xcc, 0x5e, 0xe1, 0x9f, 0x02, 0x5c, 0x18, 0x89,
-	0xc9, 0xa1, 0x5c, 0x4e, 0x98, 0x32, 0x97, 0x5b, 0x83, 0x0c, 0xfd, 0x0d, 0x71, 0x62, 0xfe, 0x97,
-	0xa6, 0x30, 0x96, 0x33, 0xf2, 0x7f, 0x19, 0x27, 0xe7, 0xbb, 0x1c, 0x58, 0xf2, 0xd1, 0x0a, 0x48,
-	0x7e, 0xaf, 0xcd, 0x0e, 0xbf, 0x0b, 0x03, 0x24, 0x7f, 0x44, 0xec, 0x6b, 0xf4, 0xda, 0x58, 0xa5,
-	0x88, 0xbe, 0xfd, 0x49, 0x7a, 0xb6, 0x67, 0x85, 0xc2, 0x2f, 0xce, 0xc3, 0x7c, 0xc4, 0x66, 0x54,
-	0x81, 0xf9, 0x0f, 0x3d, 0xc7, 0xd6, 0x9c, 0xfd, 0x0f, 0xc9, 0x59, 0x97, 0x99, 0x7b, 0x2b, 0x7e,
-	0xd1, 0xa2, 0xdf, 0x3b, 0x14, 0xb8, 0x35, 0xa7, 0x02, 0x91, 0x63, 0x25, 0x54, 0x02, 0x5a, 0xd2,
-	0x74, 0xd7, 0xd5, 0x7b, 0xdc, 0xfe, 0x9b, 0x13, 0x3a, 0x29, 0x11, 0x1c, 0x39, 0x48, 0x12, 0x29,
-	0x5a, 0x60, 0xff, 0xd9, 0xac, 0x96, 0xe5, 0x5b, 0xe1, 0xdf, 0x80, 0x71, 0x3d, 0xec, 0x06, 0x38,
-	0xd2, 0x43, 0x28, 0x84, 0xd6, 0x41, 0xf2, 0xf1, 0x93, 0x80, 0x46, 0xd7, 0xc6, 0x08, 0x93, 0xcd,
-	0x98, 0x1c, 0xf2, 0x09, 0x14, 0xbd, 0x43, 0xf2, 0xc7, 0x8e, 0xed, 0x63, 0x97, 0x2f, 0x00, 0xcb,
-	0x63, 0xa4, 0xca, 0x0c, 0xb5, 0x35, 0xa7, 0x06, 0x02, 0x74, 0x38, 0x17, 0x07, 0x07, 0xfd, 0xb1,
-	0xc3, 0xb9, 0x98, 0xfe, 0xbb, 0x20, 0xd0, 0xfc, 0x67, 0x02, 0x40, 0x7f, 0x0e, 0xd1, 0x0a, 0x24,
-	0x6d, 0xb2, 0x2a, 0xe5, 0x04, 0x1a, 0x49, 0xd1, 0xa8, 0x53, 0xb7, 0x1a, 0x64, 0xc1, 0x52, 0x19,
-	0x60, 0xc6, 0xf3, 0x45, 0x94, 0x93, 0x89, 0x19, 0x38, 0x29, 0x4d, 0xc7, 0xc9, 0xfc, 0x9f, 0x04,
-	0x90, 0x43, 0xaf, 0x4e, 0xb4, 0xea, 0x7e, 0xe9, 0xc5, 0xb1, 0xea, 0xef, 0x02, 0xc8, 0x21, 0xd3,
-	0xc2, 0xb8, 0x13, 0xa6, 0x8f, 0x3b, 0x31, 0x12, 0x77, 0x33, 0x9e, 0x6e, 0xa3, 0xb6, 0x4a, 0x33,
-	0xd8, 0x9a, 0x9c, 0xd2, 0xd6, 0x3f, 0x0a, 0x20, 0x91, 0xc0, 0x40, 0xaf, 0x0d, 0x3a, 0x6f, 0x29,
-	0x26, 0x8b, 0x7d, 0x31, 0xbc, 0xf7, 0x37, 0x01, 0xd2, 0x3c, 0x68, 0xff, 0x17, 0x7c, 0xe7, 0x62,
-	0x3c, 0xd1, 0x77, 0x3c, 0x01, 0x7a, 0x21, 0x7c, 0x17, 0xee, 0xcf, 0x0f, 0x21, 0xcd, 0xd7, 0xc1,
-	0x98, 0xed, 0x7d, 0x0d, 0xd2, 0x98, 0xad, 0xb1, 0x31, 0x67, 0xb3, 0xe8, 0x35, 0x4e, 0x00, 0x2b,
-	0x18, 0x90, 0xe6, 0x0b, 0x10, 0x49, 0x8a, 0x6c, 0xb2, 0x55, 0x08, 0x23, 0xe9, 0x4e, 0xb0, 0x44,
-	0xd1, 0xf6, 0x19, 0x06, 0x79, 0x04, 0x19, 0x22, 0x4f, 0xd2, 0x93, 0x3e, 0x9b, 0x84, 0x48, 0x06,
-	0x42, 0xe6, 0xa4, 0xd3, 0x36, 0xa7, 0x9b, 0x7b, 0x0e, 0x2c, 0xf9, 0x85, 0x3f, 0x88, 0x90, 0x09,
-	0x22, 0x10, 0xbd, 0x12, 0xb9, 0xdf, 0xb8, 0x14, 0x13, 0xa2, 0xfc, 0x86, 0x23, 0x36, 0x03, 0x9a,
-	0x31, 0xef, 0x78, 0x13, 0xe6, 0x2d, 0xdb, 0xd3, 0xe8, 0x0f, 0x3e, 0x7e, 0x5f, 0x30, 0x76, 0x6c,
-	0xd9, 0xb2, 0xbd, 0x5d, 0x17, 0x77, 0xab, 0x26, 0x2a, 0x0f, 0x64, 0x8c, 0x2c, 0x33, 0x7f, 0x39,
-	0x46, 0x6a, 0xe2, 0x8f, 0x14, 0x75, 0x9a, 0x74, 0x6f, 0xc2, 0x0d, 0x5a, 0xe0, 0x90, 0xe8, 0x0d,
-	0xda, 0x07, 0x00, 0x7d, 0x8d, 0x67, 0xcc, 0xf9, 0x2e, 0x43, 0xca, 0x39, 0x38, 0xf0, 0x30, 0xf3,
-	0x62, 0x52, 0xe5, 0xa5, 0xc2, 0xaf, 0xf8, 0xb1, 0x6c, 0xb2, 0xaf, 0x38, 0x80, 0xfb, 0x0a, 0xf1,
-	0x35, 0x8a, 0xb9, 0x6a, 0x68, 0x35, 0x4a, 0x8c, 0xf7, 0x9f, 0x34, 0x9b, 0xff, 0x92, 0x93, 0xf4,
-	0x89, 0xf8, 0x8f, 0x8b, 0x91, 0x60, 0x20, 0x62, 0xa9, 0x93, 0xc4, 0x6a, 0xf8, 0x89, 0x5f, 0xa5,
-	0xcc, 0x33, 0x71, 0xdb, 0x3f, 0xa2, 0xc9, 0x51, 0x52, 0x65, 0x85, 0x21, 0x32, 0x64, 0x46, 0xc9,
-	0xc0, 0xfb, 0xfa, 0xd2, 0xc9, 0xf0, 0x0e, 0x3b, 0x73, 0xd1, 0x23, 0x22, 0xfa, 0x6a, 0xff, 0x9f,
-	0xe2, 0x84, 0x85, 0x34, 0xc0, 0x50, 0x22, 0x85, 0x73, 0x70, 0xc6, 0x44, 0xfa, 0x01, 0xa4, 0xf9,
-	0xf1, 0x0b, 0x6d, 0x80, 0xcc, 0x4f, 0x82, 0x27, 0xb1, 0x29, 0xc3, 0x70, 0x55, 0x13, 0xdd, 0x85,
-	0xc5, 0x26, 0x3e, 0xf0, 0x35, 0xcf, 0xda, 0x6f, 0x5a, 0xf6, 0x21, 0x91, 0x14, 0x27, 0x49, 0x9e,
-	0x27, 0xe8, 0x3a, 0x03, 0x57, 0xcd, 0x42, 0x0b, 0xa4, 0x3d, 0x0f, 0xbb, 0x68, 0x21, 0x64, 0xb0,
-	0x4c, 0xa9, 0x9a, 0x87, 0x4c, 0xc7, 0xc3, 0xae, 0xad, 0xb7, 0x02, 0xba, 0x86, 0x65, 0xf4, 0xf5,
-	0x98, 0xad, 0x32, 0x5f, 0x64, 0x77, 0xf3, 0xc5, 0xe0, 0x6e, 0x9e, 0xce, 0x02, 0xbd, 0xbc, 0x8f,
-	0x4c, 0x42, 0xe1, 0x3f, 0x22, 0xa4, 0x77, 0x5d, 0x87, 0x66, 0xc6, 0xc3, 0x43, 0x22, 0x90, 0x22,
-	0xc3, 0xd1, 0x6f, 0x74, 0x03, 0xa0, 0xdd, 0xd9, 0x6f, 0x5a, 0x06, 0xbd, 0xf2, 0x66, 0x21, 0x22,
-	0xb3, 0x9a, 0xf7, 0x70, 0x8f, 0x34, 0x7b, 0xd8, 0x70, 0x31, 0xbb, 0x11, 0x97, 0x58, 0x33, 0xab,
-	0x21, 0xcd, 0x2b, 0x90, 0xd5, 0x3b, 0xfe, 0x91, 0xf6, 0x31, 0xde, 0x3f, 0x72, 0x9c, 0x63, 0xad,
-	0xe3, 0x36, 0xf9, 0x2f, 0xe4, 0x05, 0x52, 0xff, 0x3e, 0xab, 0xde, 0x73, 0x9b, 0x68, 0x0d, 0x2e,
-	0x0e, 0x20, 0x5b, 0xd8, 0x3f, 0x72, 0x4c, 0x8f, 0xfe, 0x26, 0x93, 0x55, 0x14, 0x41, 0x3f, 0x64,
-	0x2d, 0xe8, 0x9b, 0x70, 0x8d, 0x5f, 0xdc, 0x9a, 0x58, 0x37, 0x7c, 0xab, 0xab, 0xfb, 0x58, 0xf3,
-	0x8f, 0x5c, 0xec, 0x1d, 0x39, 0x4d, 0x93, 0xc6, 0x84, 0xac, 0x5e, 0x65, 0x90, 0x4a, 0x88, 0x68,
-	0x04, 0x80, 0xa1, 0x49, 0xcc, 0x9c, 0x62, 0x12, 0x89, 0x68, 0x64, 0x73, 0x91, 0x4f, 0x16, 0xed,
-	0xef, 0x30, 0x3f, 0x4d, 0xc0, 0xe5, 0x3d, 0x52, 0xd2, 0xf7, 0x9b, 0x98, 0x3b, 0xe2, 0x9e, 0x85,
-	0x9b, 0xa6, 0x87, 0xd6, 0xf8, 0xf4, 0x0b, 0xfc, 0x97, 0xd6, 0x70, 0x7f, 0x75, 0xdf, 0xb5, 0xec,
-	0x43, 0x9a, 0x4c, 0x71, 0xe7, 0xdc, 0x8b, 0x99, 0x5e, 0x71, 0x0a, 0xe9, 0xe1, 0xc9, 0x3f, 0x18,
-	0x33, 0xf9, 0x8c, 0x59, 0x6f, 0x44, 0x78, 0x1c, 0xaf, 0x7a, 0xb1, 0x34, 0xe2, 0x9e, 0x58, 0x97,
-	0x7d, 0x6f, 0xb2, 0xcb, 0xa4, 0x29, 0x54, 0x1f, 0xef, 0xd0, 0x7c, 0x11, 0xd0, 0xa8, 0x1e, 0xec,
-	0x01, 0x02, 0x33, 0x47, 0xa0, 0x5c, 0x0a, 0x8a, 0x85, 0x1f, 0x89, 0xb0, 0x58, 0xe1, 0x8f, 0x37,
-	0xea, 0x9d, 0x56, 0x4b, 0x77, 0x7b, 0x23, 0x21, 0x31, 0x7a, 0x5b, 0x3a, 0xfc, 0x56, 0x43, 0x8e,
-	0xbc, 0xd5, 0x18, 0xa4, 0x94, 0x74, 0x1a, 0x4a, 0xbd, 0x0b, 0xf3, 0xba, 0x61, 0x60, 0xcf, 0x8b,
-	0xa6, 0xa5, 0x93, 0x64, 0x21, 0x80, 0x8f, 0xf0, 0x31, 0x75, 0x1a, 0x3e, 0xfe, 0x43, 0xe8, 0xbf,
-	0x9b, 0xe1, 0xef, 0x3a, 0xde, 0x1e, 0x48, 0xe4, 0xff, 0x6f, 0xec, 0xbb, 0x0a, 0xfe, 0xd0, 0x23,
-	0x92, 0xd8, 0xaf, 0x42, 0x26, 0x78, 0x6a, 0x31, 0xe9, 0x89, 0x4d, 0x08, 0x2a, 0xb4, 0x82, 0x07,
-	0x36, 0xa4, 0x13, 0x74, 0x0d, 0xae, 0x94, 0xb7, 0x4a, 0xb5, 0xfb, 0x8a, 0xd6, 0x78, 0xbc, 0xab,
-	0x68, 0x7b, 0xb5, 0xfa, 0xae, 0x52, 0xae, 0xde, 0xab, 0x2a, 0x95, 0xec, 0x1c, 0x5a, 0x82, 0xc5,
-	0x68, 0xe3, 0xee, 0x5e, 0x23, 0x2b, 0xa0, 0xcb, 0x80, 0xa2, 0x95, 0x15, 0x65, 0x5b, 0x69, 0x28,
-	0x59, 0x11, 0x5d, 0x82, 0x0b, 0xd1, 0xfa, 0xf2, 0xb6, 0x52, 0x52, 0xb3, 0x89, 0x42, 0x17, 0x32,
-	0x81, 0x12, 0x68, 0x1d, 0x24, 0x42, 0x65, 0xbe, 0xfb, 0xdc, 0x88, 0xd1, 0xb3, 0x58, 0xd1, 0x7d,
-	0x9d, 0x6d, 0x8d, 0x14, 0x9a, 0xff, 0x1a, 0xc8, 0x61, 0xd5, 0x69, 0x7e, 0x85, 0x15, 0x6a, 0xc4,
-	0xcc, 0xf0, 0xb5, 0xcf, 0xe0, 0x93, 0x12, 0x21, 0xee, 0x49, 0xc9, 0xe0, 0xa3, 0x14, 0x71, 0xe8,
-	0x51, 0x4a, 0xe1, 0xc7, 0x02, 0xcc, 0x47, 0xae, 0x3b, 0xce, 0x76, 0x3f, 0x44, 0xff, 0x0f, 0x8b,
-	0x2e, 0x6e, 0xea, 0xe4, 0x40, 0xae, 0x71, 0x40, 0x82, 0x02, 0x16, 0x82, 0xea, 0x1d, 0xb6, 0x71,
-	0x1a, 0x00, 0xfd, 0x9e, 0xa3, 0xcf, 0x60, 0x84, 0xd1, 0x67, 0x30, 0xd7, 0x41, 0x36, 0x71, 0x93,
-	0x9c, 0xf3, 0xb1, 0x1b, 0x18, 0x14, 0x56, 0x0c, 0x3c, 0x92, 0x49, 0x0c, 0x3e, 0x92, 0xd9, 0x83,
-	0x4c, 0xc5, 0x31, 0x94, 0x2e, 0xb6, 0x7d, 0x74, 0x67, 0x80, 0x99, 0x57, 0x22, 0x16, 0x06, 0x90,
-	0x08, 0x19, 0xaf, 0x03, 0xdb, 0xa7, 0xbc, 0x23, 0x3e, 0x62, 0xb0, 0x71, 0x91, 0x8a, 0xdb, 0x9f,
-	0x89, 0x20, 0x87, 0xe7, 0x52, 0x42, 0xae, 0x47, 0xa5, 0xed, 0x3d, 0x4e, 0x97, 0xda, 0xde, 0xf6,
-	0x76, 0x76, 0x8e, 0x90, 0x2b, 0x52, 0xb9, 0xb9, 0xb3, 0xb3, 0xad, 0x94, 0x6a, 0x8c, 0x74, 0x91,
-	0xfa, 0x6a, 0xad, 0xa1, 0xdc, 0x57, 0xd4, 0xac, 0x38, 0xd4, 0xc9, 0xf6, 0x4e, 0xed, 0x7e, 0x36,
-	0x41, 0x98, 0x18, 0xa9, 0xac, 0xec, 0xec, 0x6d, 0x6e, 0x2b, 0x59, 0x69, 0xa8, 0xba, 0xde, 0x50,
-	0xab, 0xb5, 0xfb, 0xd9, 0x24, 0xba, 0x08, 0xd9, 0xe8, 0x90, 0x8f, 0x1b, 0x4a, 0x3d, 0x9b, 0x1a,
-	0xea, 0xb8, 0x52, 0x6a, 0x28, 0xd9, 0x34, 0xca, 0xc3, 0xe5, 0x48, 0x25, 0x39, 0x25, 0x69, 0x3b,
-	0x9b, 0x0f, 0x94, 0x72, 0x23, 0x9b, 0x41, 0x57, 0xe1, 0xd2, 0x70, 0x5b, 0x49, 0x55, 0x4b, 0x8f,
-	0xb3, 0xf2, 0x50, 0x5f, 0x0d, 0xe5, 0xbb, 0x8d, 0x2c, 0x0c, 0xf5, 0xc5, 0x2d, 0xd2, 0xca, 0xb5,
-	0x46, 0x76, 0x1e, 0x5d, 0x81, 0xa5, 0x21, 0xab, 0x68, 0xc3, 0xb9, 0xe1, 0x9e, 0x54, 0x45, 0xc9,
-	0x9e, 0xbf, 0xfd, 0x43, 0x38, 0x17, 0x75, 0x05, 0x7a, 0x19, 0x5e, 0xaa, 0xec, 0x94, 0x35, 0xe5,
-	0x91, 0x52, 0x6b, 0x04, 0x53, 0x50, 0xde, 0x7b, 0x48, 0x4a, 0x2c, 0x40, 0x49, 0x68, 0x4f, 0x00,
-	0xbd, 0x5f, 0x6a, 0x94, 0xb7, 0x94, 0x4a, 0x56, 0x40, 0xaf, 0xc0, 0xad, 0x71, 0xa0, 0xbd, 0x5a,
-	0x00, 0x13, 0x37, 0xef, 0xfc, 0xee, 0xe9, 0xb2, 0xf0, 0xe9, 0xd3, 0x65, 0xe1, 0x2f, 0x4f, 0x97,
-	0x85, 0x9f, 0x7f, 0xbe, 0x3c, 0x07, 0x17, 0x4c, 0xdc, 0x0d, 0x98, 0xa2, 0xb7, 0xad, 0x62, 0x77,
-	0x7d, 0x57, 0xf8, 0x40, 0x2a, 0xbe, 0xdb, 0x5d, 0xdf, 0x4f, 0xd1, 0xb5, 0xf1, 0xf5, 0xff, 0x06,
-	0x00, 0x00, 0xff, 0xff, 0xcd, 0x66, 0xbf, 0x7b, 0x1e, 0x29, 0x00, 0x00,
+	// 2714 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcb, 0x8f, 0x1b, 0x49,
+	0x19, 0x9f, 0xb6, 0xdb, 0x8f, 0xfe, 0x26, 0xc9, 0x74, 0x2a, 0x2f, 0xc7, 0x49, 0x66, 0x13, 0x2f,
+	0xbb, 0xcc, 0x26, 0xe0, 0x49, 0x66, 0x1f, 0x2c, 0xbb, 0x2c, 0xd0, 0x63, 0x77, 0x32, 0xb3, 0x3b,
+	0xf1, 0x0c, 0x6d, 0x4f, 0x96, 0xac, 0x40, 0xad, 0x9e, 0xee, 0x4a, 0xa6, 0x37, 0x76, 0xb7, 0xb7,
+	0xbb, 0xed, 0x8d, 0x25, 0x24, 0x24, 0x04, 0x12, 0x17, 0x0e, 0xdc, 0xf8, 0x17, 0xb8, 0x70, 0xe3,
+	0xb0, 0x47, 0x38, 0x20, 0x24, 0x84, 0x58, 0x89, 0x95, 0xb8, 0xc2, 0x72, 0x40, 0x20, 0x71, 0x40,
+	0x48, 0xdc, 0x90, 0x50, 0x3d, 0xba, 0x5d, 0xb6, 0xdb, 0x8e, 0xc7, 0x3b, 0xbb, 0xda, 0x88, 0x5b,
+	0x57, 0xd5, 0xef, 0xab, 0xfa, 0xbe, 0xfa, 0x9e, 0xd5, 0x55, 0x70, 0x71, 0xe0, 0x07, 0x8f, 0x5c,
+	0xbc, 0xde, 0xbf, 0xb5, 0x1e, 0xe0, 0xd0, 0xef, 0x05, 0x36, 0x0e, 0xab, 0xdd, 0xc0, 0x8f, 0x7c,
+	0xa4, 0xb0, 0xa1, 0x6a, 0xff, 0x56, 0xf9, 0x99, 0x87, 0xbe, 0xff, 0xb0, 0x8d, 0xd7, 0xe9, 0xc0,
+	0x41, 0xef, 0xc1, 0x7a, 0xe4, 0x76, 0x70, 0x18, 0x59, 0x9d, 0x2e, 0xc3, 0x96, 0x57, 0xc7, 0x01,
+	0xef, 0x07, 0x56, 0xb7, 0x8b, 0x03, 0x3e, 0x57, 0xe5, 0x77, 0x12, 0x14, 0x9b, 0x9e, 0xd5, 0x0d,
+	0x0f, 0xfd, 0x08, 0x5d, 0x07, 0x39, 0xf0, 0xfd, 0xa8, 0x24, 0x5d, 0x95, 0xd6, 0x96, 0x37, 0xce,
+	0x57, 0x93, 0x75, 0xaa, 0x6f, 0x36, 0x77, 0x1b, 0x7a, 0x1b, 0x77, 0xb0, 0x17, 0x19, 0x14, 0x83,
+	0xbe, 0x09, 0x4a, 0x37, 0xc0, 0x21, 0xf6, 0x6c, 0x1c, 0x96, 0x32, 0x57, 0xb3, 0x6b, 0xcb, 0x1b,
+	0x15, 0x81, 0x20, 0x9e, 0xb3, 0xba, 0x17, 0x83, 0x74, 0x2f, 0x0a, 0x06, 0xc6, 0x90, 0xa8, 0xfc,
+	0x2d, 0x38, 0x35, 0x3a, 0x88, 0x54, 0xc8, 0x3e, 0xc2, 0x03, 0xba, 0xbc, 0x62, 0x90, 0x4f, 0xf4,
+	0x02, 0xe4, 0xfa, 0x56, 0xbb, 0x87, 0x4b, 0x19, 0xca, 0xd2, 0x19, 0x61, 0x85, 0x98, 0xd6, 0x60,
+	0x88, 0xd7, 0x32, 0xaf, 0x4a, 0x95, 0x9f, 0x66, 0x00, 0x6a, 0x87, 0x96, 0xf7, 0x10, 0xef, 0x59,
+	0xf6, 0x23, 0x74, 0x0d, 0x4e, 0x38, 0xbe, 0xdd, 0x23, 0x5c, 0x9b, 0xc3, 0x89, 0x97, 0xe3, 0xbe,
+	0xb7, 0xf0, 0x00, 0xbd, 0x0c, 0x60, 0x1f, 0x62, 0xfb, 0x51, 0xd7, 0x77, 0xbd, 0x88, 0xaf, 0x72,
+	0x4e, 0x58, 0xa5, 0x96, 0x0c, 0x1a, 0x02, 0x10, 0x95, 0xa1, 0x18, 0x72, 0x09, 0x4b, 0xd9, 0xab,
+	0xd2, 0xda, 0x09, 0x23, 0x69, 0xa3, 0x1b, 0x50, 0xb0, 0x29, 0x0f, 0x61, 0x49, 0xa6, 0xfb, 0x72,
+	0x7a, 0x64, 0x3e, 0x32, 0x62, 0xc4, 0x08, 0xa4, 0xc1, 0xe9, 0x8e, 0xeb, 0x99, 0xe1, 0xc0, 0xb3,
+	0xb1, 0x63, 0x46, 0xae, 0xfd, 0x08, 0x47, 0xa5, 0xdc, 0x04, 0x1b, 0x2d, 0xb7, 0x83, 0x5b, 0x74,
+	0xd0, 0x58, 0xe9, 0xb8, 0x5e, 0x93, 0xc2, 0x59, 0x07, 0xba, 0x02, 0xe0, 0x86, 0x66, 0x80, 0x3b,
+	0x7e, 0x1f, 0x3b, 0xa5, 0xfc, 0x55, 0x69, 0xad, 0x68, 0x28, 0x6e, 0x68, 0xb0, 0x8e, 0xca, 0xaf,
+	0x24, 0xc8, 0xb3, 0x55, 0xd1, 0xb3, 0x90, 0x71, 0x1d, 0xae, 0xdd, 0x33, 0x13, 0x4c, 0x6d, 0xd7,
+	0x8d, 0x8c, 0xeb, 0xa0, 0x12, 0x14, 0x3a, 0x38, 0x0c, 0xad, 0x87, 0x6c, 0xd3, 0x15, 0x23, 0x6e,
+	0xa2, 0x97, 0x00, 0xfc, 0x2e, 0x0e, 0xac, 0xc8, 0xf5, 0xbd, 0xb0, 0x94, 0xa5, 0xb2, 0x9d, 0x15,
+	0xa6, 0xd9, 0x8d, 0x07, 0x0d, 0x01, 0x87, 0x36, 0x61, 0x25, 0xd6, 0xb9, 0xc9, 0xa4, 0x2e, 0xc9,
+	0x94, 0x83, 0x8b, 0x29, 0xca, 0xe4, 0xdb, 0x73, 0xaa, 0x3b, 0xd2, 0xae, 0xfc, 0x48, 0x82, 0x62,
+	0xcc, 0x24, 0x91, 0xd7, 0x6e, 0xbb, 0x44, 0xa7, 0x21, 0x7e, 0x8f, 0x4a, 0x73, 0xd2, 0x50, 0x58,
+	0x4f, 0x13, 0xbf, 0x87, 0xae, 0x01, 0x84, 0x38, 0xe8, 0xe3, 0x80, 0x0e, 0x13, 0x11, 0xb2, 0x9b,
+	0x99, 0x9b, 0x92, 0xa1, 0xb0, 0x5e, 0x02, 0xb9, 0x0c, 0x85, 0xb6, 0xd5, 0xe9, 0xfa, 0x01, 0x53,
+	0x1e, 0x1b, 0x8f, 0xbb, 0xd0, 0x45, 0x28, 0x5a, 0x76, 0xe4, 0x07, 0xa6, 0xeb, 0x50, 0x4e, 0x4f,
+	0x18, 0x05, 0xda, 0xde, 0x76, 0x2a, 0xff, 0xbc, 0x02, 0x4a, 0x22, 0x25, 0xfa, 0x12, 0x64, 0x43,
+	0x1c, 0x7b, 0x4b, 0x29, 0x6d, 0x23, 0xaa, 0x4d, 0x1c, 0x6d, 0x2d, 0x19, 0x04, 0x46, 0xd0, 0x96,
+	0xe3, 0x70, 0x13, 0x4b, 0x47, 0x6b, 0x8e, 0x43, 0xd0, 0x96, 0xe3, 0xa0, 0x75, 0x90, 0x89, 0xfa,
+	0x28, 0x7f, 0xa3, 0x5b, 0x35, 0x84, 0xdf, 0xf5, 0xfb, 0x78, 0x6b, 0xc9, 0xa0, 0x40, 0xf4, 0x32,
+	0xe4, 0x99, 0x09, 0xf0, 0xdd, 0xbd, 0x94, 0x4a, 0xc2, 0x8c, 0x62, 0x6b, 0xc9, 0xe0, 0x60, 0xb2,
+	0x0e, 0x76, 0xdc, 0xd8, 0xe4, 0xd2, 0xd7, 0xd1, 0x1d, 0x97, 0x48, 0x41, 0x81, 0x64, 0x9d, 0x10,
+	0xb7, 0xb1, 0x1d, 0x51, 0x4b, 0x9b, 0xb6, 0x4e, 0x93, 0x42, 0xc8, 0x3a, 0x0c, 0x8c, 0x36, 0x20,
+	0x17, 0x46, 0x83, 0x36, 0x2e, 0x15, 0x28, 0x55, 0x39, 0x9d, 0x8a, 0x20, 0xb6, 0x96, 0x0c, 0x06,
+	0x45, 0xaf, 0x43, 0xd1, 0xf5, 0xec, 0x00, 0x5b, 0x21, 0x2e, 0x15, 0x29, 0xd9, 0x95, 0x54, 0xb2,
+	0x6d, 0x0e, 0xda, 0x5a, 0x32, 0x12, 0x02, 0xf4, 0x35, 0x50, 0xa2, 0x00, 0x63, 0x93, 0x4a, 0xa7,
+	0xcc, 0xa0, 0x6e, 0x05, 0x18, 0x73, 0x09, 0x8b, 0x11, 0xff, 0x46, 0xdf, 0x00, 0xa0, 0xd4, 0x8c,
+	0x67, 0xa0, 0xe4, 0xab, 0x53, 0xc9, 0x63, 0xbe, 0xe9, 0x8a, 0xb4, 0x51, 0xfe, 0x8d, 0x04, 0xd9,
+	0x26, 0x8e, 0x88, 0x7f, 0x77, 0xad, 0x80, 0x18, 0x2b, 0xe1, 0x2b, 0xc2, 0x8e, 0x69, 0xc5, 0x16,
+	0x33, 0xcd, 0xbf, 0x19, 0xbe, 0xc6, 0xe0, 0x5a, 0x14, 0x47, 0xc5, 0xcc, 0x30, 0x2a, 0x6e, 0xc4,
+	0x51, 0x91, 0x59, 0xc7, 0xe5, 0xf4, 0x40, 0xdd, 0x74, 0x3b, 0xdd, 0x76, 0x1c, 0x1e, 0xd1, 0x2b,
+	0xb0, 0x8c, 0x1f, 0x63, 0xbb, 0xc7, 0x59, 0x90, 0x67, 0xb1, 0x00, 0x31, 0x52, 0x8b, 0xca, 0xff,
+	0x96, 0x20, 0xab, 0x39, 0xce, 0x71, 0x08, 0xf2, 0x06, 0x8d, 0x04, 0x7d, 0x71, 0x82, 0xcc, 0xac,
+	0x09, 0x4e, 0x12, 0xf4, 0x90, 0xfc, 0xb3, 0x94, 0xfa, 0x3f, 0x12, 0xc8, 0xc4, 0xbd, 0x3e, 0x07,
+	0x62, 0xbf, 0x04, 0x20, 0x50, 0x66, 0x67, 0x51, 0x2a, 0x76, 0x42, 0xb5, 0xa8, 0xe0, 0x1f, 0x48,
+	0x90, 0x67, 0x41, 0xe2, 0x38, 0x44, 0x1f, 0xe5, 0x3d, 0xb3, 0x18, 0xef, 0xd9, 0x79, 0x79, 0xff,
+	0xb5, 0x0c, 0x32, 0xf5, 0xde, 0x63, 0xe0, 0xfc, 0x3a, 0xc8, 0x0f, 0x02, 0xbf, 0xc3, 0x79, 0x16,
+	0x4b, 0xa1, 0x16, 0x7e, 0x1c, 0x35, 0x7c, 0x07, 0xef, 0xf9, 0xa1, 0x41, 0x31, 0xe8, 0x79, 0xc8,
+	0x44, 0x3e, 0x67, 0x73, 0x1a, 0x32, 0x13, 0xf9, 0xe8, 0x10, 0x2e, 0x0c, 0xf9, 0x31, 0x3b, 0x56,
+	0xd7, 0x3c, 0x18, 0x98, 0x34, 0xb5, 0xf0, 0x42, 0x61, 0x63, 0x6a, 0xf8, 0xad, 0x26, 0x9c, 0xdd,
+	0xb5, 0xba, 0x9b, 0x03, 0x8d, 0x10, 0xb1, 0x82, 0xea, 0x8c, 0x3d, 0x39, 0x42, 0x72, 0xb8, 0xed,
+	0x7b, 0x11, 0xf6, 0x58, 0x60, 0x57, 0x8c, 0xb8, 0x39, 0xbe, 0xb7, 0xf9, 0x39, 0xf7, 0x16, 0x6d,
+	0x03, 0x58, 0x51, 0x14, 0xb8, 0x07, 0xbd, 0x08, 0x87, 0xa5, 0x02, 0x65, 0xf7, 0x85, 0xe9, 0xec,
+	0x6a, 0x09, 0x96, 0x71, 0x29, 0x10, 0x97, 0xbf, 0x0b, 0xa5, 0x69, 0xd2, 0xa4, 0x54, 0x80, 0x37,
+	0x46, 0x2b, 0xc0, 0x29, 0xac, 0x0e, 0x6b, 0xc0, 0xf2, 0x1b, 0xb0, 0x32, 0xb6, 0x7a, 0xca, 0xac,
+	0x67, 0xc5, 0x59, 0x15, 0x91, 0xfc, 0x4f, 0x12, 0xe4, 0x59, 0xf6, 0xfa, 0xbc, 0x9a, 0xd1, 0xa2,
+	0xae, 0xfd, 0x4b, 0x19, 0x72, 0x34, 0x39, 0x1d, 0x87, 0x60, 0xeb, 0x23, 0x82, 0x5d, 0x4a, 0x61,
+	0x77, 0xd3, 0xef, 0x79, 0x8e, 0x15, 0x0c, 0xb8, 0x74, 0x37, 0x04, 0xe9, 0x66, 0xc2, 0x89, 0x88,
+	0x6f, 0x8e, 0x58, 0x1b, 0x73, 0x8e, 0xeb, 0xd3, 0x4b, 0x86, 0x59, 0xe6, 0x36, 0xbe, 0x5d, 0xb9,
+	0x79, 0x2d, 0xde, 0x9d, 0xee, 0xad, 0x79, 0xca, 0xd0, 0x8b, 0x33, 0x18, 0x3a, 0x92, 0xbb, 0x7e,
+	0x52, 0x93, 0xfd, 0x94, 0x1d, 0xea, 0x03, 0x09, 0x8a, 0x71, 0x89, 0x75, 0x1c, 0xa6, 0xb3, 0x31,
+	0xca, 0xc0, 0x22, 0x79, 0x7c, 0xee, 0x94, 0xf0, 0x61, 0x16, 0x8a, 0x71, 0x81, 0x77, 0x1c, 0xbc,
+	0x3f, 0x3f, 0x62, 0xf6, 0x48, 0xa4, 0x0a, 0xb0, 0xe0, 0xcb, 0x15, 0xc1, 0xda, 0xd3, 0x50, 0xc4,
+	0xc8, 0xdb, 0x4f, 0x4a, 0x07, 0xaf, 0xcc, 0xac, 0x57, 0x8f, 0x98, 0x12, 0x6e, 0x42, 0x91, 0xe7,
+	0x80, 0xb0, 0x94, 0x9b, 0x38, 0xba, 0x91, 0x49, 0x89, 0x17, 0x86, 0x46, 0x82, 0x5a, 0x34, 0x55,
+	0x7c, 0xda, 0xe6, 0xf8, 0x97, 0x0c, 0x28, 0x49, 0xd1, 0xfd, 0x79, 0xd3, 0x69, 0x23, 0x25, 0x70,
+	0x55, 0x67, 0x9f, 0x1b, 0x3e, 0x8d, 0xe0, 0xf5, 0x09, 0x23, 0xca, 0x66, 0x1e, 0xe4, 0x03, 0xdf,
+	0x19, 0x54, 0xfe, 0x25, 0xc1, 0xe9, 0x09, 0x9f, 0x1c, 0xab, 0xea, 0xa4, 0x39, 0xab, 0xba, 0x9b,
+	0x50, 0xa4, 0x3f, 0x24, 0x9e, 0x58, 0x09, 0x16, 0x28, 0x8c, 0x55, 0x8f, 0xfc, 0xaf, 0xc6, 0x93,
+	0x2b, 0x5f, 0x0e, 0xd4, 0x22, 0xb4, 0x06, 0x72, 0x34, 0xe8, 0xb2, 0x63, 0xf0, 0xa9, 0x11, 0x23,
+	0xbf, 0x47, 0xe4, 0x6b, 0x0d, 0xba, 0xd8, 0xa0, 0x88, 0xa1, 0xfc, 0x39, 0x7a, 0xca, 0x67, 0x8d,
+	0xca, 0xcf, 0x4f, 0xc2, 0xb2, 0x20, 0x33, 0xaa, 0xc3, 0xf2, 0xbb, 0xa1, 0xef, 0x99, 0xfe, 0xc1,
+	0xbb, 0xe4, 0xd4, 0xcb, 0xc4, 0xbd, 0x96, 0x1e, 0xb4, 0xe8, 0xf7, 0x2e, 0x05, 0x6e, 0x2d, 0x19,
+	0x40, 0xe8, 0x58, 0x0b, 0x69, 0x40, 0x5b, 0xa6, 0x15, 0x04, 0xd6, 0x80, 0xcb, 0x7f, 0x75, 0xc6,
+	0x24, 0x1a, 0xc1, 0x91, 0x23, 0x25, 0xa1, 0xa2, 0x0d, 0xf6, 0xc7, 0xcd, 0xed, 0xb8, 0x91, 0x9b,
+	0xfc, 0x17, 0x98, 0x36, 0xc3, 0x5e, 0x8c, 0x23, 0x33, 0x24, 0x44, 0xe8, 0x16, 0xc8, 0x11, 0x7e,
+	0x1c, 0x9b, 0xd1, 0xa5, 0x29, 0xc4, 0x24, 0x23, 0x93, 0xe3, 0x3e, 0x81, 0xa2, 0xd7, 0x48, 0x25,
+	0xd9, 0xf3, 0x22, 0x1c, 0xf0, 0x00, 0xb0, 0x3a, 0x85, 0xaa, 0xc6, 0x50, 0x5b, 0x4b, 0x46, 0x4c,
+	0x40, 0x97, 0x0b, 0x70, 0x7c, 0xe4, 0x9f, 0xba, 0x5c, 0x80, 0xe9, 0x5f, 0x0c, 0x02, 0x2d, 0x7f,
+	0x24, 0x01, 0x0c, 0xf7, 0x10, 0xad, 0x41, 0xce, 0x23, 0x51, 0xa9, 0x24, 0x51, 0x4f, 0x12, 0xbd,
+	0xce, 0xd8, 0x6a, 0x91, 0x80, 0x65, 0x30, 0xc0, 0x82, 0x27, 0x0d, 0xd1, 0x26, 0xb3, 0x0b, 0xd8,
+	0xa4, 0x3c, 0x9f, 0x4d, 0x96, 0xff, 0x28, 0x81, 0x92, 0x68, 0x75, 0xa6, 0x54, 0x77, 0xb4, 0xa7,
+	0x47, 0xaa, 0xbf, 0x4b, 0xa0, 0x24, 0x96, 0x96, 0xf8, 0x9d, 0x34, 0xbf, 0xdf, 0x65, 0x04, 0xbf,
+	0x5b, 0xf0, 0x9c, 0x2b, 0xca, 0x2a, 0x2f, 0x20, 0x6b, 0x6e, 0x4e, 0x59, 0xff, 0x20, 0x81, 0x4c,
+	0x1c, 0x03, 0xbd, 0x30, 0xaa, 0xbc, 0x33, 0x29, 0xa5, 0xec, 0xd3, 0xa1, 0xbd, 0xbf, 0x49, 0x50,
+	0xe0, 0x4e, 0xfb, 0xff, 0xa0, 0xbb, 0x00, 0xe3, 0x99, 0xba, 0xe3, 0x05, 0xd0, 0x53, 0xa1, 0xbb,
+	0x24, 0x3f, 0xdf, 0x85, 0x02, 0x8f, 0x83, 0x29, 0xe9, 0xfd, 0x26, 0x14, 0x30, 0x8b, 0xb1, 0x29,
+	0xc7, 0x4f, 0xf1, 0x42, 0x27, 0x86, 0x55, 0x6c, 0x28, 0xf0, 0x00, 0x44, 0x8a, 0x22, 0x8f, 0xa4,
+	0x0a, 0x69, 0xa2, 0xdc, 0x89, 0x43, 0x14, 0x1d, 0x5f, 0x60, 0x91, 0x7b, 0x50, 0x24, 0xf4, 0xa4,
+	0x3c, 0x19, 0x5a, 0x93, 0x24, 0x54, 0x20, 0x64, 0x4f, 0x7a, 0x5d, 0x67, 0xbe, 0xbd, 0xe7, 0x40,
+	0x2d, 0xaa, 0xfc, 0x3e, 0x03, 0xc5, 0xd8, 0x03, 0xd1, 0x73, 0xc2, 0x4d, 0xc7, 0xb9, 0x14, 0x17,
+	0xe5, 0x77, 0x1d, 0xa9, 0x15, 0xd0, 0x82, 0x75, 0xc7, 0xcb, 0xb0, 0xec, 0x7a, 0xa1, 0x49, 0x7f,
+	0xf5, 0xf1, 0x9b, 0x83, 0xa9, 0x6b, 0x2b, 0xae, 0x17, 0xee, 0x05, 0xb8, 0xbf, 0xed, 0xa0, 0xda,
+	0x48, 0xc5, 0xc8, 0x2a, 0xf3, 0x67, 0x53, 0xa8, 0x66, 0xfe, 0x52, 0x31, 0xe6, 0x29, 0xf7, 0x66,
+	0xdc, 0xa5, 0xc5, 0x0a, 0x11, 0xef, 0xd2, 0xde, 0x01, 0x18, 0x72, 0xbc, 0x60, 0xcd, 0x77, 0x1e,
+	0xf2, 0xfe, 0x83, 0x07, 0x21, 0x66, 0x5a, 0xcc, 0x19, 0xbc, 0x55, 0xf9, 0x05, 0x3f, 0x96, 0xcd,
+	0xd6, 0x15, 0x07, 0x70, 0x5d, 0x21, 0x1e, 0xa3, 0x98, 0xaa, 0xc6, 0xa2, 0x51, 0x76, 0xba, 0xfe,
+	0xe4, 0xc5, 0xf4, 0x97, 0x9b, 0xc5, 0x8f, 0xa0, 0x3f, 0x4e, 0x46, 0x9c, 0x81, 0x90, 0xe5, 0x9f,
+	0x44, 0xd6, 0xc0, 0x8f, 0xa3, 0x6d, 0x6a, 0x79, 0x0e, 0xee, 0x46, 0x87, 0xb4, 0x38, 0xca, 0x19,
+	0xac, 0x31, 0x66, 0x0c, 0xc5, 0x49, 0x63, 0xe0, 0x73, 0x7d, 0xe6, 0xc6, 0xf0, 0x1a, 0x3b, 0x73,
+	0xd1, 0x23, 0x22, 0xfa, 0xf2, 0xf0, 0xef, 0xe2, 0x8c, 0x40, 0x1a, 0x63, 0xa8, 0x21, 0x25, 0x7b,
+	0x70, 0xcc, 0x86, 0xf4, 0x3d, 0x28, 0xf0, 0xe3, 0x17, 0xda, 0x00, 0x85, 0x9f, 0x04, 0x9f, 0x64,
+	0x4d, 0x45, 0x86, 0xdb, 0x76, 0xd0, 0x1b, 0xb0, 0xd2, 0xc6, 0x0f, 0x22, 0x33, 0x74, 0x0f, 0xda,
+	0xae, 0xf7, 0x90, 0x50, 0x66, 0x66, 0x51, 0x9e, 0x24, 0xe8, 0x26, 0x03, 0x6f, 0x3b, 0x95, 0x0e,
+	0xc8, 0xfb, 0x21, 0x0e, 0xd0, 0xa9, 0xc4, 0x82, 0x15, 0x6a, 0xaa, 0x65, 0x28, 0xf6, 0x42, 0x1c,
+	0x78, 0x56, 0x27, 0x36, 0xd7, 0xa4, 0x8d, 0xbe, 0x9a, 0x92, 0x2a, 0xcb, 0x55, 0x76, 0x4b, 0x5f,
+	0x8d, 0x6f, 0xe9, 0xe9, 0x2e, 0xd0, 0x6b, 0x7c, 0x61, 0x13, 0x2a, 0xff, 0xcd, 0x40, 0x61, 0x2f,
+	0xf0, 0x69, 0x65, 0x3c, 0xbe, 0x24, 0x02, 0x59, 0x58, 0x8e, 0x7e, 0xa3, 0x2b, 0x00, 0xdd, 0xde,
+	0x41, 0xdb, 0xb5, 0xe9, 0xe5, 0x37, 0x73, 0x11, 0x85, 0xf5, 0xbc, 0x85, 0x07, 0x64, 0x38, 0xc4,
+	0x76, 0x80, 0xd9, 0xdd, 0xb8, 0xcc, 0x86, 0x59, 0x0f, 0x19, 0x5e, 0x03, 0xd5, 0xea, 0x45, 0x87,
+	0xe6, 0xfb, 0xf8, 0xe0, 0xd0, 0xf7, 0x1f, 0x99, 0xbd, 0xa0, 0xcd, 0x7f, 0x26, 0x9f, 0x22, 0xfd,
+	0x6f, 0xb3, 0xee, 0xfd, 0xa0, 0x8d, 0x6e, 0xc2, 0xd9, 0x11, 0x64, 0x07, 0x47, 0x87, 0xbe, 0x13,
+	0xd2, 0xdf, 0x64, 0x8a, 0x81, 0x04, 0xf4, 0x5d, 0x36, 0x82, 0xbe, 0x0e, 0x97, 0xf8, 0x15, 0xae,
+	0x83, 0x2d, 0x3b, 0x72, 0xfb, 0x56, 0x84, 0xcd, 0xe8, 0x30, 0xc0, 0xe1, 0xa1, 0xdf, 0x76, 0xa8,
+	0x4f, 0x28, 0xc6, 0x45, 0x06, 0xa9, 0x27, 0x88, 0x56, 0x0c, 0x18, 0xdb, 0xc4, 0xe2, 0x11, 0x36,
+	0x91, 0x90, 0x0a, 0xc9, 0x45, 0x79, 0x32, 0xe9, 0x30, 0xc3, 0xfc, 0x38, 0x0b, 0xe7, 0xf7, 0x49,
+	0xcb, 0x3a, 0x68, 0x63, 0xae, 0x88, 0xdb, 0x2e, 0x6e, 0x3b, 0x21, 0xba, 0xc9, 0xb7, 0x5f, 0xe2,
+	0xbf, 0xb4, 0xc6, 0xe7, 0x6b, 0x46, 0x81, 0xeb, 0x3d, 0xa4, 0xc5, 0x14, 0x57, 0xce, 0xed, 0x94,
+	0xed, 0xcd, 0xcc, 0x41, 0x3d, 0xbe, 0xf9, 0x0f, 0xa6, 0x6c, 0x3e, 0xb3, 0xac, 0x97, 0x04, 0x3b,
+	0x4e, 0x67, 0xbd, 0xaa, 0x4d, 0xa8, 0x27, 0x55, 0x65, 0xdf, 0x99, 0xad, 0x32, 0x79, 0x0e, 0xd6,
+	0xa7, 0x2b, 0xb4, 0x5c, 0x05, 0x34, 0xc9, 0x07, 0x7b, 0x8a, 0xc0, 0xc4, 0x91, 0xa8, 0x2d, 0xc5,
+	0xcd, 0xca, 0x0f, 0x32, 0xb0, 0x52, 0xe7, 0xcf, 0x38, 0x9a, 0xbd, 0x4e, 0xc7, 0x0a, 0x06, 0x13,
+	0x2e, 0x31, 0x79, 0x6f, 0x3a, 0xfe, 0x6a, 0x43, 0x11, 0x5e, 0x6d, 0x8c, 0x9a, 0x94, 0x7c, 0x14,
+	0x93, 0x7a, 0x1d, 0x96, 0x2d, 0xdb, 0xc6, 0x61, 0x28, 0x96, 0xa5, 0xb3, 0x68, 0x21, 0x86, 0x4f,
+	0xd8, 0x63, 0xfe, 0x28, 0xf6, 0xf8, 0x0f, 0x69, 0xf8, 0x82, 0x86, 0xbf, 0xf0, 0x78, 0x75, 0xa4,
+	0x90, 0xff, 0xc2, 0xd4, 0x17, 0x16, 0xfc, 0xc9, 0x87, 0x50, 0xd8, 0xaf, 0x43, 0x31, 0x7e, 0x74,
+	0x31, 0xeb, 0xb1, 0x4d, 0x02, 0xaa, 0x74, 0xe2, 0xa7, 0x36, 0x64, 0x12, 0x74, 0x09, 0x2e, 0xd4,
+	0xb6, 0xb4, 0xc6, 0x1d, 0xdd, 0x6c, 0xdd, 0xdf, 0xd3, 0xcd, 0xfd, 0x46, 0x73, 0x4f, 0xaf, 0x6d,
+	0xdf, 0xde, 0xd6, 0xeb, 0xea, 0x12, 0x3a, 0x03, 0x2b, 0xe2, 0xe0, 0xde, 0x7e, 0x4b, 0x95, 0xd0,
+	0x79, 0x40, 0x62, 0x67, 0x5d, 0xdf, 0xd1, 0x5b, 0xba, 0x9a, 0x41, 0xe7, 0xe0, 0xb4, 0xd8, 0x5f,
+	0xdb, 0xd1, 0x35, 0x43, 0xcd, 0x56, 0xfa, 0x50, 0x8c, 0x99, 0x40, 0xb7, 0x40, 0x26, 0xa6, 0xcc,
+	0xb3, 0xcf, 0x95, 0x14, 0x3e, 0xab, 0x75, 0x2b, 0xb2, 0x58, 0x6a, 0xa4, 0xd0, 0xf2, 0x57, 0x40,
+	0x49, 0xba, 0x8e, 0xf2, 0x2b, 0xac, 0xd2, 0x20, 0x62, 0x26, 0xef, 0x7e, 0x46, 0x1f, 0x97, 0x48,
+	0x69, 0x8f, 0x4b, 0x46, 0x9f, 0xa7, 0x64, 0xc6, 0x9e, 0xa7, 0x54, 0x7e, 0x28, 0xc1, 0xb2, 0x70,
+	0xa3, 0x73, 0xbc, 0xf9, 0x10, 0x7d, 0x11, 0x56, 0x02, 0xdc, 0xb6, 0xc8, 0x81, 0xdc, 0xe4, 0x80,
+	0x2c, 0x05, 0x9c, 0x8a, 0xbb, 0x77, 0x59, 0xe2, 0xfc, 0x89, 0x04, 0xea, 0xf8, 0xd5, 0xcb, 0x31,
+	0xf3, 0x72, 0x83, 0xdb, 0x62, 0x96, 0xda, 0xe2, 0x05, 0x61, 0x9e, 0x78, 0xc1, 0xa1, 0xf9, 0x55,
+	0x6c, 0x80, 0xe1, 0xec, 0xe2, 0x03, 0x1d, 0x69, 0xf2, 0x81, 0xce, 0x65, 0x50, 0x1c, 0xdc, 0x76,
+	0x3b, 0x6e, 0x84, 0x83, 0x78, 0x83, 0x93, 0x8e, 0x91, 0xe7, 0x3b, 0xd9, 0xd1, 0xe7, 0x3b, 0xfb,
+	0x50, 0xac, 0xfb, 0xb6, 0xde, 0xc7, 0xde, 0x90, 0x3b, 0x69, 0x82, 0xbb, 0x18, 0x22, 0x38, 0xc7,
+	0x65, 0x60, 0x79, 0x33, 0x3c, 0xe4, 0x2b, 0xc6, 0x89, 0x94, 0x74, 0x5c, 0x7f, 0x0f, 0x4e, 0x88,
+	0x12, 0xa1, 0x12, 0x9c, 0xdd, 0xdc, 0xdd, 0x6f, 0xd4, 0x35, 0xe3, 0x3e, 0xb3, 0xe1, 0x4d, 0xfd,
+	0xf6, 0xae, 0xa1, 0xab, 0x4b, 0xe8, 0x02, 0x9c, 0x19, 0x1d, 0xd1, 0x6e, 0xb7, 0x74, 0x43, 0x95,
+	0x26, 0x07, 0x9a, 0x2d, 0xcd, 0x68, 0x31, 0x6f, 0x18, 0x1d, 0xd0, 0x1b, 0x75, 0x35, 0x7b, 0xfd,
+	0xa3, 0x0c, 0x28, 0xc9, 0xd1, 0x9c, 0xf8, 0xd7, 0x3d, 0x6d, 0x67, 0x9f, 0x7b, 0x4c, 0x63, 0x7f,
+	0x67, 0x47, 0x5d, 0x22, 0xfe, 0x25, 0x74, 0x6e, 0xee, 0xee, 0xee, 0xe8, 0x5a, 0x83, 0xf9, 0x9d,
+	0xd0, 0xbf, 0xdd, 0x68, 0xe9, 0x77, 0x74, 0x43, 0xcd, 0x8c, 0x4d, 0xb2, 0xb3, 0xdb, 0xb8, 0xa3,
+	0x66, 0xc9, 0xf2, 0x42, 0x67, 0x7d, 0x77, 0x7f, 0x73, 0x47, 0x57, 0xe5, 0xb1, 0xee, 0x66, 0xcb,
+	0xd8, 0x6e, 0xdc, 0x51, 0x73, 0xe8, 0x2c, 0xa8, 0xe2, 0x92, 0xf7, 0x5b, 0x7a, 0x53, 0xcd, 0x8f,
+	0x4d, 0x5c, 0xd7, 0x5a, 0xba, 0x5a, 0x40, 0x65, 0x38, 0x2f, 0x74, 0x92, 0x83, 0xa2, 0xb9, 0xbb,
+	0xf9, 0xa6, 0x5e, 0x6b, 0xa9, 0x45, 0x74, 0x11, 0xce, 0x8d, 0x8f, 0x69, 0x86, 0xa1, 0xdd, 0x57,
+	0x95, 0xb1, 0xb9, 0x5a, 0xfa, 0xb7, 0x5b, 0x2a, 0x8c, 0xcd, 0xc5, 0x25, 0x32, 0x6b, 0x8d, 0x96,
+	0xba, 0x4c, 0x36, 0x76, 0x4c, 0x2a, 0x3a, 0x70, 0x62, 0x7c, 0x26, 0x43, 0xd7, 0xd5, 0x93, 0xd7,
+	0xbf, 0x0f, 0x27, 0x44, 0xed, 0xa3, 0x67, 0xe1, 0x99, 0xfa, 0x6e, 0xcd, 0xd4, 0xef, 0xe9, 0x8d,
+	0x56, 0xbc, 0x05, 0xb5, 0xfd, 0xbb, 0xa4, 0xc5, 0x62, 0x14, 0x89, 0x6e, 0x33, 0x40, 0x6f, 0x6b,
+	0xad, 0xda, 0x96, 0x5e, 0x57, 0x25, 0xf4, 0x1c, 0x5c, 0x9b, 0x06, 0xda, 0x6f, 0xc4, 0xb0, 0xcc,
+	0xe6, 0x8d, 0xdf, 0x7e, 0xbc, 0x2a, 0x7d, 0xf8, 0xf1, 0xaa, 0xf4, 0xe7, 0x8f, 0x57, 0xa5, 0x9f,
+	0xfd, 0x75, 0x75, 0x09, 0x4e, 0x3b, 0xb8, 0x1f, 0x1b, 0xa7, 0xd5, 0x75, 0xab, 0xfd, 0x5b, 0x7b,
+	0xd2, 0x3b, 0x72, 0xf5, 0xf5, 0xfe, 0xad, 0x83, 0x3c, 0x4d, 0x0f, 0x2f, 0xfe, 0x2f, 0x00, 0x00,
+	0xff, 0xff, 0xe9, 0x52, 0x7f, 0x36, 0x2b, 0x2a, 0x00, 0x00,
 }
 
 func (m *Snapshot) Marshal() (dAtA []byte, err error) {
@@ -6716,6 +6818,55 @@ func (m *TextNodePos) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *TextNodeBoundary) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TextNodeBoundary) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TextNodeBoundary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Type != 0 {
+		i = encodeVarintResources(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.Offset != 0 {
+		i = encodeVarintResources(dAtA, i, uint64(m.Offset))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.CreatedAt != nil {
+		{
+			size, err := m.CreatedAt.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintResources(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *TimeTicket) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -8175,6 +8326,28 @@ func (m *TextNodePos) Size() (n int) {
 	return n
 }
 
+func (m *TextNodeBoundary) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CreatedAt != nil {
+		l = m.CreatedAt.Size()
+		n += 1 + l + sovResources(uint64(l))
+	}
+	if m.Offset != 0 {
+		n += 1 + sovResources(uint64(m.Offset))
+	}
+	if m.Type != 0 {
+		n += 1 + sovResources(uint64(m.Type))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *TimeTicket) Size() (n int) {
 	if m == nil {
 		return 0
@@ -10926,7 +11099,7 @@ func (m *Operation_Style) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.From == nil {
-				m.From = &TextNodePos{}
+				m.From = &TextNodeBoundary{}
 			}
 			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -10962,7 +11135,7 @@ func (m *Operation_Style) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.To == nil {
-				m.To = &TextNodePos{}
+				m.To = &TextNodeBoundary{}
 			}
 			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -16827,6 +17000,131 @@ func (m *TextNodePos) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *TextNodeBoundary) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowResources
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TextNodeBoundary: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TextNodeBoundary: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowResources
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthResources
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthResources
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.CreatedAt == nil {
+				m.CreatedAt = &TimeTicket{}
+			}
+			if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
+			}
+			m.Offset = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowResources
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Offset |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowResources
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= BoundaryType(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipResources(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthResources
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *TimeTicket) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/api/yorkie/v1/resources.proto b/api/yorkie/v1/resources.proto
index 75947b1df..7e5bec2e3 100644
--- a/api/yorkie/v1/resources.proto
+++ b/api/yorkie/v1/resources.proto
@@ -107,8 +107,8 @@ message Operation {
   }
   message Style {
     TimeTicket parent_created_at = 1;
-    TextNodePos from = 2;
-    TextNodePos to = 3;
+    TextNodeBoundary from = 2;
+    TextNodeBoundary to = 3;
     map<string, string> attributes = 4;
     TimeTicket executed_at = 5;
     map<string, TimeTicket> created_at_map_by_actor = 6;
@@ -331,6 +331,19 @@ message TextNodePos {
   int32 relative_offset = 3;
 }
 
+enum BoundaryType {
+  BOUNDARY_TYPE_BEFORE = 0;
+  BOUNDARY_TYPE_AFTER = 1;
+  BOUNDARY_TYPE_START = 2;
+  BOUNDARY_TYPE_END = 3;
+}
+
+message TextNodeBoundary {
+  TimeTicket created_at = 1;
+  int32 offset = 2;
+  BoundaryType type = 3;
+}
+
 message TimeTicket {
   int64 lamport = 1 [jstype = JS_STRING];
   uint32 delimiter = 2;
diff --git a/pkg/document/crdt/rga_tree_split.go b/pkg/document/crdt/rga_tree_split.go
index 54ab7306d..f1d77b903 100644
--- a/pkg/document/crdt/rga_tree_split.go
+++ b/pkg/document/crdt/rga_tree_split.go
@@ -14,6 +14,17 @@ var (
 	initialNodeID = NewRGATreeSplitNodeID(time.InitialTicket, 0)
 )
 
+// BoundaryType represents any type that can be used as a boundary.
+type BoundaryType string
+
+// The values below are the types that can be used as boundary.
+const (
+	Before BoundaryType = "before"
+	After  BoundaryType = "after"
+	Start  BoundaryType = "start"
+	End    BoundaryType = "end"
+)
+
 // RGATreeSplitValue is a value of RGATreeSplitNode.
 type RGATreeSplitValue interface {
 	Split(offset int) RGATreeSplitValue
@@ -144,6 +155,27 @@ func (pos *RGATreeSplitNodePos) Equal(other *RGATreeSplitNodePos) bool {
 	return pos.relativeOffset == other.relativeOffset
 }
 
+// RGATreeSplitNodeBoundary is a boundary of RGATreeSplitNode.
+type RGATreeSplitNodeBoundary struct {
+	id           *RGATreeSplitNodeID
+	boundaryType BoundaryType
+}
+
+// NewRGATreeSplitNodeBoundary creates a new instance of NewRGATreeSplitNodeBoundary.
+func NewRGATreeSplitNodeBoundary(id *RGATreeSplitNodeID, boundaryType BoundaryType) *RGATreeSplitNodeBoundary {
+	return &RGATreeSplitNodeBoundary{id, boundaryType}
+}
+
+// ID returns the ID of this RGATreeSplitNodeBoundary.
+func (boundary *RGATreeSplitNodeBoundary) ID() *RGATreeSplitNodeID {
+	return boundary.id
+}
+
+// Type returns the boundary type of this RGATreeSplitNodeBoundary.
+func (boundary *RGATreeSplitNodeBoundary) Type() BoundaryType {
+	return boundary.boundaryType
+}
+
 // RGATreeSplitNode is a node of RGATreeSplit.
 type RGATreeSplitNode[V RGATreeSplitValue] struct {
 	id        *RGATreeSplitNodeID
@@ -354,6 +386,27 @@ func (s *RGATreeSplit[V]) findNodeWithSplit(
 	return node, node.next, nil
 }
 
+func (s *RGATreeSplit[V]) splitNodeByBoundary(
+	boundary *RGATreeSplitNodeBoundary,
+) error {
+	absoluteID := boundary.ID()
+	if absoluteID.CreatedAt() != nil {
+		node, err := s.findFloorNodePreferToLeft(absoluteID)
+		if err != nil {
+			return err
+		}
+
+		relativeOffset := absoluteID.offset - node.id.offset
+
+		_, err = s.splitNode(node, relativeOffset)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (s *RGATreeSplit[V]) findFloorNodePreferToLeft(id *RGATreeSplitNodeID) (*RGATreeSplitNode[V], error) {
 	node := s.findFloorNode(id)
 	if node == nil {
diff --git a/pkg/document/crdt/root_test.go b/pkg/document/crdt/root_test.go
index df8f69a6e..248a890bd 100644
--- a/pkg/document/crdt/root_test.go
+++ b/pkg/document/crdt/root_test.go
@@ -63,28 +63,28 @@ func TestRoot(t *testing.T) {
 		ctx := helper.TextChangeContext(root)
 		text := crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ctx.IssueTimeTicket())
 
-		fromPos, toPos, _ := text.CreateRange(0, 0)
+		fromPos, toPos, _ := text.CreatePosRange(0, 0)
 		_, _, err := text.Edit(fromPos, toPos, nil, "Hello World", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
 		assert.Equal(t, "Hello World", text.String())
 		assert.Equal(t, 0, root.GarbageLen())
 
-		fromPos, toPos, _ = text.CreateRange(5, 10)
+		fromPos, toPos, _ = text.CreatePosRange(5, 10)
 		_, _, err = text.Edit(fromPos, toPos, nil, "Yorkie", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
 		assert.Equal(t, "HelloYorkied", text.String())
 		assert.Equal(t, 1, root.GarbageLen())
 
-		fromPos, toPos, _ = text.CreateRange(0, 5)
+		fromPos, toPos, _ = text.CreatePosRange(0, 5)
 		_, _, err = text.Edit(fromPos, toPos, nil, "", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
 		assert.Equal(t, "Yorkied", text.String())
 		assert.Equal(t, 2, root.GarbageLen())
 
-		fromPos, toPos, _ = text.CreateRange(6, 7)
+		fromPos, toPos, _ = text.CreatePosRange(6, 7)
 		_, _, err = text.Edit(fromPos, toPos, nil, "", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
@@ -125,7 +125,7 @@ func TestRoot(t *testing.T) {
 		}
 
 		for _, tc := range tests {
-			fromPos, toPos, _ := text.CreateRange(tc.from, tc.to)
+			fromPos, toPos, _ := text.CreatePosRange(tc.from, tc.to)
 			_, _, err := text.Edit(fromPos, toPos, nil, tc.content, nil, ctx.IssueTimeTicket())
 			assert.NoError(t, err)
 			registerElementHasRemovedNodes(fromPos, toPos, root, text)
@@ -144,21 +144,21 @@ func TestRoot(t *testing.T) {
 		ctx := helper.TextChangeContext(root)
 		text := crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ctx.IssueTimeTicket())
 
-		fromPos, toPos, _ := text.CreateRange(0, 0)
+		fromPos, toPos, _ := text.CreatePosRange(0, 0)
 		_, _, err := text.Edit(fromPos, toPos, nil, "Hello World", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
 		assert.Equal(t, `[{"val":"Hello World"}]`, text.Marshal())
 		assert.Equal(t, 0, root.GarbageLen())
 
-		fromPos, toPos, _ = text.CreateRange(6, 11)
+		fromPos, toPos, _ = text.CreatePosRange(6, 11)
 		_, _, err = text.Edit(fromPos, toPos, nil, "Yorkie", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
 		assert.Equal(t, `[{"val":"Hello "},{"val":"Yorkie"}]`, text.Marshal())
 		assert.Equal(t, 1, root.GarbageLen())
 
-		fromPos, toPos, _ = text.CreateRange(0, 6)
+		fromPos, toPos, _ = text.CreatePosRange(0, 6)
 		_, _, err = text.Edit(fromPos, toPos, nil, "", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		registerElementHasRemovedNodes(fromPos, toPos, root, text)
diff --git a/pkg/document/crdt/text.go b/pkg/document/crdt/text.go
index be33ce9be..5d35e058f 100644
--- a/pkg/document/crdt/text.go
+++ b/pkg/document/crdt/text.go
@@ -218,11 +218,24 @@ func (t *Text) Remove(removedAt *time.Ticket) bool {
 	return false
 }
 
-// CreateRange returns a pair of RGATreeSplitNodePos of the given integer offsets.
-func (t *Text) CreateRange(from, to int) (*RGATreeSplitNodePos, *RGATreeSplitNodePos, error) {
+// CreatePosRange returns a pair of RGATreeSplitNodePos of the given integer offsets.
+func (t *Text) CreatePosRange(from, to int) (*RGATreeSplitNodePos, *RGATreeSplitNodePos, error) {
 	return t.rgaTreeSplit.createRange(from, to)
 }
 
+// CreateBoundaryRange returns a pair of RGATreeSplitNodeBoundary of the given pos.
+func (t *Text) CreateBoundaryRange(from, to *RGATreeSplitNodePos, editedAt *time.Ticket) (*RGATreeSplitNodeBoundary, *RGATreeSplitNodeBoundary, error) {
+	_, fromRight, err := t.rgaTreeSplit.findNodeWithSplit(from, editedAt)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, toRight, err := t.rgaTreeSplit.findNodeWithSplit(to, editedAt)
+	if err != nil {
+		return nil, nil, err
+	}
+	return NewRGATreeSplitNodeBoundary(fromRight.ID(), ""), NewRGATreeSplitNodeBoundary(toRight.ID(), ""), nil
+}
+
 // Edit edits the given range with the given content and attributes.
 func (t *Text) Edit(
 	from,
@@ -249,23 +262,37 @@ func (t *Text) Edit(
 // Style applies the given attributes of the given range.
 func (t *Text) Style(
 	from,
-	to *RGATreeSplitNodePos,
+	to *RGATreeSplitNodeBoundary,
 	latestCreatedAtMapByActor map[string]*time.Ticket,
 	attributes map[string]string,
 	executedAt *time.Ticket,
 ) (map[string]*time.Ticket, error) {
-	// 01. Split nodes with from and to
-	_, toRight, err := t.rgaTreeSplit.findNodeWithSplit(to, executedAt)
-	if err != nil {
-		return nil, err
-	}
-	_, fromRight, err := t.rgaTreeSplit.findNodeWithSplit(from, executedAt)
-	if err != nil {
-		return nil, err
+	// 01. Split nodes with boundaryRange if it is a remote operation
+	isRemote := latestCreatedAtMapByActor != nil
+	if isRemote {
+		err := t.rgaTreeSplit.splitNodeByBoundary(to)
+		if err != nil {
+			return nil, err
+		}
+		err = t.rgaTreeSplit.splitNodeByBoundary(from)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// 02. style nodes between from and to
-	nodes := t.rgaTreeSplit.findBetween(fromRight, toRight)
+	if from.Type() != "" && to.Type() != "" {
+		// 02-1. Update styleOpsBefore and styleOpsAfter if it is a bold type
+		// TODO(MoonGyu1): Peritext 2. Update styleOpsBefore/styleOpsAfter of fromRight/toRight nodes
+
+		createdAtMapByActor := make(map[string]*time.Ticket)
+		return createdAtMapByActor, nil
+	}
+	// 02-2. Apply the existing logic to style nodes if they are not of a bold type
+	fromNode := t.rgaTreeSplit.FindNode(from.ID())
+	toNode := t.rgaTreeSplit.FindNode(to.ID())
+
+	nodes := t.rgaTreeSplit.findBetween(fromNode, toNode)
 	createdAtMapByActor := make(map[string]*time.Ticket)
 	var toBeStyled []*RGATreeSplitNode[*TextValue]
 
diff --git a/pkg/document/crdt/text_test.go b/pkg/document/crdt/text_test.go
index 0b2ee5ed1..ba90cfc27 100644
--- a/pkg/document/crdt/text_test.go
+++ b/pkg/document/crdt/text_test.go
@@ -31,12 +31,12 @@ func TestText(t *testing.T) {
 		ctx := helper.TextChangeContext(root)
 		text := crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ctx.IssueTimeTicket())
 
-		fromPos, toPos, _ := text.CreateRange(0, 0)
+		fromPos, toPos, _ := text.CreatePosRange(0, 0)
 		_, _, err := text.Edit(fromPos, toPos, nil, "Hello World", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		assert.Equal(t, `[{"val":"Hello World"}]`, text.Marshal())
 
-		fromPos, toPos, _ = text.CreateRange(6, 11)
+		fromPos, toPos, _ = text.CreatePosRange(6, 11)
 		_, _, err = text.Edit(fromPos, toPos, nil, "Yorkie", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		assert.Equal(t, `[{"val":"Hello "},{"val":"Yorkie"}]`, text.Marshal())
@@ -69,23 +69,24 @@ func TestText(t *testing.T) {
 		ctx := helper.TextChangeContext(root)
 		text := crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ctx.IssueTimeTicket())
 
-		fromPos, toPos, _ := text.CreateRange(0, 0)
+		fromPos, toPos, _ := text.CreatePosRange(0, 0)
 		_, _, err := text.Edit(fromPos, toPos, nil, "Hello World", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		assert.Equal(t, `[{"val":"Hello World"}]`, text.Marshal())
 
-		fromPos, toPos, _ = text.CreateRange(6, 11)
+		fromPos, toPos, _ = text.CreatePosRange(6, 11)
 		_, _, err = text.Edit(fromPos, toPos, nil, "Yorkie", nil, ctx.IssueTimeTicket())
 		assert.NoError(t, err)
 		assert.Equal(t, `[{"val":"Hello "},{"val":"Yorkie"}]`, text.Marshal())
 
-		fromPos, toPos, _ = text.CreateRange(0, 1)
-		_, err = text.Style(fromPos, toPos, nil, map[string]string{"b": "1"}, ctx.IssueTimeTicket())
-		assert.NoError(t, err)
-		assert.Equal(
-			t,
-			`[{"attrs":{"b":"1"},"val":"H"},{"val":"ello "},{"val":"Yorkie"}]`,
-			text.Marshal(),
-		)
+		// TODO(MoonGyu1): Remove annotation after implementing addMark operation
+		// fromPos, toPos, _ = text.CreatePosRange(0, 1)
+		// _, err = text.Style(fromPos, toPos, nil, map[string]string{"b": "1"}, ctx.IssueTimeTicket())
+		// assert.NoError(t, err)
+		// assert.Equal(
+		// 	t,
+		// 	`[{"attrs":{"b":"1"},"val":"H"},{"val":"ello "},{"val":"Yorkie"}]`,
+		// 	text.Marshal(),
+		// )
 	})
 }
diff --git a/pkg/document/json/text.go b/pkg/document/json/text.go
index fc053e6f7..b25e6657e 100644
--- a/pkg/document/json/text.go
+++ b/pkg/document/json/text.go
@@ -39,7 +39,7 @@ func NewText(ctx *change.Context, text *crdt.Text) *Text {
 
 // CreateRange creates a range from the given positions.
 func (p *Text) CreateRange(from, to int) (*crdt.RGATreeSplitNodePos, *crdt.RGATreeSplitNodePos) {
-	fromPos, toPos, err := p.Text.CreateRange(from, to)
+	fromPos, toPos, err := p.Text.CreatePosRange(from, to)
 	if err != nil {
 		panic(err)
 	}
@@ -51,7 +51,7 @@ func (p *Text) Edit(from, to int, content string, attributes ...map[string]strin
 	if from > to {
 		panic("from should be less than or equal to to")
 	}
-	fromPos, toPos, err := p.Text.CreateRange(from, to)
+	fromPos, toPos, err := p.Text.CreatePosRange(from, to)
 	if err != nil {
 		panic(err)
 	}
@@ -97,15 +97,27 @@ func (p *Text) Style(from, to int, attributes map[string]string) *Text {
 	if from > to {
 		panic("from should be less than or equal to to")
 	}
-	fromPos, toPos, err := p.Text.CreateRange(from, to)
+	fromPos, toPos, err := p.Text.CreatePosRange(from, to)
 	if err != nil {
 		panic(err)
 	}
 
 	ticket := p.context.IssueTimeTicket()
-	maxCreationMapByActor, err := p.Text.Style(
+
+	fromBoundary, toBoundary, err := p.Text.CreateBoundaryRange(
 		fromPos,
 		toPos,
+		ticket,
+		// TODO(MoonGyu1): Add mark spec if it is a mark operation
+		// expand,
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	maxCreationMapByActor, err := p.Text.Style(
+		fromBoundary,
+		toBoundary,
 		nil,
 		attributes,
 		ticket,
@@ -116,8 +128,8 @@ func (p *Text) Style(from, to int, attributes map[string]string) *Text {
 
 	p.context.Push(operations.NewStyle(
 		p.CreatedAt(),
-		fromPos,
-		toPos,
+		fromBoundary,
+		toBoundary,
 		maxCreationMapByActor,
 		attributes,
 		ticket,
diff --git a/pkg/document/operations/style.go b/pkg/document/operations/style.go
index 5394bc9de..cfbb29c5e 100644
--- a/pkg/document/operations/style.go
+++ b/pkg/document/operations/style.go
@@ -27,10 +27,10 @@ type Style struct {
 	parentCreatedAt *time.Ticket
 
 	// from is the starting point of the range to apply the style to.
-	from *crdt.RGATreeSplitNodePos
+	from *crdt.RGATreeSplitNodeBoundary
 
 	// to is the end point of the range to apply the style to.
-	to *crdt.RGATreeSplitNodePos
+	to *crdt.RGATreeSplitNodeBoundary
 
 	// latestCreatedAtMapByActor is a map that stores the latest creation time
 	// by actor for the nodes included in the range to apply the style to.
@@ -46,8 +46,8 @@ type Style struct {
 // NewStyle creates a new instance of Style.
 func NewStyle(
 	parentCreatedAt *time.Ticket,
-	from *crdt.RGATreeSplitNodePos,
-	to *crdt.RGATreeSplitNodePos,
+	from *crdt.RGATreeSplitNodeBoundary,
+	to *crdt.RGATreeSplitNodeBoundary,
 	latestCreatedAtMapByActor map[string]*time.Ticket,
 	attributes map[string]string,
 	executedAt *time.Ticket,
@@ -75,12 +75,12 @@ func (e *Style) Execute(root *crdt.Root) error {
 }
 
 // From returns the start point of the editing range.
-func (e *Style) From() *crdt.RGATreeSplitNodePos {
+func (e *Style) From() *crdt.RGATreeSplitNodeBoundary {
 	return e.from
 }
 
 // To returns the end point of the editing range.
-func (e *Style) To() *crdt.RGATreeSplitNodePos {
+func (e *Style) To() *crdt.RGATreeSplitNodeBoundary {
 	return e.to
 }