diff --git a/api/adminservice/v1/request_response.pb.go b/api/adminservice/v1/request_response.pb.go
index d8f47250e53..c8c0bc7f934 100644
--- a/api/adminservice/v1/request_response.pb.go
+++ b/api/adminservice/v1/request_response.pb.go
@@ -1005,6 +1005,7 @@ type GetWorkflowExecutionRawHistoryV2Response struct {
 	NextPageToken  []byte              `protobuf:"bytes,1,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
 	HistoryBatches []*v1.DataBlob      `protobuf:"bytes,2,rep,name=history_batches,json=historyBatches,proto3" json:"history_batches,omitempty"`
 	VersionHistory *v14.VersionHistory `protobuf:"bytes,3,opt,name=version_history,json=versionHistory,proto3" json:"version_history,omitempty"`
+	HistoryNodeIds []int64             `protobuf:"varint,4,rep,packed,name=history_node_ids,json=historyNodeIds,proto3" json:"history_node_ids,omitempty"`
 }
 
 func (m *GetWorkflowExecutionRawHistoryV2Response) Reset() {
@@ -1062,6 +1063,13 @@ func (m *GetWorkflowExecutionRawHistoryV2Response) GetVersionHistory() *v14.Vers
 	return nil
 }
 
+func (m *GetWorkflowExecutionRawHistoryV2Response) GetHistoryNodeIds() []int64 {
+	if m != nil {
+		return m.HistoryNodeIds
+	}
+	return nil
+}
+
 type GetReplicationMessagesRequest struct {
 	Tokens      []*v15.ReplicationToken `protobuf:"bytes,1,rep,name=tokens,proto3" json:"tokens,omitempty"`
 	ClusterName string                  `protobuf:"bytes,2,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
@@ -3123,14 +3131,14 @@ func init() {
 }
 
 var fileDescriptor_cc07c1a2abe7cb51 = []byte{
-	// 2924 bytes of a gzipped FileDescriptorProto
+	// 2948 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3a, 0xcd, 0x6f, 0x1b, 0xc7,
 	0xf5, 0x5e, 0x52, 0x94, 0xc8, 0x27, 0x89, 0x92, 0xd6, 0x96, 0x45, 0x53, 0x11, 0xa5, 0x30, 0x8e,
 	0x63, 0xfb, 0x97, 0x50, 0x3f, 0x2b, 0x6d, 0xe2, 0x24, 0x0d, 0x02, 0x59, 0x76, 0x64, 0xa1, 0x52,
 	0x3e, 0x96, 0x8e, 0x5d, 0x04, 0x08, 0x36, 0xc3, 0xdd, 0x11, 0xb5, 0xf0, 0x72, 0x77, 0xb3, 0x33,
-	0xa4, 0xad, 0x00, 0xfd, 0x40, 0xd3, 0x02, 0xbd, 0x14, 0x35, 0x50, 0x14, 0x08, 0xf2, 0x17, 0xb4,
-	0x40, 0x8b, 0xde, 0x7a, 0xef, 0x2d, 0xc7, 0xa0, 0xa7, 0xa0, 0x2d, 0x90, 0x46, 0xb9, 0xb4, 0xb7,
-	0x9c, 0x7a, 0x2e, 0xe6, 0x6b, 0x3f, 0xc8, 0x25, 0x45, 0xd5, 0xb1, 0x0b, 0xe4, 0xc6, 0x7d, 0xf3,
+	0xa4, 0xad, 0x00, 0xfd, 0x40, 0xd3, 0x02, 0xbd, 0x14, 0x35, 0x50, 0x14, 0x08, 0x72, 0xea, 0xb1,
+	0x05, 0x5a, 0xf4, 0xd6, 0x7b, 0x6f, 0x39, 0x06, 0x3d, 0x05, 0x6d, 0x81, 0x34, 0xca, 0xa5, 0xbd,
+	0xe5, 0x4f, 0x28, 0xe6, 0x6b, 0x3f, 0xc8, 0x25, 0x45, 0xd5, 0xb1, 0x0b, 0xe4, 0xc6, 0x7d, 0xf3,
 	0xde, 0x9b, 0x37, 0xef, 0x6b, 0xde, 0x7b, 0x43, 0x78, 0x99, 0xe2, 0x4e, 0xe0, 0x87, 0xc8, 0x5d,
 	0x27, 0x38, 0xec, 0xe1, 0x70, 0x1d, 0x05, 0xce, 0x3a, 0xb2, 0x3b, 0x8e, 0xc7, 0xbe, 0x1d, 0x0b,
 	0xaf, 0xf7, 0xae, 0xac, 0x87, 0xf8, 0x83, 0x2e, 0x26, 0xd4, 0x0c, 0x31, 0x09, 0x7c, 0x8f, 0xe0,
@@ -3154,13 +3162,13 @@ var fileDescriptor_cc07c1a2abe7cb51 = []byte{
 	0x56, 0xb4, 0x35, 0xed, 0x62, 0xc9, 0x88, 0x01, 0xfa, 0x36, 0x94, 0xa2, 0x13, 0x54, 0x72, 0x6b,
 	0xda, 0xc5, 0xe9, 0x8d, 0x4b, 0x91, 0x00, 0x3c, 0x64, 0xa5, 0xc7, 0xf4, 0xae, 0x34, 0xee, 0x48,
 	0xa9, 0x6f, 0x28, 0x02, 0x23, 0xa6, 0xad, 0xaf, 0xc0, 0x72, 0xa6, 0x10, 0x22, 0x27, 0xd4, 0x7f,
-	0xa6, 0xc1, 0xf2, 0x75, 0x4c, 0xac, 0xd0, 0x69, 0xe1, 0xff, 0xa1, 0x94, 0x7f, 0xca, 0xc1, 0x13,
+	0xa6, 0xc1, 0xf2, 0x75, 0x4c, 0xac, 0xd0, 0x69, 0xe1, 0xff, 0xa1, 0x94, 0x7f, 0xce, 0xc1, 0x13,
 	0xd9, 0x62, 0x08, 0x39, 0xf5, 0x73, 0x50, 0x24, 0x07, 0x28, 0xb4, 0x4d, 0xc7, 0x96, 0x62, 0x4c,
 	0xf1, 0xef, 0x1d, 0x5b, 0x7f, 0x12, 0x66, 0xa4, 0x1b, 0x9b, 0xc8, 0xb6, 0x43, 0x2e, 0x47, 0xc9,
 	0x98, 0x96, 0xb0, 0x4d, 0xdb, 0x0e, 0xf5, 0x03, 0x38, 0x6d, 0x21, 0xeb, 0x00, 0xa7, 0xed, 0x5a,
 	0xc9, 0x73, 0x89, 0xaf, 0x36, 0xb2, 0x32, 0x62, 0xc2, 0xb0, 0x49, 0xe9, 0x53, 0xc2, 0x2d, 0x70,
 	0xa6, 0x49, 0x90, 0xee, 0xc1, 0x59, 0xe6, 0xa8, 0x2d, 0x44, 0xfa, 0x37, 0x9b, 0x78, 0xc8, 0xcd,
-	0xce, 0x28, 0xbe, 0x49, 0x68, 0xfd, 0x2f, 0x1a, 0x54, 0x95, 0xe2, 0x6e, 0x8a, 0x13, 0xdf, 0xf4,
+	0xce, 0x28, 0xbe, 0x49, 0x68, 0xfd, 0xaf, 0x1a, 0x54, 0x95, 0xe2, 0x6e, 0x8a, 0x13, 0xdf, 0xf4,
 	0x09, 0x55, 0xe6, 0x63, 0xba, 0xf1, 0x09, 0xe5, 0x8a, 0xc1, 0x84, 0x48, 0xd5, 0x4d, 0x33, 0xd8,
 	0xa6, 0x00, 0xa5, 0x34, 0xcb, 0x54, 0x57, 0x88, 0x35, 0x9b, 0x32, 0x7e, 0xbe, 0xdf, 0xf8, 0x3f,
 	0x00, 0x3d, 0x8a, 0x97, 0xd8, 0x0b, 0x26, 0x4e, 0xea, 0x05, 0x0b, 0xf7, 0xfa, 0x41, 0xf5, 0x07,
@@ -3191,7 +3199,7 @@ var fileDescriptor_cc07c1a2abe7cb51 = []byte{
 	0x8d, 0x0b, 0xc7, 0x1b, 0xf7, 0xd6, 0x61, 0x80, 0x8d, 0x22, 0x95, 0xbf, 0xf4, 0x57, 0xa1, 0xb4,
 	0xef, 0x84, 0xd8, 0x64, 0x55, 0x6b, 0x65, 0x92, 0xdb, 0xb5, 0xda, 0x10, 0x15, 0x6b, 0x43, 0x55,
 	0xac, 0x8d, 0x5b, 0xaa, 0xa4, 0xbd, 0x36, 0xf1, 0xe0, 0x8b, 0x55, 0xcd, 0x28, 0x32, 0x12, 0x06,
-	0x64, 0x61, 0x28, 0x8b, 0xc3, 0xca, 0x14, 0x17, 0x4e, 0x7d, 0xd6, 0xff, 0xaa, 0xc1, 0x82, 0x81,
+	0x64, 0x61, 0x28, 0x8b, 0xc3, 0xca, 0x14, 0x17, 0x4e, 0x7d, 0xd6, 0xff, 0xa6, 0xc1, 0x82, 0x81,
 	0x3b, 0x7e, 0x0f, 0x73, 0xc5, 0x3e, 0x3e, 0x57, 0x4d, 0xe8, 0x2b, 0x9f, 0xd2, 0xd7, 0x0e, 0xcc,
 	0xf5, 0x1c, 0xe2, 0xb4, 0x1c, 0xd7, 0xa1, 0x87, 0xe2, 0xc0, 0x13, 0x63, 0x1e, 0xb8, 0x1c, 0x13,
 	0xb2, 0x25, 0x96, 0x33, 0x92, 0x67, 0x93, 0x39, 0xe3, 0x17, 0x79, 0x78, 0x66, 0x1b, 0xd3, 0xc1,
@@ -3201,112 +3209,114 @@ var fileDescriptor_cc07c1a2abe7cb51 = []byte{
 	0x06, 0x7b, 0x76, 0xcc, 0xb3, 0xc0, 0x11, 0x01, 0x7b, 0xb6, 0xe2, 0x78, 0x19, 0x16, 0x62, 0x0c,
 	0xc5, 0x6f, 0x92, 0xa3, 0xcd, 0x29, 0x34, 0xc5, 0xed, 0x32, 0x2c, 0x74, 0xd0, 0x7d, 0xa7, 0xd3,
 	0xed, 0x88, 0x78, 0xe3, 0x89, 0x61, 0x8a, 0x3b, 0xc7, 0x9c, 0x5c, 0x60, 0x11, 0x37, 0x2c, 0x3d,
-	0x14, 0xb3, 0x02, 0xf3, 0xdf, 0x1a, 0x5c, 0x3c, 0xde, 0x14, 0x32, 0x5d, 0x64, 0x30, 0xd5, 0x32,
-	0x98, 0x32, 0x07, 0x52, 0xe5, 0x13, 0x4f, 0x58, 0x58, 0xdc, 0x96, 0xd3, 0x1b, 0x6b, 0xc3, 0x6c,
-	0x73, 0x1d, 0x51, 0x74, 0xcd, 0xf5, 0x5b, 0x46, 0x59, 0x12, 0x5e, 0x13, 0x74, 0xfa, 0x1d, 0x98,
-	0x93, 0x5a, 0x31, 0xe5, 0x8a, 0x4c, 0xaa, 0x8d, 0xe3, 0x92, 0xaa, 0xd4, 0x9a, 0x3c, 0x85, 0x51,
-	0xee, 0xa5, 0xbe, 0xeb, 0x0f, 0x34, 0x58, 0xd9, 0xc6, 0xd4, 0x88, 0xfb, 0x89, 0x3d, 0xd1, 0x4b,
-	0x44, 0xb7, 0xc5, 0x2e, 0x4c, 0xf2, 0x33, 0xaa, 0xec, 0x98, 0x7d, 0x8f, 0x27, 0x1a, 0x12, 0xb6,
-	0x6b, 0x82, 0x1f, 0xd7, 0x85, 0x21, 0x79, 0xb0, 0xc4, 0xa7, 0x5a, 0x0f, 0xe6, 0xbe, 0xaa, 0xa4,
-	0x94, 0x30, 0x56, 0x00, 0xd4, 0x3f, 0xc9, 0x41, 0x6d, 0x98, 0x48, 0xd2, 0x02, 0x3f, 0x84, 0xb2,
-	0x48, 0x0b, 0xb2, 0xf1, 0x51, 0xb2, 0xdd, 0x1e, 0x2b, 0x73, 0x8f, 0x66, 0x2e, 0xee, 0x53, 0x05,
-	0xbd, 0xe1, 0xd1, 0xf0, 0xd0, 0x10, 0x45, 0x91, 0x82, 0x55, 0x0f, 0x41, 0x1f, 0x44, 0xd2, 0xe7,
-	0x21, 0x7f, 0x17, 0x1f, 0xca, 0x34, 0xc5, 0x7e, 0xea, 0x7b, 0x50, 0xe8, 0x21, 0xb7, 0x8b, 0x65,
-	0x48, 0xbe, 0x78, 0x42, 0xcd, 0x45, 0x92, 0x09, 0x2e, 0x2f, 0xe7, 0xae, 0x6a, 0xf5, 0x3f, 0x6b,
-	0x70, 0x61, 0x1b, 0xd3, 0xa8, 0x52, 0x1a, 0x61, 0xb8, 0x97, 0xe0, 0x9c, 0x8b, 0xf8, 0x94, 0x82,
-	0x86, 0x0e, 0xee, 0xe1, 0x48, 0x5b, 0x2a, 0x99, 0xe6, 0x8d, 0xb3, 0x0c, 0xc1, 0x50, 0xeb, 0x92,
-	0xc1, 0x8e, 0x1d, 0x91, 0x06, 0xa1, 0x6f, 0x61, 0x42, 0xd2, 0xa4, 0xb9, 0x98, 0xf4, 0x2d, 0xb5,
-	0x1e, 0x93, 0xf6, 0x1b, 0x38, 0x3f, 0x68, 0xe0, 0x1f, 0xf1, 0xb4, 0x37, 0xfa, 0x08, 0xd2, 0xd0,
-	0x4d, 0x28, 0x26, 0x4c, 0xfc, 0x50, 0x4a, 0x8c, 0x18, 0xd5, 0x3f, 0x84, 0xb5, 0x6d, 0x4c, 0xaf,
-	0xef, 0xbe, 0x3d, 0x42, 0x79, 0xb7, 0x65, 0x01, 0xc3, 0x8a, 0x31, 0xe5, 0x5d, 0x27, 0xdd, 0x9a,
-	0x25, 0x7b, 0x51, 0x97, 0x51, 0xf9, 0x8b, 0xd4, 0x7f, 0xae, 0xc1, 0x93, 0x23, 0x36, 0x97, 0xc7,
-	0x7e, 0x1f, 0x16, 0x12, 0x6c, 0xcd, 0x64, 0x71, 0xf2, 0xfc, 0x7f, 0x21, 0x84, 0x31, 0x1f, 0xa6,
-	0x01, 0xa4, 0xfe, 0xa9, 0x06, 0x67, 0x0c, 0x8c, 0x82, 0xc0, 0x3d, 0xe4, 0xc9, 0x95, 0x8c, 0x77,
-	0xd1, 0x64, 0x77, 0x26, 0xb9, 0x87, 0xef, 0x4c, 0xf4, 0xab, 0x30, 0xc9, 0xb3, 0x3f, 0x91, 0x89,
-	0xed, 0xf8, 0x1c, 0x29, 0xf1, 0xeb, 0x4b, 0xb0, 0xd8, 0x77, 0x12, 0x79, 0xbf, 0xfe, 0x3d, 0x07,
-	0xd5, 0x4d, 0xdb, 0x6e, 0x62, 0x14, 0x5a, 0x07, 0x9b, 0x94, 0x86, 0x4e, 0xab, 0x4b, 0x63, 0x13,
-	0xff, 0x54, 0x83, 0x05, 0xc2, 0xd7, 0x4c, 0x14, 0x2d, 0x4a, 0x2d, 0xbf, 0x33, 0x56, 0x22, 0x19,
-	0xce, 0xbc, 0xd1, 0x0f, 0x17, 0x79, 0x64, 0x9e, 0xf4, 0x81, 0x59, 0x79, 0xeb, 0x78, 0x36, 0xbe,
-	0x9f, 0xcc, 0x86, 0x25, 0x0e, 0x61, 0xf1, 0xa1, 0x3f, 0x0b, 0x3a, 0xb9, 0xeb, 0x04, 0x26, 0xb1,
-	0x0e, 0x70, 0x07, 0x99, 0xdd, 0xc0, 0x56, 0xdd, 0x75, 0xd1, 0x98, 0x67, 0x2b, 0x4d, 0xbe, 0xf0,
-	0x0e, 0x87, 0x57, 0x5d, 0x58, 0xcc, 0xdc, 0x37, 0x99, 0x9a, 0x4a, 0x22, 0x35, 0xbd, 0x9a, 0x4c,
-	0x4d, 0xe5, 0x8d, 0x67, 0xd2, 0xda, 0x8e, 0x6a, 0xa6, 0x1d, 0x26, 0x09, 0xb6, 0x6f, 0x33, 0x54,
-	0x5e, 0x09, 0x26, 0x52, 0xd1, 0x0a, 0x2c, 0x67, 0x2a, 0x40, 0x6a, 0xff, 0x2e, 0xac, 0x88, 0x9a,
-	0x67, 0x98, 0xfe, 0xff, 0x6f, 0x98, 0xfa, 0x4b, 0x27, 0xd6, 0x53, 0x7d, 0x0d, 0x6a, 0xc3, 0x36,
-	0x93, 0xe2, 0xbc, 0x02, 0x55, 0xd6, 0x72, 0x0d, 0x91, 0x25, 0xcd, 0x5e, 0xeb, 0x67, 0xff, 0xc9,
-	0x24, 0x2c, 0x67, 0x52, 0xcb, 0x78, 0xfd, 0x48, 0x83, 0x05, 0xab, 0x4b, 0xa8, 0xdf, 0x19, 0x74,
-	0xa5, 0xb1, 0xef, 0xa4, 0x61, 0xdc, 0x1b, 0x5b, 0x9c, 0xf3, 0x80, 0x2f, 0x59, 0x7d, 0x60, 0x2e,
-	0x05, 0x39, 0x24, 0x14, 0xa7, 0xa4, 0xc8, 0x7d, 0x43, 0x52, 0x34, 0x39, 0xe7, 0x41, 0x8f, 0xee,
-	0x03, 0xeb, 0x6d, 0x98, 0xea, 0xa0, 0x20, 0x70, 0xbc, 0x76, 0x25, 0xcf, 0xb7, 0xde, 0x7b, 0xe8,
-	0xad, 0xf7, 0x04, 0x3f, 0xb1, 0xa3, 0xe2, 0xae, 0x7b, 0xb0, 0x8c, 0x6c, 0xdb, 0x1c, 0xcc, 0x47,
-	0xa2, 0x83, 0x16, 0xb5, 0xfa, 0x7a, 0xda, 0xb1, 0x15, 0x72, 0x66, 0x5a, 0xe2, 0xb9, 0xba, 0x82,
-	0x6c, 0x3b, 0x73, 0x85, 0x45, 0x57, 0xa6, 0x25, 0x1e, 0x49, 0x74, 0xf1, 0x58, 0xce, 0xd2, 0xf8,
-	0xa3, 0xd9, 0xed, 0x65, 0x98, 0x49, 0x2a, 0x39, 0x63, 0x93, 0x33, 0xc9, 0x4d, 0x4a, 0xc9, 0x3c,
-	0xf0, 0x0a, 0x9c, 0x55, 0x23, 0xa5, 0x2d, 0x71, 0xcb, 0x27, 0x66, 0x64, 0xa9, 0x5a, 0x40, 0x1b,
-	0xac, 0x05, 0x7e, 0x37, 0x09, 0x4b, 0x03, 0xd4, 0x32, 0xaa, 0x7e, 0x0c, 0x0b, 0xa4, 0x1b, 0x04,
-	0x7e, 0x48, 0xb1, 0x6d, 0x5a, 0xae, 0xc3, 0x6f, 0x07, 0x11, 0x54, 0xc6, 0x58, 0x3e, 0x35, 0x84,
-	0x71, 0xa3, 0xa9, 0xb8, 0x6e, 0x09, 0xa6, 0xca, 0x95, 0xfb, 0xc0, 0xfa, 0xd3, 0x50, 0x16, 0xdc,
-	0xa3, 0x96, 0x44, 0x1c, 0x7e, 0x56, 0x40, 0x55, 0x43, 0x72, 0x07, 0xe6, 0x3a, 0xb8, 0xd3, 0xc2,
-	0x21, 0x39, 0x70, 0x02, 0xe1, 0x7c, 0xa3, 0x8a, 0x73, 0xf5, 0xca, 0xd0, 0xbb, 0xd2, 0xd8, 0x8b,
-	0xc8, 0xc4, 0xb0, 0xab, 0x93, 0xfa, 0x66, 0x59, 0x49, 0xe9, 0x4f, 0x76, 0xf3, 0x25, 0xa3, 0x24,
-	0x21, 0x19, 0xa5, 0x56, 0x61, 0x40, 0xbd, 0xac, 0x53, 0x53, 0x2d, 0x88, 0x1a, 0x9b, 0x75, 0x3d,
-	0xca, 0x3b, 0xab, 0x82, 0xb1, 0x20, 0x97, 0x9a, 0x62, 0x62, 0xd6, 0xf5, 0x78, 0x4e, 0x4e, 0x4c,
-	0x97, 0x4c, 0xb6, 0x2c, 0x7a, 0xab, 0x92, 0x31, 0x9f, 0x58, 0x68, 0x32, 0xb8, 0x7e, 0x09, 0xe6,
-	0x13, 0x0d, 0xb2, 0xc0, 0x2d, 0x72, 0xdc, 0x44, 0xe3, 0x2c, 0x50, 0xb7, 0x61, 0x46, 0xf5, 0x2f,
-	0x5c, 0x3f, 0x25, 0xae, 0x9f, 0xf3, 0x69, 0x4f, 0x95, 0x18, 0x89, 0xae, 0x85, 0x6b, 0x65, 0xba,
-	0x17, 0x7f, 0xe8, 0xdf, 0x83, 0xea, 0x3e, 0x72, 0x5c, 0x3f, 0x61, 0x14, 0xd3, 0xf1, 0xac, 0x10,
-	0x77, 0xb0, 0x47, 0x2b, 0xc0, 0x4b, 0xd3, 0x8a, 0xc2, 0x88, 0xb8, 0xc8, 0x75, 0xfd, 0x2a, 0x54,
-	0x1c, 0xcf, 0xa1, 0x0e, 0x72, 0xcd, 0x7e, 0x2e, 0x95, 0x69, 0x51, 0xd6, 0xca, 0xf5, 0xd7, 0xd3,
-	0x2c, 0xf4, 0x57, 0x61, 0xd9, 0x21, 0x66, 0xdb, 0xf5, 0x5b, 0xc8, 0x35, 0xe3, 0xd1, 0x0d, 0xf6,
-	0x50, 0xcb, 0xc5, 0x76, 0x65, 0x86, 0xdf, 0xc8, 0x15, 0x87, 0x6c, 0x73, 0x8c, 0xa8, 0xb6, 0xbd,
-	0x21, 0xd6, 0xab, 0x5b, 0xb0, 0x98, 0xe9, 0x74, 0x27, 0x0a, 0xb4, 0x77, 0xe1, 0xf4, 0xae, 0x43,
-	0xa8, 0xf4, 0xe6, 0xe8, 0xee, 0x5a, 0x86, 0x52, 0xdc, 0x07, 0x8b, 0xee, 0xa3, 0x18, 0x8c, 0x68,
-	0x80, 0x33, 0x27, 0x53, 0xbf, 0xd2, 0xe0, 0x4c, 0x9a, 0xb9, 0x0c, 0xc2, 0x37, 0xa1, 0x28, 0x1d,
-	0x6a, 0x74, 0x05, 0xda, 0x37, 0x94, 0x94, 0x7c, 0xf6, 0xe4, 0xf3, 0x92, 0x11, 0x31, 0x19, 0x5b,
-	0xa2, 0xdf, 0x68, 0xb0, 0xba, 0x69, 0xdb, 0x6f, 0x86, 0xa2, 0xb8, 0x61, 0xd7, 0x3b, 0xed, 0x4f,
-	0x30, 0x97, 0x60, 0x7e, 0x3f, 0xf4, 0x3d, 0x8a, 0x3d, 0xbb, 0x6f, 0x10, 0x3f, 0xa7, 0xe0, 0x6a,
-	0x18, 0xbf, 0x0d, 0x6b, 0xc2, 0x58, 0x66, 0xc8, 0x39, 0x99, 0x2a, 0x74, 0x2c, 0xdf, 0xf3, 0xb0,
-	0x15, 0xd5, 0xb1, 0x45, 0x63, 0x45, 0xe0, 0xa5, 0x36, 0xdc, 0x8a, 0x90, 0xea, 0x75, 0x58, 0x1b,
-	0x2e, 0x96, 0x2c, 0x36, 0x5e, 0x83, 0xaa, 0x28, 0x47, 0x32, 0xa5, 0x1e, 0x23, 0x2d, 0xf2, 0xb7,
-	0xa5, 0x0c, 0x06, 0x92, 0xff, 0xaf, 0xf3, 0x70, 0x2e, 0x61, 0x2d, 0x99, 0x46, 0x14, 0xff, 0x26,
-	0x2c, 0xf2, 0xee, 0xed, 0x00, 0xa3, 0x90, 0xb6, 0x30, 0xa2, 0xe6, 0x3d, 0x87, 0x1e, 0x38, 0x9e,
-	0xec, 0xa0, 0xce, 0x0d, 0x8c, 0xaf, 0xae, 0xcb, 0x17, 0xe6, 0x6b, 0x13, 0x1f, 0x7f, 0xb1, 0xaa,
-	0x19, 0xa7, 0x19, 0xf5, 0x4d, 0x45, 0x7c, 0x87, 0xd3, 0xea, 0xab, 0x30, 0x1d, 0x06, 0x56, 0xa4,
-	0x65, 0x39, 0x8e, 0x0c, 0x03, 0x4b, 0x29, 0x78, 0x09, 0xa6, 0xf8, 0x83, 0x48, 0x34, 0x8f, 0x9c,
-	0x64, 0x9f, 0x7c, 0xee, 0x38, 0x11, 0xfa, 0xae, 0x18, 0x9e, 0x95, 0x93, 0x17, 0x72, 0xd6, 0x90,
-	0x2e, 0x75, 0x22, 0xc3, 0x77, 0xb1, 0xc1, 0x89, 0xf5, 0xf7, 0xa0, 0x4a, 0x30, 0xe1, 0xe1, 0xce,
-	0xe7, 0x4b, 0xd8, 0x36, 0xd1, 0x3e, 0xd3, 0x20, 0x9f, 0xcb, 0x15, 0xc6, 0x9c, 0xcb, 0x2d, 0x49,
-	0x1e, 0x4d, 0xc1, 0x62, 0x93, 0x71, 0xe0, 0x73, 0xc9, 0x54, 0x0c, 0x4d, 0x1e, 0x1f, 0x43, 0x53,
-	0x59, 0x1e, 0xfb, 0x89, 0x06, 0xd5, 0x2c, 0xab, 0xc8, 0x48, 0xba, 0x05, 0x65, 0x64, 0x51, 0xa7,
-	0x87, 0x4d, 0x99, 0xe6, 0x65, 0x3c, 0x3d, 0x77, 0xdc, 0x2d, 0x91, 0xd6, 0xc9, 0xac, 0x60, 0x22,
-	0xb9, 0x8f, 0x1d, 0x4e, 0x7f, 0xc8, 0xc1, 0xa2, 0x68, 0x3c, 0xfb, 0x5b, 0xdd, 0x1b, 0x30, 0xc1,
-	0x47, 0xc2, 0x1a, 0xb7, 0xcf, 0x95, 0xd1, 0xf6, 0xb9, 0x8e, 0x91, 0xbd, 0x8b, 0x29, 0xc5, 0xe1,
-	0xdb, 0x5d, 0x2c, 0xeb, 0x08, 0x4e, 0x3e, 0xea, 0xb5, 0x8b, 0xdd, 0xa3, 0x7e, 0x37, 0xb4, 0xa2,
-	0xa0, 0x93, 0x1e, 0x32, 0x2b, 0xa0, 0xf2, 0x7c, 0xfa, 0x8b, 0x2c, 0x3b, 0x33, 0x0c, 0xa6, 0x23,
-	0x16, 0xd2, 0x89, 0xa1, 0x83, 0x98, 0x2d, 0x2e, 0x46, 0xeb, 0x37, 0xbc, 0xc4, 0xcc, 0x21, 0x73,
-	0x22, 0x58, 0x18, 0x7b, 0x22, 0x38, 0x99, 0xa5, 0xaf, 0x7f, 0x69, 0x70, 0xb6, 0x5f, 0x5f, 0xd2,
-	0x90, 0xdf, 0x90, 0xc2, 0x32, 0x9b, 0xfc, 0xdc, 0x37, 0xd8, 0xe4, 0x67, 0x9d, 0x35, 0x9f, 0x75,
-	0xd6, 0xbf, 0x69, 0xb0, 0xf4, 0x56, 0x37, 0x6c, 0xe3, 0x6f, 0xa3, 0x77, 0xd4, 0xab, 0x50, 0x19,
-	0x3c, 0x9c, 0x4c, 0xa4, 0x7f, 0xcc, 0xc1, 0xd2, 0x1e, 0xfe, 0x96, 0x9e, 0xfc, 0x91, 0xc4, 0xc5,
-	0x35, 0xa8, 0x0c, 0x2a, 0xec, 0x64, 0x83, 0x71, 0xfe, 0xd7, 0x08, 0x03, 0xef, 0x87, 0x98, 0x1c,
-	0xa8, 0x56, 0x2b, 0xf5, 0x40, 0xf9, 0x98, 0xfe, 0x1a, 0x51, 0x83, 0x27, 0xb2, 0xa5, 0x88, 0x9d,
-	0x63, 0xc5, 0xc0, 0x04, 0x7b, 0x76, 0x5f, 0xa8, 0x91, 0xc4, 0x4d, 0xfe, 0xa8, 0x9e, 0xf1, 0x9e,
-	0x86, 0x72, 0xba, 0x50, 0x91, 0xf5, 0xff, 0x6c, 0x98, 0xac, 0x08, 0x32, 0x1e, 0x6c, 0x0a, 0x19,
-	0x0f, 0x36, 0x4f, 0xc1, 0xac, 0xc0, 0x4a, 0x3f, 0xad, 0x08, 0xa4, 0x61, 0xaf, 0x34, 0x53, 0x03,
-	0xaf, 0x34, 0xab, 0x30, 0xcd, 0x30, 0x14, 0x93, 0x62, 0x84, 0x20, 0x59, 0x88, 0x31, 0x4c, 0xb6,
-	0xc2, 0xa4, 0x4e, 0x7f, 0x9f, 0x83, 0xca, 0x36, 0xa6, 0x0c, 0x28, 0x02, 0x65, 0x7c, 0xbb, 0xaf,
-	0xc8, 0x91, 0x2c, 0xff, 0x77, 0x9a, 0x1a, 0x01, 0x51, 0xc5, 0x48, 0xdf, 0x85, 0xb9, 0x78, 0x59,
-	0x3c, 0x72, 0xe6, 0x79, 0xe4, 0x9e, 0x1f, 0xd2, 0x0f, 0xc7, 0x32, 0xb0, 0x60, 0x9d, 0xa5, 0xc9,
-	0x4f, 0xbd, 0x06, 0xd3, 0x1d, 0x47, 0x24, 0xe5, 0x38, 0xcc, 0x4a, 0x1d, 0x47, 0x0c, 0x75, 0x6d,
-	0xbe, 0x8e, 0xee, 0x47, 0xeb, 0x05, 0xb9, 0x8e, 0xee, 0xcb, 0xf5, 0xf4, 0xb3, 0xf5, 0xe4, 0x18,
-	0xcf, 0xd6, 0x99, 0x25, 0xc5, 0x03, 0x0d, 0xce, 0x65, 0xa8, 0x4b, 0xc6, 0xdb, 0xf7, 0xd3, 0xef,
-	0xd6, 0xdf, 0x1d, 0xa7, 0x30, 0xdf, 0x74, 0x5d, 0xdf, 0x42, 0x14, 0xdb, 0xd1, 0x74, 0xfa, 0x64,
-	0x6f, 0xd8, 0xd7, 0xdc, 0xcf, 0xbe, 0xac, 0x9d, 0xfa, 0xfc, 0xcb, 0xda, 0xa9, 0xaf, 0xbf, 0xac,
-	0x69, 0x3f, 0x39, 0xaa, 0x69, 0xbf, 0x3d, 0xaa, 0x69, 0x9f, 0x1e, 0xd5, 0xb4, 0xcf, 0x8e, 0x6a,
-	0xda, 0x3f, 0x8e, 0x6a, 0xda, 0x3f, 0x8f, 0x6a, 0xa7, 0xbe, 0x3e, 0xaa, 0x69, 0x0f, 0xbe, 0xaa,
-	0x9d, 0xfa, 0xec, 0xab, 0xda, 0xa9, 0xcf, 0xbf, 0xaa, 0x9d, 0x7a, 0xf7, 0x85, 0xb6, 0x1f, 0x4b,
-	0xe7, 0xf8, 0x23, 0xfe, 0x5d, 0xf9, 0x4a, 0xf2, 0xbb, 0x35, 0xc9, 0x6b, 0xb9, 0xe7, 0xff, 0x13,
-	0x00, 0x00, 0xff, 0xff, 0xb0, 0xb9, 0x50, 0x61, 0x98, 0x29, 0x00, 0x00,
+	0x14, 0xb3, 0x02, 0xf3, 0xb7, 0x39, 0xb8, 0x78, 0xbc, 0x29, 0x64, 0xba, 0xc8, 0x60, 0xaa, 0x65,
+	0x30, 0x65, 0x0e, 0xa4, 0xca, 0x27, 0x9e, 0xb0, 0xb0, 0xb8, 0x2d, 0xa7, 0x37, 0xd6, 0x86, 0xd9,
+	0xe6, 0x3a, 0xa2, 0xe8, 0x9a, 0xeb, 0xb7, 0x8c, 0xb2, 0x24, 0xbc, 0x26, 0xe8, 0xf4, 0x3b, 0x30,
+	0x27, 0xb5, 0x62, 0xca, 0x15, 0x99, 0x54, 0x1b, 0xc7, 0x25, 0x55, 0xa9, 0x35, 0x79, 0x0a, 0xa3,
+	0xdc, 0x4b, 0x7d, 0xeb, 0x17, 0x61, 0x5e, 0xc9, 0xe8, 0xf9, 0x36, 0xe6, 0x57, 0xfa, 0xc4, 0x5a,
+	0xfe, 0x62, 0x3e, 0x12, 0xe1, 0x0d, 0xdf, 0xc6, 0x3b, 0x36, 0xa9, 0x3f, 0xd0, 0x60, 0x65, 0x1b,
+	0x53, 0x23, 0xee, 0x3c, 0xf6, 0x44, 0xd7, 0x11, 0xdd, 0x2b, 0xbb, 0x30, 0xc9, 0xb5, 0xa1, 0xf2,
+	0x68, 0xf6, 0x8d, 0x9f, 0x68, 0x5d, 0x98, 0x7c, 0x09, 0x7e, 0x5c, 0x6b, 0x86, 0xe4, 0xc1, 0x52,
+	0xa4, 0x6a, 0x52, 0x98, 0xa3, 0xab, 0xe2, 0x53, 0xc2, 0x58, 0xa9, 0x50, 0xff, 0x24, 0x07, 0xb5,
+	0x61, 0x22, 0x49, 0x5b, 0xfd, 0x10, 0xca, 0x22, 0x81, 0xc8, 0x16, 0x49, 0xc9, 0x76, 0x7b, 0xac,
+	0x1c, 0x3f, 0x9a, 0xb9, 0xb8, 0x79, 0x15, 0xf4, 0x86, 0x47, 0xc3, 0x43, 0x43, 0x94, 0x4f, 0x0a,
+	0x56, 0x3d, 0x04, 0x7d, 0x10, 0x49, 0x9f, 0x87, 0xfc, 0x5d, 0x7c, 0x28, 0x13, 0x1a, 0xfb, 0xa9,
+	0xef, 0x41, 0xa1, 0x87, 0xdc, 0x2e, 0x96, 0xc1, 0xfb, 0xe2, 0x09, 0x35, 0x17, 0x49, 0x26, 0xb8,
+	0xbc, 0x9c, 0xbb, 0xaa, 0xd5, 0xff, 0xa2, 0xc1, 0x85, 0x6d, 0x4c, 0xa3, 0x9a, 0x6a, 0x84, 0xe1,
+	0x5e, 0x82, 0x73, 0x2e, 0xe2, 0xf3, 0x0c, 0x1a, 0x3a, 0xb8, 0x87, 0x23, 0x6d, 0xa9, 0xb4, 0x9b,
+	0x37, 0xce, 0x32, 0x04, 0x43, 0xad, 0x4b, 0x06, 0x3b, 0x76, 0x44, 0x1a, 0x84, 0xbe, 0x85, 0x09,
+	0x49, 0x93, 0xe6, 0x62, 0xd2, 0xb7, 0xd4, 0x7a, 0x4c, 0xda, 0x6f, 0xe0, 0xfc, 0xa0, 0x81, 0x7f,
+	0xc4, 0x13, 0xe4, 0xe8, 0x23, 0x48, 0x43, 0x37, 0xa1, 0x98, 0x30, 0xf1, 0x43, 0x29, 0x31, 0x62,
+	0x54, 0xff, 0x10, 0xd6, 0xb6, 0x31, 0xbd, 0xbe, 0xfb, 0xf6, 0x08, 0xe5, 0xdd, 0x96, 0xa5, 0x0e,
+	0x2b, 0xdb, 0x94, 0x77, 0x9d, 0x74, 0x6b, 0x76, 0x2d, 0x88, 0x0a, 0x8e, 0xca, 0x5f, 0xa4, 0xfe,
+	0x73, 0x0d, 0x9e, 0x1c, 0xb1, 0xb9, 0x3c, 0xf6, 0xfb, 0xb0, 0x90, 0x60, 0x6b, 0x26, 0xcb, 0x98,
+	0xe7, 0xff, 0x0b, 0x21, 0x8c, 0xf9, 0x30, 0x0d, 0x20, 0xf5, 0x4f, 0x35, 0x38, 0x63, 0x60, 0x14,
+	0x04, 0xee, 0x21, 0x4f, 0xc3, 0x64, 0xbc, 0x2b, 0x29, 0xbb, 0x87, 0xc9, 0x3d, 0x7c, 0x0f, 0xa3,
+	0x5f, 0x85, 0x49, 0x7e, 0x4f, 0x10, 0x99, 0x02, 0x8f, 0xcf, 0xa6, 0x12, 0xbf, 0xbe, 0x04, 0x8b,
+	0x7d, 0x27, 0x91, 0x37, 0xf1, 0x3f, 0x72, 0x50, 0xdd, 0xb4, 0xed, 0x26, 0x46, 0xa1, 0x75, 0xb0,
+	0x49, 0x69, 0xe8, 0xb4, 0xba, 0x34, 0x36, 0xf1, 0x4f, 0x35, 0x58, 0x20, 0x7c, 0xcd, 0x44, 0xd1,
+	0xa2, 0xd4, 0xf2, 0x3b, 0x63, 0x25, 0x92, 0xe1, 0xcc, 0x1b, 0xfd, 0x70, 0x91, 0x47, 0xe6, 0x49,
+	0x1f, 0x98, 0x15, 0xc2, 0x8e, 0x67, 0xe3, 0xfb, 0xc9, 0x6c, 0x58, 0xe2, 0x10, 0x16, 0x1f, 0xfa,
+	0xb3, 0xa0, 0x93, 0xbb, 0x4e, 0x60, 0x12, 0xeb, 0x00, 0x77, 0x90, 0xd9, 0x0d, 0x6c, 0xd5, 0x87,
+	0x17, 0x8d, 0x79, 0xb6, 0xd2, 0xe4, 0x0b, 0xef, 0x70, 0x78, 0xd5, 0x85, 0xc5, 0xcc, 0x7d, 0x93,
+	0xa9, 0xa9, 0x24, 0x52, 0xd3, 0xab, 0xc9, 0xd4, 0x54, 0xde, 0x78, 0x26, 0xad, 0xed, 0xa8, 0xba,
+	0xda, 0x61, 0x92, 0x60, 0xfb, 0x36, 0x43, 0xe5, 0x35, 0x63, 0x22, 0x15, 0xad, 0xc0, 0x72, 0xa6,
+	0x02, 0xa4, 0xf6, 0xef, 0xc2, 0x8a, 0xa8, 0x8e, 0x86, 0xe9, 0xff, 0xff, 0x86, 0xa9, 0xbf, 0x74,
+	0x62, 0x3d, 0xd5, 0xd7, 0xa0, 0x36, 0x6c, 0x33, 0x29, 0xce, 0x2b, 0x50, 0x65, 0xcd, 0xd9, 0x10,
+	0x59, 0xd2, 0xec, 0xb5, 0x7e, 0xf6, 0x9f, 0x4c, 0xc2, 0x72, 0x26, 0xb5, 0x8c, 0xd7, 0x8f, 0x34,
+	0x58, 0xb0, 0xba, 0x84, 0xfa, 0x9d, 0x41, 0x57, 0x1a, 0xfb, 0x4e, 0x1a, 0xc6, 0xbd, 0xb1, 0xc5,
+	0x39, 0x0f, 0xf8, 0x92, 0xd5, 0x07, 0xe6, 0x52, 0x90, 0x43, 0x42, 0x71, 0x4a, 0x8a, 0xdc, 0x37,
+	0x24, 0x45, 0x93, 0x73, 0x1e, 0xf4, 0xe8, 0x3e, 0xb0, 0xde, 0x86, 0xa9, 0x0e, 0x0a, 0x02, 0xc7,
+	0x6b, 0x57, 0xf2, 0x7c, 0xeb, 0xbd, 0x87, 0xde, 0x7a, 0x4f, 0xf0, 0x13, 0x3b, 0x2a, 0xee, 0xba,
+	0x07, 0xcb, 0xc8, 0xb6, 0xcd, 0xc1, 0x7c, 0x24, 0x7a, 0x6d, 0x51, 0xd5, 0xaf, 0xa7, 0x1d, 0x5b,
+	0x21, 0x67, 0xa6, 0x25, 0x9e, 0xab, 0x2b, 0xc8, 0xb6, 0x33, 0x57, 0x58, 0x74, 0x65, 0x5a, 0xe2,
+	0x91, 0x44, 0x17, 0x8f, 0xe5, 0x2c, 0x8d, 0x3f, 0x9a, 0xdd, 0x5e, 0x86, 0x99, 0xa4, 0x92, 0x33,
+	0x36, 0x39, 0x93, 0xdc, 0xa4, 0x94, 0xcc, 0x03, 0xaf, 0xc0, 0x59, 0x35, 0x7c, 0xda, 0x12, 0xb7,
+	0x7c, 0x62, 0x9a, 0x96, 0xaa, 0x05, 0xb4, 0xc1, 0x5a, 0xe0, 0xf7, 0x93, 0xb0, 0x34, 0x40, 0x2d,
+	0xa3, 0xea, 0xc7, 0xb0, 0x40, 0xba, 0x41, 0xe0, 0x87, 0x14, 0xdb, 0xa6, 0xe5, 0x3a, 0xfc, 0x76,
+	0x10, 0x41, 0x65, 0x8c, 0xe5, 0x53, 0x43, 0x18, 0x37, 0x9a, 0x8a, 0xeb, 0x96, 0x60, 0xaa, 0x5c,
+	0xb9, 0x0f, 0xac, 0x3f, 0x0d, 0x65, 0xc1, 0x3d, 0x6a, 0x5e, 0xc4, 0xe1, 0x67, 0x05, 0x54, 0xb5,
+	0x2e, 0x77, 0x60, 0xae, 0x83, 0x3b, 0x2d, 0x1c, 0x92, 0x03, 0x27, 0x10, 0xce, 0x37, 0xaa, 0x8c,
+	0x57, 0xef, 0x11, 0xbd, 0x2b, 0x8d, 0xbd, 0x88, 0x4c, 0x8c, 0xc5, 0x3a, 0xa9, 0x6f, 0x96, 0x95,
+	0x94, 0xfe, 0x64, 0xdf, 0x5f, 0x32, 0x4a, 0x12, 0x92, 0x51, 0x6a, 0x15, 0x06, 0xd4, 0xcb, 0x7a,
+	0x3a, 0xd5, 0x08, 0xa8, 0x01, 0x5b, 0xd7, 0xa3, 0xbc, 0x07, 0x2b, 0x18, 0x0b, 0x72, 0xa9, 0x29,
+	0x66, 0x6b, 0x5d, 0x8f, 0xe7, 0xe4, 0xc4, 0x1c, 0xca, 0x64, 0xcb, 0xa2, 0x0b, 0x2b, 0x19, 0xf3,
+	0x89, 0x85, 0x26, 0x83, 0xeb, 0x97, 0x60, 0x3e, 0xd1, 0x4a, 0x0b, 0xdc, 0x22, 0xc7, 0x4d, 0xb4,
+	0xd8, 0x02, 0x75, 0x1b, 0x66, 0x54, 0xa7, 0xc3, 0xf5, 0x53, 0xe2, 0xfa, 0x39, 0x9f, 0xf6, 0x54,
+	0x89, 0x91, 0xe8, 0x6f, 0xb8, 0x56, 0xa6, 0x7b, 0xf1, 0x87, 0xfe, 0x3d, 0xa8, 0xee, 0x23, 0xc7,
+	0xf5, 0x13, 0x46, 0x31, 0x1d, 0xcf, 0x0a, 0x71, 0x07, 0x7b, 0xb4, 0x02, 0xbc, 0x34, 0xad, 0x28,
+	0x8c, 0x88, 0x8b, 0x5c, 0xd7, 0xaf, 0x42, 0xc5, 0xf1, 0x1c, 0xea, 0x20, 0xd7, 0xec, 0xe7, 0x52,
+	0x99, 0x16, 0x65, 0xad, 0x5c, 0x7f, 0x3d, 0xcd, 0x42, 0x7f, 0x15, 0x96, 0x1d, 0x62, 0xb6, 0x5d,
+	0xbf, 0x85, 0x5c, 0x33, 0x1e, 0xf2, 0x60, 0x0f, 0xb5, 0x5c, 0x6c, 0x57, 0x66, 0xf8, 0x8d, 0x5c,
+	0x71, 0xc8, 0x36, 0xc7, 0x88, 0x6a, 0xdb, 0x1b, 0x62, 0xbd, 0xba, 0x05, 0x8b, 0x99, 0x4e, 0x77,
+	0xa2, 0x40, 0x7b, 0x17, 0x4e, 0xef, 0x3a, 0x84, 0x4a, 0x6f, 0x8e, 0xee, 0xae, 0x65, 0x28, 0xc5,
+	0x1d, 0xb3, 0xe8, 0x3e, 0x8a, 0xc1, 0x88, 0x56, 0x39, 0x73, 0x86, 0xf5, 0x2b, 0x0d, 0xce, 0xa4,
+	0x99, 0xcb, 0x20, 0x7c, 0x13, 0x8a, 0xd2, 0xa1, 0x46, 0x57, 0xa0, 0x7d, 0xe3, 0x4b, 0xc9, 0x67,
+	0x4f, 0x3e, 0x44, 0x19, 0x11, 0x93, 0xb1, 0x25, 0xfa, 0x8d, 0x06, 0xab, 0x9b, 0xb6, 0xfd, 0x66,
+	0x28, 0x8a, 0x1b, 0x76, 0xbd, 0xd3, 0xfe, 0x04, 0x73, 0x09, 0xe6, 0xf7, 0x43, 0xdf, 0xa3, 0xd8,
+	0xb3, 0xfb, 0x46, 0xf6, 0x73, 0x0a, 0xae, 0xc6, 0xf6, 0xdb, 0xb0, 0x26, 0x8c, 0x65, 0x86, 0x9c,
+	0x93, 0xa9, 0x42, 0xc7, 0xf2, 0x3d, 0x0f, 0x5b, 0x51, 0x1d, 0x5b, 0x34, 0x56, 0x04, 0x5e, 0x6a,
+	0xc3, 0xad, 0x08, 0xa9, 0x5e, 0x87, 0xb5, 0xe1, 0x62, 0xc9, 0x62, 0xe3, 0x35, 0xa8, 0x8a, 0x72,
+	0x24, 0x53, 0xea, 0x31, 0xd2, 0x22, 0x7f, 0x85, 0xca, 0x60, 0x20, 0xf9, 0xff, 0x3a, 0x0f, 0xe7,
+	0x12, 0xd6, 0x92, 0x69, 0x44, 0xf1, 0x6f, 0xc2, 0x22, 0xef, 0xde, 0x0e, 0x30, 0x0a, 0x69, 0x0b,
+	0x23, 0x6a, 0xde, 0x73, 0xe8, 0x81, 0xe3, 0xc9, 0x0e, 0xea, 0xdc, 0xc0, 0xa0, 0xeb, 0xba, 0x7c,
+	0x8b, 0xbe, 0x36, 0xf1, 0xf1, 0x17, 0xab, 0x9a, 0x71, 0x9a, 0x51, 0xdf, 0x54, 0xc4, 0x77, 0x38,
+	0xad, 0xbe, 0x0a, 0xd3, 0x61, 0x60, 0x45, 0x5a, 0x96, 0x83, 0xcb, 0x30, 0xb0, 0x94, 0x82, 0x97,
+	0x60, 0x8a, 0x3f, 0x9d, 0x44, 0x93, 0xcb, 0x49, 0xf6, 0xc9, 0x27, 0x94, 0x13, 0xa1, 0xef, 0x8a,
+	0x31, 0x5b, 0x39, 0x79, 0x21, 0x67, 0x8d, 0xf3, 0x52, 0x27, 0x32, 0x7c, 0x17, 0x1b, 0x9c, 0x58,
+	0x7f, 0x0f, 0xaa, 0x04, 0x13, 0x1e, 0xee, 0x7c, 0x12, 0x85, 0x6d, 0x13, 0xed, 0x33, 0x0d, 0xf2,
+	0x09, 0x5e, 0x61, 0xcc, 0x09, 0xde, 0x92, 0xe4, 0xd1, 0x14, 0x2c, 0x36, 0x19, 0x07, 0x3e, 0xc1,
+	0x4c, 0xc5, 0xd0, 0xe4, 0xf1, 0x31, 0x34, 0x95, 0xe5, 0xb1, 0x9f, 0x68, 0x50, 0xcd, 0xb2, 0x8a,
+	0x8c, 0xa4, 0x5b, 0x50, 0x46, 0x16, 0x75, 0x7a, 0xd8, 0x94, 0x69, 0x5e, 0xc6, 0xd3, 0x73, 0xc7,
+	0xdd, 0x12, 0x69, 0x9d, 0xcc, 0x0a, 0x26, 0x92, 0xfb, 0xd8, 0xe1, 0xf4, 0xc7, 0x1c, 0x2c, 0x8a,
+	0xc6, 0xb3, 0xbf, 0xd5, 0xbd, 0x01, 0x13, 0x7c, 0x78, 0xac, 0x71, 0xfb, 0x5c, 0x19, 0x6d, 0x9f,
+	0xeb, 0x18, 0xd9, 0xbb, 0x98, 0x52, 0x1c, 0xbe, 0xdd, 0xc5, 0xb2, 0x8e, 0xe0, 0xe4, 0xa3, 0xde,
+	0xc5, 0xd8, 0x3d, 0xea, 0x77, 0x43, 0x2b, 0x0a, 0x3a, 0xe9, 0x21, 0xb3, 0x02, 0x2a, 0xcf, 0xa7,
+	0xbf, 0xc8, 0xb2, 0x33, 0xc3, 0x60, 0x3a, 0x62, 0x21, 0x9d, 0x18, 0x3a, 0x88, 0x29, 0xe4, 0x62,
+	0xb4, 0x7e, 0xc3, 0x4b, 0xcc, 0x1c, 0x32, 0x67, 0x87, 0x85, 0xb1, 0x67, 0x87, 0x93, 0x59, 0xfa,
+	0xfa, 0xb7, 0x06, 0x67, 0xfb, 0xf5, 0x25, 0x0d, 0xf9, 0x0d, 0x29, 0x2c, 0xb3, 0xc9, 0xcf, 0x7d,
+	0x83, 0x4d, 0x7e, 0xd6, 0x59, 0xf3, 0x59, 0x67, 0xfd, 0xbb, 0x06, 0x4b, 0x6f, 0x75, 0xc3, 0x36,
+	0xfe, 0x36, 0x7a, 0x47, 0xbd, 0x0a, 0x95, 0xc1, 0xc3, 0xc9, 0x44, 0xfa, 0xa7, 0x1c, 0x2c, 0xed,
+	0xe1, 0x6f, 0xe9, 0xc9, 0x1f, 0x49, 0x5c, 0x5c, 0x83, 0xca, 0xa0, 0xc2, 0x4e, 0x36, 0x42, 0xe7,
+	0x7f, 0xa2, 0x30, 0xf0, 0x7e, 0x88, 0xc9, 0x81, 0x6a, 0xb5, 0x52, 0x4f, 0x99, 0x8f, 0xe9, 0x4f,
+	0x14, 0x35, 0x78, 0x22, 0x5b, 0x8a, 0xd8, 0x39, 0x56, 0x0c, 0x4c, 0xb0, 0x67, 0xf7, 0x85, 0x1a,
+	0x49, 0xdc, 0xe4, 0x8f, 0xea, 0xc1, 0xef, 0x69, 0x28, 0xa7, 0x0b, 0x15, 0x59, 0xff, 0xcf, 0x86,
+	0xc9, 0x8a, 0x20, 0xe3, 0x69, 0xa7, 0x90, 0xf1, 0xb4, 0xf3, 0x14, 0xcc, 0x0a, 0xac, 0xf4, 0x23,
+	0x8c, 0x40, 0x1a, 0xf6, 0x9e, 0x33, 0x35, 0xf0, 0x9e, 0xb3, 0x0a, 0xd3, 0x0c, 0x43, 0x31, 0x29,
+	0x46, 0x08, 0x92, 0x85, 0x18, 0xc3, 0x64, 0x2b, 0x4c, 0xea, 0xf4, 0x0f, 0x39, 0xa8, 0x6c, 0x63,
+	0xca, 0x80, 0x22, 0x50, 0xc6, 0xb7, 0xfb, 0x8a, 0x1c, 0xc9, 0xf2, 0xff, 0xb1, 0xa9, 0x11, 0x10,
+	0x55, 0x8c, 0xf4, 0x5d, 0x98, 0x8b, 0x97, 0xc5, 0x73, 0x68, 0x9e, 0x47, 0xee, 0xf9, 0x21, 0xfd,
+	0x70, 0x2c, 0x03, 0x0b, 0xd6, 0x59, 0x9a, 0xfc, 0xd4, 0x6b, 0x30, 0xdd, 0x71, 0x44, 0x52, 0x8e,
+	0xc3, 0xac, 0xd4, 0x71, 0xc4, 0x50, 0xd7, 0xe6, 0xeb, 0xe8, 0x7e, 0xb4, 0x5e, 0x90, 0xeb, 0xe8,
+	0xbe, 0x5c, 0x4f, 0x3f, 0x70, 0x4f, 0x8e, 0xf1, 0xc0, 0x9d, 0x59, 0x52, 0x3c, 0xd0, 0xe0, 0x5c,
+	0x86, 0xba, 0x64, 0xbc, 0x7d, 0x3f, 0xfd, 0xc2, 0xfd, 0xdd, 0x71, 0x0a, 0xf3, 0x4d, 0xd7, 0xf5,
+	0x2d, 0x44, 0xb1, 0x1d, 0x4d, 0xa7, 0x4f, 0xf6, 0xda, 0x7d, 0xcd, 0xfd, 0xec, 0xcb, 0xda, 0xa9,
+	0xcf, 0xbf, 0xac, 0x9d, 0xfa, 0xfa, 0xcb, 0x9a, 0xf6, 0x93, 0xa3, 0x9a, 0xf6, 0xbb, 0xa3, 0x9a,
+	0xf6, 0xe9, 0x51, 0x4d, 0xfb, 0xec, 0xa8, 0xa6, 0xfd, 0xf3, 0xa8, 0xa6, 0xfd, 0xeb, 0xa8, 0x76,
+	0xea, 0xeb, 0xa3, 0x9a, 0xf6, 0xe0, 0xab, 0xda, 0xa9, 0xcf, 0xbe, 0xaa, 0x9d, 0xfa, 0xfc, 0xab,
+	0xda, 0xa9, 0x77, 0x5f, 0x68, 0xfb, 0xb1, 0x74, 0x8e, 0x3f, 0xe2, 0x7f, 0x98, 0xaf, 0x24, 0xbf,
+	0x5b, 0x93, 0xbc, 0x96, 0x7b, 0xfe, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xf6, 0x05, 0x60,
+	0xc2, 0x29, 0x00, 0x00,
 }
 
 func (this *RebuildMutableStateRequest) Equal(that interface{}) bool {
@@ -3834,6 +3844,14 @@ func (this *GetWorkflowExecutionRawHistoryV2Response) Equal(that interface{}) bo
 	if !this.VersionHistory.Equal(that1.VersionHistory) {
 		return false
 	}
+	if len(this.HistoryNodeIds) != len(that1.HistoryNodeIds) {
+		return false
+	}
+	for i := range this.HistoryNodeIds {
+		if this.HistoryNodeIds[i] != that1.HistoryNodeIds[i] {
+			return false
+		}
+	}
 	return true
 }
 func (this *GetReplicationMessagesRequest) Equal(that interface{}) bool {
@@ -5156,7 +5174,7 @@ func (this *GetWorkflowExecutionRawHistoryV2Response) GoString() string {
 	if this == nil {
 		return "nil"
 	}
-	s := make([]string, 0, 7)
+	s := make([]string, 0, 8)
 	s = append(s, "&adminservice.GetWorkflowExecutionRawHistoryV2Response{")
 	s = append(s, "NextPageToken: "+fmt.Sprintf("%#v", this.NextPageToken)+",\n")
 	if this.HistoryBatches != nil {
@@ -5165,6 +5183,7 @@ func (this *GetWorkflowExecutionRawHistoryV2Response) GoString() string {
 	if this.VersionHistory != nil {
 		s = append(s, "VersionHistory: "+fmt.Sprintf("%#v", this.VersionHistory)+",\n")
 	}
+	s = append(s, "HistoryNodeIds: "+fmt.Sprintf("%#v", this.HistoryNodeIds)+",\n")
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
@@ -6434,6 +6453,25 @@ func (m *GetWorkflowExecutionRawHistoryV2Response) MarshalToSizedBuffer(dAtA []b
 	_ = i
 	var l int
 	_ = l
+	if len(m.HistoryNodeIds) > 0 {
+		dAtA15 := make([]byte, len(m.HistoryNodeIds)*10)
+		var j14 int
+		for _, num1 := range m.HistoryNodeIds {
+			num := uint64(num1)
+			for num >= 1<<7 {
+				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j14++
+			}
+			dAtA15[j14] = uint8(num)
+			j14++
+		}
+		i -= j14
+		copy(dAtA[i:], dAtA15[:j14])
+		i = encodeVarintRequestResponse(dAtA, i, uint64(j14))
+		i--
+		dAtA[i] = 0x22
+	}
 	if m.VersionHistory != nil {
 		{
 			size, err := m.VersionHistory.MarshalToSizedBuffer(dAtA[:i])
@@ -7431,12 +7469,12 @@ func (m *ListClusterMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
 		dAtA[i] = 0x30
 	}
 	if m.SessionStartedAfterTime != nil {
-		n22, err22 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SessionStartedAfterTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.SessionStartedAfterTime):])
-		if err22 != nil {
-			return 0, err22
+		n24, err24 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SessionStartedAfterTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.SessionStartedAfterTime):])
+		if err24 != nil {
+			return 0, err24
 		}
-		i -= n22
-		i = encodeVarintRequestResponse(dAtA, i, uint64(n22))
+		i -= n24
+		i = encodeVarintRequestResponse(dAtA, i, uint64(n24))
 		i--
 		dAtA[i] = 0x2a
 	}
@@ -7460,12 +7498,12 @@ func (m *ListClusterMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
 		dAtA[i] = 0x12
 	}
 	if m.LastHeartbeatWithin != nil {
-		n23, err23 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.LastHeartbeatWithin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.LastHeartbeatWithin):])
-		if err23 != nil {
-			return 0, err23
+		n25, err25 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.LastHeartbeatWithin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.LastHeartbeatWithin):])
+		if err25 != nil {
+			return 0, err25
 		}
-		i -= n23
-		i = encodeVarintRequestResponse(dAtA, i, uint64(n23))
+		i -= n25
+		i = encodeVarintRequestResponse(dAtA, i, uint64(n25))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -8390,6 +8428,13 @@ func (m *GetWorkflowExecutionRawHistoryV2Response) Size() (n int) {
 		l = m.VersionHistory.Size()
 		n += 1 + l + sovRequestResponse(uint64(l))
 	}
+	if len(m.HistoryNodeIds) > 0 {
+		l = 0
+		for _, e := range m.HistoryNodeIds {
+			l += sovRequestResponse(uint64(e))
+		}
+		n += 1 + sovRequestResponse(uint64(l)) + l
+	}
 	return n
 }
 
@@ -9305,6 +9350,7 @@ func (this *GetWorkflowExecutionRawHistoryV2Response) String() string {
 		`NextPageToken:` + fmt.Sprintf("%v", this.NextPageToken) + `,`,
 		`HistoryBatches:` + repeatedStringForHistoryBatches + `,`,
 		`VersionHistory:` + strings.Replace(fmt.Sprintf("%v", this.VersionHistory), "VersionHistory", "v14.VersionHistory", 1) + `,`,
+		`HistoryNodeIds:` + fmt.Sprintf("%v", this.HistoryNodeIds) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -12141,6 +12187,82 @@ func (m *GetWorkflowExecutionRawHistoryV2Response) Unmarshal(dAtA []byte) error
 				return err
 			}
 			iNdEx = postIndex
+		case 4:
+			if wireType == 0 {
+				var v int64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowRequestResponse
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.HistoryNodeIds = append(m.HistoryNodeIds, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowRequestResponse
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthRequestResponse
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthRequestResponse
+				}
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA[iNdEx:postIndex] {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.HistoryNodeIds) == 0 {
+					m.HistoryNodeIds = make([]int64, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v int64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowRequestResponse
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= int64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.HistoryNodeIds = append(m.HistoryNodeIds, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field HistoryNodeIds", wireType)
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRequestResponse(dAtA[iNdEx:])
diff --git a/common/metrics/defs.go b/common/metrics/defs.go
index 68bb8971cdf..592c2eb146f 100644
--- a/common/metrics/defs.go
+++ b/common/metrics/defs.go
@@ -664,6 +664,8 @@ const (
 
 	// PersistenceAppendHistoryNodesScope tracks AppendHistoryNodes calls made by service to persistence layer
 	PersistenceAppendHistoryNodesScope
+	// PersistenceAppendRawHistoryNodesScope tracks AppendRawHistoryNodes calls made by service to persistence layer
+	PersistenceAppendRawHistoryNodesScope
 	// PersistenceDeleteHistoryNodesScope tracks DeleteHistoryNodes calls made by service to persistence layer
 	PersistenceDeleteHistoryNodesScope
 	// PersistenceReadHistoryBranchScope tracks ReadHistoryBranch calls made by service to persistence layer
@@ -1289,6 +1291,7 @@ var ScopeDefs = map[ServiceIdx]map[int]scopeDefinition{
 		VisibilityPersistenceCountWorkflowExecutionsScope:                  {operation: "CountWorkflowExecutions", tags: map[string]string{visibilityTypeTagName: unknownValue}},
 
 		PersistenceAppendHistoryNodesScope:         {operation: "AppendHistoryNodes"},
+		PersistenceAppendRawHistoryNodesScope:      {operation: "AppendRawHistoryNodes"},
 		PersistenceDeleteHistoryNodesScope:         {operation: "DeleteHistoryNodes"},
 		PersistenceReadHistoryBranchScope:          {operation: "ReadHistoryBranch"},
 		PersistenceReadHistoryBranchReverseScope:   {operation: "ReadHistoryBranchReverse"},
diff --git a/common/persistence/dataInterfaces.go b/common/persistence/dataInterfaces.go
index c6d02d411c0..31f6a129058 100644
--- a/common/persistence/dataInterfaces.go
+++ b/common/persistence/dataInterfaces.go
@@ -719,6 +719,26 @@ type (
 		Size int
 	}
 
+	// AppendRawHistoryNodesRequest is used to append a batch of raw history nodes
+	AppendRawHistoryNodesRequest struct {
+		// The shard to get history node data
+		ShardID int32
+		// true if this is the first append request to the branch
+		IsNewBranch bool
+		// the info for clean up data in background
+		Info string
+		// The branch to be appended
+		BranchToken []byte
+		// The batch of events to be appended. The first eventID will become the nodeID of this batch
+		History *commonpb.DataBlob
+		// TransactionID for events before these events. For events chaining
+		PrevTransactionID int64
+		// requested TransactionID for this write operation. For the same eventID, the node with larger TransactionID always wins
+		TransactionID int64
+		// NodeID is the first event id.
+		NodeID int64
+	}
+
 	// ReadHistoryBranchRequest is used to read a history branch
 	ReadHistoryBranchRequest struct {
 		// The shard to get history branch data
@@ -795,6 +815,8 @@ type (
 	ReadRawHistoryBranchResponse struct {
 		// HistoryEventBlobs history event blobs
 		HistoryEventBlobs []*commonpb.DataBlob
+		// NodeIDs is the first event id of each history blob
+		NodeIDs []int64
 		// Token to read next page if there are more events beyond page size.
 		// Use this to set NextPageToken on ReadHistoryBranchRequest to read the next page.
 		// Empty means we have reached the last page, not need to continue
@@ -1026,6 +1048,8 @@ type (
 
 		// AppendHistoryNodes add a node to history node table
 		AppendHistoryNodes(ctx context.Context, request *AppendHistoryNodesRequest) (*AppendHistoryNodesResponse, error)
+		// AppendRawHistoryNodes add a node of raw histories to history ndoe table
+		AppendRawHistoryNodes(ctx context.Context, request *AppendRawHistoryNodesRequest) (*AppendHistoryNodesResponse, error)
 		// ReadHistoryBranch returns history node data for a branch
 		ReadHistoryBranch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadHistoryBranchResponse, error)
 		// ReadHistoryBranchByBatch returns history node data for a branch ByBatch
diff --git a/common/persistence/dataInterfaces_mock.go b/common/persistence/dataInterfaces_mock.go
index 99f7f5bf312..ca468b2c3db 100644
--- a/common/persistence/dataInterfaces_mock.go
+++ b/common/persistence/dataInterfaces_mock.go
@@ -214,6 +214,21 @@ func (mr *MockExecutionManagerMockRecorder) AppendHistoryNodes(ctx, request inte
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockExecutionManager)(nil).AppendHistoryNodes), ctx, request)
 }
 
+// AppendRawHistoryNodes mocks base method.
+func (m *MockExecutionManager) AppendRawHistoryNodes(ctx context.Context, request *AppendRawHistoryNodesRequest) (*AppendHistoryNodesResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AppendRawHistoryNodes", ctx, request)
+	ret0, _ := ret[0].(*AppendHistoryNodesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AppendRawHistoryNodes indicates an expected call of AppendRawHistoryNodes.
+func (mr *MockExecutionManagerMockRecorder) AppendRawHistoryNodes(ctx, request interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendRawHistoryNodes", reflect.TypeOf((*MockExecutionManager)(nil).AppendRawHistoryNodes), ctx, request)
+}
+
 // Close mocks base method.
 func (m *MockExecutionManager) Close() {
 	m.ctrl.T.Helper()
diff --git a/common/persistence/history_manager.go b/common/persistence/history_manager.go
index 08c6ec719e6..0199cd3a189 100644
--- a/common/persistence/history_manager.go
+++ b/common/persistence/history_manager.go
@@ -426,6 +426,71 @@ func (m *executionManagerImpl) serializeAppendHistoryNodesRequest(
 	return req, nil
 }
 
+func (m *executionManagerImpl) serializeAppendRawHistoryNodesRequest(
+	request *AppendRawHistoryNodesRequest,
+) (*InternalAppendHistoryNodesRequest, error) {
+	branch, err := m.serializer.HistoryBranchFromBlob(&commonpb.DataBlob{Data: request.BranchToken, EncodingType: enumspb.ENCODING_TYPE_PROTO3})
+	if err != nil {
+		return nil, err
+	}
+
+	if len(request.History.Data) == 0 {
+		return nil, &InvalidPersistenceRequestError{
+			Msg: fmt.Sprintf("events to be appended cannot be empty"),
+		}
+	}
+	sortAncestors(branch.Ancestors)
+
+	nodeID := request.NodeID
+	if nodeID <= 0 {
+		return nil, &InvalidPersistenceRequestError{
+			Msg: fmt.Sprintf("eventID cannot be less than 1"),
+		}
+	}
+	// nodeID will be the first eventID
+	size := len(request.History.Data)
+	sizeLimit := m.transactionSizeLimit()
+	if size > sizeLimit {
+		return nil, &TransactionSizeLimitError{
+			Msg: fmt.Sprintf("transaction size of %v bytes exceeds limit of %v bytes", size, sizeLimit),
+		}
+	}
+
+	req := &InternalAppendHistoryNodesRequest{
+		IsNewBranch: request.IsNewBranch,
+		Info:        request.Info,
+		BranchInfo:  branch,
+		Node: InternalHistoryNode{
+			NodeID:            nodeID,
+			Events:            request.History,
+			PrevTransactionID: request.PrevTransactionID,
+			TransactionID:     request.TransactionID,
+		},
+		ShardID: request.ShardID,
+	}
+
+	if req.IsNewBranch {
+		// TreeInfo is only needed for new branch
+		treeInfoBlob, err := m.serializer.HistoryTreeInfoToBlob(&persistencespb.HistoryTreeInfo{
+			BranchInfo: branch,
+			ForkTime:   timestamp.TimeNowPtrUtc(),
+			Info:       request.Info,
+		}, enumspb.ENCODING_TYPE_PROTO3)
+		if err != nil {
+			return nil, err
+		}
+		req.TreeInfo = treeInfoBlob
+	}
+
+	if nodeID < GetBeginNodeID(branch) {
+		return nil, &InvalidPersistenceRequestError{
+			Msg: fmt.Sprintf("cannot append to ancestors' nodes"),
+		}
+	}
+
+	return req, nil
+}
+
 // AppendHistoryNodes add a node to history node table
 func (m *executionManagerImpl) AppendHistoryNodes(
 	ctx context.Context,
@@ -445,6 +510,23 @@ func (m *executionManagerImpl) AppendHistoryNodes(
 	}, err
 }
 
+// AppendRawHistoryNodes add raw history nodes to history node table
+func (m *executionManagerImpl) AppendRawHistoryNodes(
+	ctx context.Context,
+	request *AppendRawHistoryNodesRequest,
+) (*AppendHistoryNodesResponse, error) {
+
+	req, err := m.serializeAppendRawHistoryNodesRequest(request)
+	if err != nil {
+		return nil, err
+	}
+
+	err = m.persistence.AppendHistoryNodes(ctx, req)
+	return &AppendHistoryNodesResponse{
+		Size: len(request.History.Data),
+	}, err
+}
+
 // ReadHistoryBranchByBatch returns history node data for a branch by batch
 // Pagination is implemented here, the actual minNodeID passing to persistence layer is calculated along with token's LastNodeID
 func (m *executionManagerImpl) ReadHistoryBranchByBatch(
@@ -479,7 +561,7 @@ func (m *executionManagerImpl) ReadRawHistoryBranch(
 	request *ReadHistoryBranchRequest,
 ) (*ReadRawHistoryBranchResponse, error) {
 
-	dataBlobs, _, token, dataSize, err := m.readRawHistoryBranchAndFilter(ctx, request)
+	dataBlobs, _, nodeIDs, token, dataSize, err := m.readRawHistoryBranchAndFilter(ctx, request)
 	if err != nil {
 		return nil, err
 	}
@@ -491,6 +573,7 @@ func (m *executionManagerImpl) ReadRawHistoryBranch(
 
 	return &ReadRawHistoryBranchResponse{
 		HistoryEventBlobs: dataBlobs,
+		NodeIDs:           nodeIDs,
 		NextPageToken:     nextPageToken,
 		Size:              dataSize,
 	}, nil
@@ -660,7 +743,7 @@ func (m *executionManagerImpl) readRawHistoryBranchReverse(
 func (m *executionManagerImpl) readRawHistoryBranchAndFilter(
 	ctx context.Context,
 	request *ReadHistoryBranchRequest,
-) ([]*commonpb.DataBlob, []int64, *historyPagingToken, int, error) {
+) ([]*commonpb.DataBlob, []int64, []int64, *historyPagingToken, int, error) {
 
 	shardID := request.ShardID
 	branchToken := request.BranchToken
@@ -669,7 +752,7 @@ func (m *executionManagerImpl) readRawHistoryBranchAndFilter(
 
 	branch, err := serialization.HistoryBranchFromBlob(branchToken, enumspb.ENCODING_TYPE_PROTO3.String())
 	if err != nil {
-		return nil, nil, nil, 0, err
+		return nil, nil, nil, nil, 0, err
 	}
 	treeID := branch.TreeId
 	branchID := branch.BranchId
@@ -692,7 +775,7 @@ func (m *executionManagerImpl) readRawHistoryBranchAndFilter(
 		defaultLastTransactionID,
 	)
 	if err != nil {
-		return nil, nil, nil, 0, err
+		return nil, nil, nil, nil, 0, err
 	}
 
 	nodes, token, err := m.readRawHistoryBranch(
@@ -707,10 +790,10 @@ func (m *executionManagerImpl) readRawHistoryBranchAndFilter(
 		false,
 	)
 	if err != nil {
-		return nil, nil, nil, 0, err
+		return nil, nil, nil, nil, 0, err
 	}
 	if len(nodes) == 0 && len(request.NextPageToken) == 0 {
-		return nil, nil, nil, 0, serviceerror.NewNotFound("Workflow execution history not found.")
+		return nil, nil, nil, nil, 0, serviceerror.NewNotFound("Workflow execution history not found.")
 	}
 
 	nodes, err = m.filterHistoryNodes(
@@ -719,11 +802,12 @@ func (m *executionManagerImpl) readRawHistoryBranchAndFilter(
 		nodes,
 	)
 	if err != nil {
-		return nil, nil, nil, 0, err
+		return nil, nil, nil, nil, 0, err
 	}
 
 	var dataBlobs []*commonpb.DataBlob
 	transactionIDs := make([]int64, 0, len(nodes))
+	nodeIDs := make([]int64, 0, len(nodes))
 	dataSize := 0
 	if len(nodes) > 0 {
 		dataBlobs = make([]*commonpb.DataBlob, len(nodes))
@@ -731,13 +815,14 @@ func (m *executionManagerImpl) readRawHistoryBranchAndFilter(
 			dataBlobs[index] = node.Events
 			dataSize += len(node.Events.Data)
 			transactionIDs = append(transactionIDs, node.TransactionID)
+			nodeIDs = append(nodeIDs, node.NodeID)
 		}
 		lastNode := nodes[len(nodes)-1]
 		token.LastNodeID = lastNode.NodeID
 		token.LastTransactionID = lastNode.TransactionID
 	}
 
-	return dataBlobs, transactionIDs, token, dataSize, nil
+	return dataBlobs, transactionIDs, nodeIDs, token, dataSize, nil
 }
 
 func (m *executionManagerImpl) readRawHistoryBranchReverseAndFilter(
@@ -834,7 +919,7 @@ func (m *executionManagerImpl) readHistoryBranch(
 	request *ReadHistoryBranchRequest,
 ) ([]*historypb.HistoryEvent, []*historypb.History, []int64, []byte, int, error) {
 
-	dataBlobs, transactionIDs, token, dataSize, err := m.readRawHistoryBranchAndFilter(ctx, request)
+	dataBlobs, transactionIDs, _, token, dataSize, err := m.readRawHistoryBranchAndFilter(ctx, request)
 	if err != nil {
 		return nil, nil, nil, nil, 0, err
 	}
diff --git a/common/persistence/persistenceInterface.go b/common/persistence/persistenceInterface.go
index 3d27c4d8492..0b2da26c96e 100644
--- a/common/persistence/persistenceInterface.go
+++ b/common/persistence/persistenceInterface.go
@@ -40,7 +40,6 @@ import (
 
 const (
 	EmptyQueueMessageID = int64(-1)
-	MinQueueMessageID   = EmptyQueueMessageID + 1
 	MaxQueueMessageID   = math.MaxInt64
 )
 
diff --git a/common/persistence/persistenceMetricClients.go b/common/persistence/persistenceMetricClients.go
index 59ea2e0030b..784efe601b2 100644
--- a/common/persistence/persistenceMetricClients.go
+++ b/common/persistence/persistenceMetricClients.go
@@ -883,6 +883,21 @@ func (p *executionPersistenceClient) AppendHistoryNodes(
 	return resp, err
 }
 
+// AppendRawHistoryNodes add a node to history node table
+func (p *executionPersistenceClient) AppendRawHistoryNodes(
+	ctx context.Context,
+	request *AppendRawHistoryNodesRequest,
+) (*AppendHistoryNodesResponse, error) {
+	p.metricClient.IncCounter(metrics.PersistenceAppendRawHistoryNodesScope, metrics.PersistenceRequests)
+	sw := p.metricClient.StartTimer(metrics.PersistenceAppendRawHistoryNodesScope, metrics.PersistenceLatency)
+	resp, err := p.persistence.AppendRawHistoryNodes(ctx, request)
+	sw.Stop()
+	if err != nil {
+		p.updateErrorMetric(metrics.PersistenceAppendRawHistoryNodesScope, err)
+	}
+	return resp, err
+}
+
 // ReadHistoryBranch returns history node data for a branch
 func (p *executionPersistenceClient) ReadHistoryBranch(
 	ctx context.Context,
diff --git a/common/persistence/persistenceRateLimitedClients.go b/common/persistence/persistenceRateLimitedClients.go
index 0f264763d04..3cb280a99e9 100644
--- a/common/persistence/persistenceRateLimitedClients.go
+++ b/common/persistence/persistenceRateLimitedClients.go
@@ -621,6 +621,17 @@ func (p *executionRateLimitedPersistenceClient) AppendHistoryNodes(
 	return p.persistence.AppendHistoryNodes(ctx, request)
 }
 
+// AppendRawHistoryNodes add a node to history node table
+func (p *executionRateLimitedPersistenceClient) AppendRawHistoryNodes(
+	ctx context.Context,
+	request *AppendRawHistoryNodesRequest,
+) (*AppendHistoryNodesResponse, error) {
+	if ok := p.rateLimiter.Allow(); !ok {
+		return nil, ErrPersistenceLimitExceeded
+	}
+	return p.persistence.AppendRawHistoryNodes(ctx, request)
+}
+
 // ReadHistoryBranch returns history node data for a branch
 func (p *executionRateLimitedPersistenceClient) ReadHistoryBranch(
 	ctx context.Context,
diff --git a/common/persistence/tests/history_store.go b/common/persistence/tests/history_store.go
index 55d470dd04e..4da6fc3fdc0 100644
--- a/common/persistence/tests/history_store.go
+++ b/common/persistence/tests/history_store.go
@@ -30,6 +30,8 @@ import (
 	"testing"
 	"time"
 
+	enumspb "go.temporal.io/api/enums/v1"
+
 	"github.com/pborman/uuid"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
@@ -60,8 +62,9 @@ type (
 		suite.Suite
 		*require.Assertions
 
-		store  p.ExecutionManager
-		logger log.Logger
+		store      p.ExecutionManager
+		serializer serialization.Serializer
+		logger     log.Logger
 
 		Ctx    context.Context
 		Cancel context.CancelFunc
@@ -73,15 +76,17 @@ func NewHistoryEventsSuite(
 	store p.ExecutionStore,
 	logger log.Logger,
 ) *HistoryEventsSuite {
+	eventSerializer := serialization.NewSerializer()
 	return &HistoryEventsSuite{
 		Assertions: require.New(t),
 		store: p.NewExecutionManager(
 			store,
-			serialization.NewSerializer(),
+			eventSerializer,
 			logger,
 			dynamicconfig.GetIntPropertyFn(4*1024*1024),
 		),
-		logger: logger,
+		serializer: eventSerializer,
+		logger:     logger,
 	}
 }
 
@@ -480,6 +485,38 @@ func (s *HistoryEventsSuite) TestAppendForkSelectTrim_LastBranch() {
 	s.Equal(events, s.listAllHistoryEvents(shardID, newBranchToken))
 }
 
+func (s *HistoryEventsSuite) TestAppendBatches() {
+	shardID := rand.Int31()
+	treeID := uuid.New()
+	branchID := uuid.New()
+	branchToken, err := p.NewHistoryBranchTokenByBranchID(treeID, branchID)
+	s.NoError(err)
+
+	eventsPacket1 := s.newHistoryEvents(
+		[]int64{1, 2, 3},
+		rand.Int63(),
+		0,
+	)
+	eventsPacket2 := s.newHistoryEvents(
+		[]int64{4, 5},
+		eventsPacket1.transactionID+100,
+		eventsPacket1.transactionID,
+	)
+	eventsPacket3 := s.newHistoryEvents(
+		[]int64{6},
+		eventsPacket2.transactionID+100,
+		eventsPacket2.transactionID,
+	)
+
+	s.appendRawHistoryBatches(shardID, branchToken, eventsPacket1)
+	s.appendRawHistoryBatches(shardID, branchToken, eventsPacket2)
+	s.appendRawHistoryBatches(shardID, branchToken, eventsPacket3)
+	s.Equal(eventsPacket1.events, s.listHistoryEvents(shardID, branchToken, common.FirstEventID, 4))
+	expectedEvents := append(eventsPacket1.events, append(eventsPacket2.events, eventsPacket3.events...)...)
+	events := s.listAllHistoryEvents(shardID, branchToken)
+	s.Equal(expectedEvents, events)
+}
+
 func (s *HistoryEventsSuite) TestForkDeleteBranch_DeleteBaseBranchFirst() {
 	shardID := rand.Int31()
 	treeID := uuid.New()
@@ -613,6 +650,26 @@ func (s *HistoryEventsSuite) appendHistoryEvents(
 	s.NoError(err)
 }
 
+func (s *HistoryEventsSuite) appendRawHistoryBatches(
+	shardID int32,
+	branchToken []byte,
+	packet HistoryEventsPacket,
+) {
+	blob, err := s.serializer.SerializeEvents(packet.events, enumspb.ENCODING_TYPE_PROTO3)
+	s.NoError(err)
+	_, err = s.store.AppendRawHistoryNodes(s.Ctx, &p.AppendRawHistoryNodesRequest{
+		ShardID:           shardID,
+		BranchToken:       branchToken,
+		NodeID:            packet.nodeID,
+		TransactionID:     packet.transactionID,
+		PrevTransactionID: packet.prevTransactionID,
+		IsNewBranch:       packet.nodeID == common.FirstEventID,
+		Info:              "",
+		History:           blob,
+	})
+	s.NoError(err)
+}
+
 func (s *HistoryEventsSuite) forkHistoryBranch(
 	shardID int32,
 	branchToken []byte,
diff --git a/proto/internal/temporal/server/api/adminservice/v1/request_response.proto b/proto/internal/temporal/server/api/adminservice/v1/request_response.proto
index 368738c2c73..c29cd3f5b93 100644
--- a/proto/internal/temporal/server/api/adminservice/v1/request_response.proto
+++ b/proto/internal/temporal/server/api/adminservice/v1/request_response.proto
@@ -150,6 +150,7 @@ message GetWorkflowExecutionRawHistoryV2Response {
     bytes next_page_token = 1;
     repeated temporal.api.common.v1.DataBlob history_batches = 2;
     temporal.server.api.history.v1.VersionHistory version_history = 3;
+    repeated int64 history_node_ids = 4;
 }
 
 message GetReplicationMessagesRequest {
diff --git a/service/frontend/adminHandler.go b/service/frontend/adminHandler.go
index 7791b680323..e78c483311f 100644
--- a/service/frontend/adminHandler.go
+++ b/service/frontend/adminHandler.go
@@ -777,6 +777,7 @@ func (adh *AdminHandler) GetWorkflowExecutionRawHistoryV2(ctx context.Context, r
 	result := &adminservice.GetWorkflowExecutionRawHistoryV2Response{
 		HistoryBatches: rawHistoryResponse.HistoryEventBlobs,
 		VersionHistory: targetVersionHistory,
+		HistoryNodeIds: rawHistoryResponse.NodeIDs,
 	}
 	if len(pageToken.PersistenceToken) == 0 {
 		result.NextPageToken = nil