From c22146e69107b8b62668445c377fa34b7dba84e7 Mon Sep 17 00:00:00 2001
From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com>
Date: Wed, 12 Aug 2020 19:12:24 +0300
Subject: [PATCH] vexec for schema-migrations, major refactor

Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com>
---
 .../tabletmanagerdata/tabletmanagerdata.pb.go | 367 +++++++++++-------
 .../tabletmanagerservice.pb.go                | 181 +++++----
 go/vt/vtcombo/tablet_map.go                   |   4 +
 go/vt/vttablet/faketmclient/fake_client.go    |   9 +
 go/vt/vttablet/grpctmclient/client.go         |  13 +
 go/vt/vttablet/grpctmserver/server.go         |   8 +
 go/vt/vttablet/onlineddl/executor.go          |   4 +
 go/vt/vttablet/onlineddl/schema.go            |   1 +
 go/vt/vttablet/tabletmanager/rpc_agent.go     |   3 +
 go/vt/vttablet/tabletmanager/rpc_vexec.go     |  59 +++
 go/vt/vttablet/tabletserver/controller.go     |   4 +
 go/vt/vttablet/tabletserver/tabletserver.go   |   5 +
 go/vt/vttablet/tabletservermock/controller.go |   6 +
 go/vt/vttablet/tmclient/rpc_client_api.go     |   3 +
 go/vt/vttablet/tmrpctest/test_tm_rpc.go       |   8 +
 go/vt/wrangler/tablet.go                      |   9 +
 go/vt/wrangler/vexec.go                       |  43 +-
 go/vt/wrangler/vexec_plan.go                  | 177 +++++++--
 go/vt/wrangler/vexec_test.go                  |   4 +-
 proto/tabletmanagerdata.proto                 |   8 +
 proto/tabletmanagerservice.proto              |   3 +
 21 files changed, 635 insertions(+), 284 deletions(-)
 create mode 100644 go/vt/vttablet/tabletmanager/rpc_vexec.go

diff --git a/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go b/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go
index c5290d4b947..0870d526b86 100644
--- a/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go
+++ b/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go
@@ -4375,6 +4375,84 @@ func (m *SlaveWasRestartedResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_SlaveWasRestartedResponse proto.InternalMessageInfo
 
+type VExecRequest struct {
+	Query                string   `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *VExecRequest) Reset()         { *m = VExecRequest{} }
+func (m *VExecRequest) String() string { return proto.CompactTextString(m) }
+func (*VExecRequest) ProtoMessage()    {}
+func (*VExecRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff9ac4f89e61ffa4, []int{110}
+}
+
+func (m *VExecRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VExecRequest.Unmarshal(m, b)
+}
+func (m *VExecRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VExecRequest.Marshal(b, m, deterministic)
+}
+func (m *VExecRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VExecRequest.Merge(m, src)
+}
+func (m *VExecRequest) XXX_Size() int {
+	return xxx_messageInfo_VExecRequest.Size(m)
+}
+func (m *VExecRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_VExecRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VExecRequest proto.InternalMessageInfo
+
+func (m *VExecRequest) GetQuery() string {
+	if m != nil {
+		return m.Query
+	}
+	return ""
+}
+
+type VExecResponse struct {
+	Result               *query.QueryResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *VExecResponse) Reset()         { *m = VExecResponse{} }
+func (m *VExecResponse) String() string { return proto.CompactTextString(m) }
+func (*VExecResponse) ProtoMessage()    {}
+func (*VExecResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff9ac4f89e61ffa4, []int{111}
+}
+
+func (m *VExecResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VExecResponse.Unmarshal(m, b)
+}
+func (m *VExecResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VExecResponse.Marshal(b, m, deterministic)
+}
+func (m *VExecResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VExecResponse.Merge(m, src)
+}
+func (m *VExecResponse) XXX_Size() int {
+	return xxx_messageInfo_VExecResponse.Size(m)
+}
+func (m *VExecResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_VExecResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VExecResponse proto.InternalMessageInfo
+
+func (m *VExecResponse) GetResult() *query.QueryResult {
+	if m != nil {
+		return m.Result
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*TableDefinition)(nil), "tabletmanagerdata.TableDefinition")
 	proto.RegisterType((*SchemaDefinition)(nil), "tabletmanagerdata.SchemaDefinition")
@@ -4489,153 +4567,156 @@ func init() {
 	proto.RegisterType((*SlaveWasPromotedResponse)(nil), "tabletmanagerdata.SlaveWasPromotedResponse")
 	proto.RegisterType((*SlaveWasRestartedRequest)(nil), "tabletmanagerdata.SlaveWasRestartedRequest")
 	proto.RegisterType((*SlaveWasRestartedResponse)(nil), "tabletmanagerdata.SlaveWasRestartedResponse")
+	proto.RegisterType((*VExecRequest)(nil), "tabletmanagerdata.VExecRequest")
+	proto.RegisterType((*VExecResponse)(nil), "tabletmanagerdata.VExecResponse")
 }
 
 func init() { proto.RegisterFile("tabletmanagerdata.proto", fileDescriptor_ff9ac4f89e61ffa4) }
 
 var fileDescriptor_ff9ac4f89e61ffa4 = []byte{
-	// 2276 bytes of a gzipped FileDescriptorProto
+	// 2291 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xdd, 0x72, 0xdb, 0xc6,
-	0x15, 0x1e, 0x50, 0x3f, 0x96, 0x0e, 0x7f, 0x44, 0x81, 0x94, 0x44, 0x51, 0xb1, 0x2c, 0xc3, 0x4e,
-	0xe2, 0x26, 0x53, 0x2a, 0x51, 0x12, 0x4f, 0x26, 0xfd, 0x99, 0xca, 0xb6, 0x64, 0x3b, 0x96, 0x63,
-	0x05, 0xb2, 0xe3, 0x4c, 0xa6, 0x53, 0x0c, 0x48, 0xac, 0x28, 0x8c, 0x40, 0x2c, 0xbc, 0xbb, 0xa0,
-	0xc4, 0x9b, 0x3e, 0x42, 0xfb, 0x02, 0x9d, 0xde, 0x74, 0xa6, 0xbd, 0xef, 0x43, 0xf4, 0x11, 0xd2,
-	0x47, 0xe9, 0x45, 0x2f, 0xda, 0xd9, 0xdd, 0x03, 0x12, 0x20, 0x20, 0x59, 0x76, 0xdd, 0x99, 0xdc,
-	0x68, 0xb0, 0xdf, 0xd9, 0xf3, 0xbb, 0x67, 0xcf, 0x39, 0x4b, 0xc1, 0x9a, 0x70, 0xbb, 0x01, 0x11,
-	0x03, 0x37, 0x74, 0xfb, 0x84, 0x79, 0xae, 0x70, 0x3b, 0x11, 0xa3, 0x82, 0x9a, 0xcb, 0x39, 0x42,
-	0xbb, 0xfc, 0x2a, 0x26, 0x6c, 0xa4, 0xe9, 0xed, 0x9a, 0xa0, 0x11, 0x9d, 0xec, 0x6f, 0xaf, 0x30,
-	0x12, 0x05, 0x7e, 0xcf, 0x15, 0x3e, 0x0d, 0x53, 0x70, 0x35, 0xa0, 0xfd, 0x58, 0xf8, 0x81, 0x5e,
-	0x5a, 0xff, 0x31, 0x60, 0xe9, 0xb9, 0x14, 0xfc, 0x80, 0x1c, 0xfb, 0xa1, 0x2f, 0x37, 0x9b, 0x26,
-	0xcc, 0x86, 0xee, 0x80, 0xb4, 0x8c, 0x2d, 0xe3, 0xce, 0xa2, 0xad, 0xbe, 0xcd, 0x55, 0x98, 0xe7,
-	0xbd, 0x13, 0x32, 0x70, 0x5b, 0x25, 0x85, 0xe2, 0xca, 0x6c, 0xc1, 0xb5, 0x1e, 0x0d, 0xe2, 0x41,
-	0xc8, 0x5b, 0x33, 0x5b, 0x33, 0x77, 0x16, 0xed, 0x64, 0x69, 0x76, 0xa0, 0x11, 0x31, 0x7f, 0xe0,
-	0xb2, 0x91, 0x73, 0x4a, 0x46, 0x4e, 0xb2, 0x6b, 0x56, 0xed, 0x5a, 0x46, 0xd2, 0x13, 0x32, 0xba,
-	0x8f, 0xfb, 0x4d, 0x98, 0x15, 0xa3, 0x88, 0xb4, 0xe6, 0xb4, 0x56, 0xf9, 0x6d, 0xde, 0x80, 0xb2,
-	0x34, 0xdd, 0x09, 0x48, 0xd8, 0x17, 0x27, 0xad, 0xf9, 0x2d, 0xe3, 0xce, 0xac, 0x0d, 0x12, 0x3a,
-	0x50, 0x88, 0xb9, 0x01, 0x8b, 0x8c, 0x9e, 0x39, 0x3d, 0x1a, 0x87, 0xa2, 0x75, 0x4d, 0x91, 0x17,
-	0x18, 0x3d, 0xbb, 0x2f, 0xd7, 0xe6, 0x6d, 0x98, 0x3f, 0xf6, 0x49, 0xe0, 0xf1, 0xd6, 0xc2, 0xd6,
-	0xcc, 0x9d, 0xf2, 0x4e, 0xa5, 0xa3, 0xe3, 0xb5, 0x2f, 0x41, 0x1b, 0x69, 0xd6, 0x5f, 0x0d, 0xa8,
-	0x1f, 0x29, 0x67, 0x52, 0x21, 0xf8, 0x10, 0x96, 0xa4, 0x96, 0xae, 0xcb, 0x89, 0x83, 0x7e, 0xeb,
-	0x68, 0xd4, 0x12, 0x58, 0xb3, 0x98, 0xcf, 0x40, 0x9f, 0x8b, 0xe3, 0x8d, 0x99, 0x79, 0xab, 0xa4,
-	0xd4, 0x59, 0x9d, 0xfc, 0x51, 0x4e, 0x85, 0xda, 0xae, 0x8b, 0x2c, 0xc0, 0x65, 0x40, 0x87, 0x84,
-	0x71, 0x9f, 0x86, 0xad, 0x19, 0xa5, 0x31, 0x59, 0x4a, 0x43, 0x4d, 0xad, 0xf5, 0xfe, 0x89, 0x1b,
-	0xf6, 0x89, 0x4d, 0x78, 0x1c, 0x08, 0xf3, 0x11, 0x54, 0xbb, 0xe4, 0x98, 0xb2, 0x8c, 0xa1, 0xe5,
-	0x9d, 0x5b, 0x05, 0xda, 0xa7, 0xdd, 0xb4, 0x2b, 0x9a, 0x13, 0x7d, 0xd9, 0x87, 0x8a, 0x7b, 0x2c,
-	0x08, 0x73, 0x52, 0x27, 0x7d, 0x45, 0x41, 0x65, 0xc5, 0xa8, 0x61, 0xeb, 0x5f, 0x06, 0xd4, 0x5e,
-	0x70, 0xc2, 0x0e, 0x09, 0x1b, 0xf8, 0x9c, 0x63, 0x4a, 0x9d, 0x50, 0x2e, 0x92, 0x94, 0x92, 0xdf,
-	0x12, 0x8b, 0x39, 0x61, 0x98, 0x50, 0xea, 0xdb, 0xfc, 0x18, 0x96, 0x23, 0x97, 0xf3, 0x33, 0xca,
-	0x3c, 0xa7, 0x77, 0x42, 0x7a, 0xa7, 0x3c, 0x1e, 0xa8, 0x38, 0xcc, 0xda, 0xf5, 0x84, 0x70, 0x1f,
-	0x71, 0xf3, 0x5b, 0x80, 0x88, 0xf9, 0x43, 0x3f, 0x20, 0x7d, 0xa2, 0x13, 0xab, 0xbc, 0xf3, 0x69,
-	0x81, 0xb5, 0x59, 0x5b, 0x3a, 0x87, 0x63, 0x9e, 0xbd, 0x50, 0xb0, 0x91, 0x9d, 0x12, 0xd2, 0xfe,
-	0x15, 0x2c, 0x4d, 0x91, 0xcd, 0x3a, 0xcc, 0x9c, 0x92, 0x11, 0x5a, 0x2e, 0x3f, 0xcd, 0x26, 0xcc,
-	0x0d, 0xdd, 0x20, 0x26, 0x68, 0xb9, 0x5e, 0x7c, 0x55, 0xfa, 0xd2, 0xb0, 0x7e, 0x34, 0xa0, 0xf2,
-	0xa0, 0xfb, 0x1a, 0xbf, 0x6b, 0x50, 0xf2, 0xba, 0xc8, 0x5b, 0xf2, 0xba, 0xe3, 0x38, 0xcc, 0xa4,
-	0xe2, 0xf0, 0xac, 0xc0, 0xb5, 0xed, 0x02, 0xd7, 0xd2, 0xca, 0xfe, 0x9f, 0x8e, 0xfd, 0xc5, 0x80,
-	0xf2, 0x44, 0x13, 0x37, 0x0f, 0xa0, 0x2e, 0xed, 0x74, 0xa2, 0x09, 0xd6, 0x32, 0x94, 0x95, 0x37,
-	0x5f, 0x7b, 0x00, 0xf6, 0x52, 0x9c, 0x59, 0x73, 0x73, 0x1f, 0x6a, 0x5e, 0x37, 0x23, 0x4b, 0xdf,
-	0xa0, 0x1b, 0xaf, 0xf1, 0xd8, 0xae, 0x7a, 0xa9, 0x15, 0xb7, 0x3e, 0x84, 0xf2, 0xa1, 0x1f, 0xf6,
-	0x6d, 0xf2, 0x2a, 0x26, 0x5c, 0xc8, 0xab, 0x14, 0xb9, 0xa3, 0x80, 0xba, 0x1e, 0x3a, 0x99, 0x2c,
-	0xad, 0x3b, 0x50, 0xd1, 0x1b, 0x79, 0x44, 0x43, 0x4e, 0x2e, 0xd9, 0xf9, 0x11, 0x54, 0x8e, 0x02,
-	0x42, 0xa2, 0x44, 0x66, 0x1b, 0x16, 0xbc, 0x98, 0xa9, 0xa2, 0xaa, 0xb6, 0xce, 0xd8, 0xe3, 0xb5,
-	0xb5, 0x04, 0x55, 0xdc, 0xab, 0xc5, 0x5a, 0xff, 0x34, 0xc0, 0xdc, 0x3b, 0x27, 0xbd, 0x58, 0x90,
-	0x47, 0x94, 0x9e, 0x26, 0x32, 0x8a, 0xea, 0xeb, 0x26, 0x40, 0xe4, 0x32, 0x77, 0x40, 0x04, 0x61,
-	0xda, 0xfd, 0x45, 0x3b, 0x85, 0x98, 0x87, 0xb0, 0x48, 0xce, 0x05, 0x73, 0x1d, 0x12, 0x0e, 0x55,
-	0xa5, 0x2d, 0xef, 0x7c, 0x56, 0x10, 0x9d, 0xbc, 0xb6, 0xce, 0x9e, 0x64, 0xdb, 0x0b, 0x87, 0x3a,
-	0x27, 0x16, 0x08, 0x2e, 0xdb, 0xbf, 0x80, 0x6a, 0x86, 0xf4, 0x46, 0xf9, 0x70, 0x0c, 0x8d, 0x8c,
-	0x2a, 0x8c, 0xe3, 0x0d, 0x28, 0x93, 0x73, 0x5f, 0x38, 0x5c, 0xb8, 0x22, 0xe6, 0x18, 0x20, 0x90,
-	0xd0, 0x91, 0x42, 0x54, 0x1b, 0x11, 0x1e, 0x8d, 0xc5, 0xb8, 0x8d, 0xa8, 0x15, 0xe2, 0x84, 0x25,
-	0xb7, 0x00, 0x57, 0xd6, 0x10, 0xea, 0x0f, 0x89, 0xd0, 0x75, 0x25, 0x09, 0xdf, 0x2a, 0xcc, 0x2b,
-	0xc7, 0x75, 0xc6, 0x2d, 0xda, 0xb8, 0x32, 0x6f, 0x41, 0xd5, 0x0f, 0x7b, 0x41, 0xec, 0x11, 0x67,
-	0xe8, 0x93, 0x33, 0xae, 0x54, 0x2c, 0xd8, 0x15, 0x04, 0xbf, 0x93, 0x98, 0xf9, 0x3e, 0xd4, 0xc8,
-	0xb9, 0xde, 0x84, 0x42, 0x74, 0xdb, 0xaa, 0x22, 0xaa, 0x0a, 0x34, 0xb7, 0x08, 0x2c, 0xa7, 0xf4,
-	0xa2, 0x77, 0x87, 0xb0, 0xac, 0x2b, 0x63, 0xaa, 0xd8, 0xbf, 0x49, 0xb5, 0xad, 0xf3, 0x29, 0xc4,
-	0x5a, 0x83, 0x95, 0x87, 0x44, 0xa4, 0x52, 0x18, 0x7d, 0xb4, 0x7e, 0x80, 0xd5, 0x69, 0x02, 0x1a,
-	0xf1, 0x1b, 0x28, 0x67, 0x2f, 0x9d, 0x54, 0xbf, 0x59, 0xa0, 0x3e, 0xcd, 0x9c, 0x66, 0xb1, 0x9a,
-	0x60, 0x1e, 0x11, 0x61, 0x13, 0xd7, 0x7b, 0x16, 0x06, 0xa3, 0x44, 0xe3, 0x0a, 0x34, 0x32, 0x28,
-	0xa6, 0xf0, 0x04, 0x7e, 0xc9, 0x7c, 0x41, 0x92, 0xdd, 0xab, 0xd0, 0xcc, 0xc2, 0xb8, 0xfd, 0x6b,
-	0x58, 0xd6, 0xcd, 0xe9, 0xf9, 0x28, 0x4a, 0x36, 0x9b, 0x5f, 0x40, 0x59, 0x9b, 0xe7, 0xa8, 0x06,
-	0x2f, 0x4d, 0xae, 0xed, 0x34, 0x3b, 0xe3, 0x79, 0x45, 0xc5, 0x5c, 0x28, 0x0e, 0x10, 0xe3, 0x6f,
-	0x69, 0x67, 0x5a, 0xd6, 0xc4, 0x20, 0x9b, 0x1c, 0x33, 0xc2, 0x4f, 0x64, 0x4a, 0xa5, 0x0d, 0xca,
-	0xc2, 0xb8, 0x7d, 0x0d, 0x56, 0xec, 0x38, 0x7c, 0x44, 0xdc, 0x40, 0x9c, 0xa8, 0xc6, 0x91, 0x30,
-	0xb4, 0x60, 0x75, 0x9a, 0x80, 0x2c, 0x9f, 0x43, 0xeb, 0x71, 0x3f, 0xa4, 0x8c, 0x68, 0xe2, 0x1e,
-	0x63, 0x94, 0x65, 0x4a, 0x8a, 0x10, 0x84, 0x85, 0x93, 0x42, 0xa1, 0x96, 0xd6, 0x06, 0xac, 0x17,
-	0x70, 0xa1, 0xc8, 0xaf, 0xa4, 0xd1, 0xb2, 0x9e, 0x64, 0x33, 0xf9, 0x16, 0x54, 0xcf, 0x5c, 0x5f,
-	0x38, 0x11, 0xe5, 0x93, 0x64, 0x5a, 0xb4, 0x2b, 0x12, 0x3c, 0x44, 0x4c, 0x7b, 0x96, 0xe6, 0x45,
-	0x99, 0x3b, 0xb0, 0x7a, 0xc8, 0xc8, 0x71, 0xe0, 0xf7, 0x4f, 0xa6, 0x2e, 0x88, 0x9c, 0xc9, 0x54,
-	0xe0, 0x92, 0x1b, 0x92, 0x2c, 0xad, 0x3e, 0xac, 0xe5, 0x78, 0x30, 0xaf, 0x0e, 0xa0, 0xa6, 0x77,
-	0x39, 0x4c, 0xcd, 0x15, 0x49, 0x3d, 0x7f, 0xff, 0xc2, 0xcc, 0x4e, 0x4f, 0x21, 0x76, 0xb5, 0x97,
-	0x5a, 0x71, 0xeb, 0xdf, 0x06, 0x98, 0xbb, 0x51, 0x14, 0x8c, 0xb2, 0x96, 0xd5, 0x61, 0x86, 0xbf,
-	0x0a, 0x92, 0x12, 0xc3, 0x5f, 0x05, 0xb2, 0xc4, 0x1c, 0x53, 0xd6, 0x23, 0x78, 0x59, 0xf5, 0x42,
-	0x8e, 0x01, 0x6e, 0x10, 0xd0, 0x33, 0x27, 0x35, 0xc3, 0xaa, 0xca, 0xb0, 0x60, 0xd7, 0x15, 0xc1,
-	0x9e, 0xe0, 0xf9, 0x01, 0x68, 0xf6, 0x5d, 0x0d, 0x40, 0x73, 0x6f, 0x39, 0x00, 0xfd, 0xcd, 0x80,
-	0x46, 0xc6, 0x7b, 0x8c, 0xf1, 0x4f, 0x6f, 0x54, 0x6b, 0xc0, 0xf2, 0x01, 0xed, 0x9d, 0xea, 0xaa,
-	0x97, 0x5c, 0x8d, 0x26, 0x98, 0x69, 0x70, 0x72, 0xf1, 0x5e, 0x84, 0x41, 0x6e, 0xf3, 0x2a, 0x34,
-	0xb3, 0x30, 0x6e, 0xff, 0xbb, 0x01, 0x2d, 0x6c, 0x11, 0xfb, 0x44, 0xf4, 0x4e, 0x76, 0xf9, 0x83,
-	0xee, 0x38, 0x0f, 0x9a, 0x30, 0xa7, 0x46, 0x71, 0x15, 0x80, 0x8a, 0xad, 0x17, 0xe6, 0x1a, 0x5c,
-	0xf3, 0xba, 0x8e, 0x6a, 0x8d, 0xd8, 0x1d, 0xbc, 0xee, 0x37, 0xb2, 0x39, 0xae, 0xc3, 0xc2, 0xc0,
-	0x3d, 0x77, 0x18, 0x3d, 0xe3, 0x38, 0x0c, 0x5e, 0x1b, 0xb8, 0xe7, 0x36, 0x3d, 0xe3, 0x6a, 0x50,
-	0xf7, 0xb9, 0x9a, 0xc0, 0xbb, 0x7e, 0x18, 0xd0, 0x3e, 0x57, 0xc7, 0xbf, 0x60, 0xd7, 0x10, 0xbe,
-	0xa7, 0x51, 0x79, 0xd7, 0x98, 0xba, 0x46, 0xe9, 0xc3, 0x5d, 0xb0, 0x2b, 0x2c, 0x75, 0xb7, 0xac,
-	0x87, 0xb0, 0x5e, 0x60, 0x33, 0x9e, 0xde, 0x47, 0x30, 0xaf, 0xaf, 0x06, 0x1e, 0x9b, 0x89, 0xcf,
-	0x89, 0x6f, 0xe5, 0x5f, 0xbc, 0x06, 0xb8, 0xc3, 0xfa, 0x83, 0x01, 0xd7, 0xb3, 0x92, 0x76, 0x83,
-	0x40, 0x0e, 0x60, 0xfc, 0xdd, 0x87, 0x20, 0xe7, 0xd9, 0x6c, 0x81, 0x67, 0x07, 0xb0, 0x79, 0x91,
-	0x3d, 0x6f, 0xe1, 0xde, 0x93, 0xe9, 0xb3, 0xdd, 0x8d, 0xa2, 0xcb, 0x1d, 0x4b, 0xdb, 0x5f, 0xca,
-	0xd8, 0x9f, 0x0f, 0xba, 0x12, 0xf6, 0x16, 0x56, 0xb5, 0xa1, 0x95, 0xaa, 0x0b, 0x7a, 0xe2, 0x48,
-	0xd2, 0xf4, 0x00, 0xd6, 0x0b, 0x68, 0xa8, 0x64, 0x5b, 0x4e, 0x1f, 0xe3, 0x89, 0xa5, 0xbc, 0xb3,
-	0xd6, 0x99, 0x7e, 0x3b, 0x23, 0x03, 0x6e, 0x93, 0x77, 0xe1, 0xa9, 0xcb, 0xe5, 0x35, 0xca, 0x28,
-	0x79, 0x0a, 0xcd, 0x2c, 0x8c, 0xf2, 0xbf, 0x98, 0x92, 0x7f, 0x3d, 0x27, 0x3f, 0xc3, 0x96, 0x68,
-	0x59, 0x83, 0x15, 0x8d, 0x27, 0xbd, 0x20, 0xd1, 0xf3, 0x39, 0xac, 0x4e, 0x13, 0x50, 0x53, 0x1b,
-	0x16, 0xa6, 0x9a, 0xc9, 0x78, 0x2d, 0xb9, 0x5e, 0xba, 0xbe, 0xd8, 0xa7, 0xd3, 0xf2, 0x2e, 0xe5,
-	0x5a, 0x87, 0xb5, 0x1c, 0x17, 0x5e, 0xf1, 0x16, 0xac, 0x1e, 0x09, 0x1a, 0xa5, 0xe2, 0x9a, 0x18,
-	0xb8, 0x0e, 0x6b, 0x39, 0x0a, 0x32, 0xfd, 0x0e, 0xae, 0x4f, 0x91, 0x9e, 0xfa, 0xa1, 0x3f, 0x88,
-	0x07, 0x57, 0x30, 0xc6, 0xbc, 0x09, 0xaa, 0x37, 0x3a, 0xc2, 0x1f, 0x90, 0x64, 0x88, 0x9c, 0xb1,
-	0xcb, 0x12, 0x7b, 0xae, 0x21, 0xeb, 0x97, 0xb0, 0x79, 0x91, 0xfc, 0x2b, 0xc4, 0x48, 0x19, 0xee,
-	0x32, 0x51, 0xe0, 0x53, 0x1b, 0x5a, 0x79, 0x12, 0x3a, 0xd5, 0x85, 0x9b, 0xd3, 0xb4, 0x17, 0xa1,
-	0xf0, 0x83, 0x5d, 0x59, 0x6a, 0xdf, 0x91, 0x63, 0xb7, 0xc1, 0xba, 0x4c, 0x07, 0x5a, 0xd2, 0x04,
-	0xf3, 0x21, 0x49, 0xf6, 0x8c, 0x13, 0xf3, 0x63, 0x68, 0x64, 0x50, 0x8c, 0x44, 0x13, 0xe6, 0x5c,
-	0xcf, 0x63, 0xc9, 0x98, 0xa0, 0x17, 0x32, 0x06, 0x36, 0xe1, 0xe4, 0x82, 0x18, 0xe4, 0x49, 0xa8,
-	0x79, 0x1b, 0xd6, 0xbe, 0x4b, 0xe1, 0xf2, 0x4a, 0x17, 0x96, 0x84, 0x45, 0x2c, 0x09, 0xd6, 0x3e,
-	0xb4, 0xf2, 0x0c, 0x6f, 0x55, 0x8c, 0xae, 0xa7, 0xe5, 0x4c, 0xb2, 0x35, 0x51, 0x5f, 0x83, 0x92,
-	0xef, 0xe1, 0x63, 0xa4, 0xe4, 0x7b, 0x99, 0x83, 0x28, 0x4d, 0x25, 0xc0, 0x16, 0x6c, 0x5e, 0x24,
-	0x0c, 0xfd, 0x6c, 0xc0, 0xf2, 0xe3, 0xd0, 0x17, 0xfa, 0x02, 0x26, 0x81, 0xf9, 0x04, 0xcc, 0x34,
-	0x78, 0x85, 0x4c, 0xfb, 0xd1, 0x80, 0xcd, 0x43, 0x1a, 0xc5, 0x81, 0x9a, 0x56, 0x23, 0x97, 0x91,
-	0x50, 0x7c, 0x4d, 0x63, 0x16, 0xba, 0x41, 0x62, 0xf7, 0x07, 0xb0, 0x24, 0xf3, 0xc1, 0xe9, 0x31,
-	0xe2, 0x0a, 0xe2, 0x39, 0x61, 0xf2, 0xa2, 0xaa, 0x4a, 0xf8, 0xbe, 0x46, 0xbf, 0xe1, 0xf2, 0xd5,
-	0xe5, 0xf6, 0xa4, 0xd0, 0x74, 0xe3, 0x00, 0x0d, 0xa9, 0xe6, 0xf1, 0x25, 0x54, 0x06, 0xca, 0x32,
-	0xc7, 0x0d, 0x7c, 0x57, 0x37, 0x90, 0xf2, 0xce, 0xca, 0xf4, 0x04, 0xbe, 0x2b, 0x89, 0x76, 0x59,
-	0x6f, 0x55, 0x0b, 0xf3, 0x53, 0x68, 0xa6, 0x4a, 0xd5, 0x64, 0x50, 0x9d, 0x55, 0x3a, 0x1a, 0x29,
-	0xda, 0x78, 0x5e, 0xbd, 0x09, 0x37, 0x2e, 0xf4, 0x0b, 0x43, 0xf8, 0x67, 0x43, 0x87, 0x0b, 0x03,
-	0x9d, 0xf8, 0xfb, 0x73, 0x98, 0xd7, 0xfb, 0xf1, 0xd0, 0x2f, 0x30, 0x10, 0x37, 0x5d, 0x68, 0x5b,
-	0xe9, 0x42, 0xdb, 0x8a, 0x22, 0x3a, 0x53, 0x10, 0x51, 0x59, 0xdf, 0x33, 0xf6, 0x4d, 0x46, 0xa0,
-	0x07, 0x64, 0x40, 0x05, 0xc9, 0x1e, 0xfe, 0x1f, 0x0d, 0x68, 0x66, 0x71, 0x3c, 0xff, 0xcf, 0xa0,
-	0xe1, 0x91, 0x88, 0x91, 0x9e, 0x52, 0x96, 0x4d, 0x85, 0x7b, 0xa5, 0x96, 0x61, 0x9b, 0x13, 0xf2,
-	0xd8, 0xc6, 0x7b, 0x50, 0xc5, 0xc3, 0xc2, 0x9e, 0x51, 0xba, 0x4a, 0xcf, 0xc0, 0x03, 0xd6, 0x2b,
-	0x79, 0x85, 0x5f, 0x84, 0x1e, 0x2d, 0x32, 0xb6, 0x0d, 0xad, 0x3c, 0x09, 0xfd, 0xdb, 0x18, 0x37,
-	0xc9, 0x97, 0x2e, 0x3f, 0x64, 0x54, 0x6e, 0xf1, 0x12, 0xc6, 0xf7, 0xa0, 0x5d, 0x44, 0x44, 0xd6,
-	0x7f, 0x18, 0x50, 0x3f, 0x22, 0xd9, 0x5b, 0xf1, 0xa6, 0x07, 0x5a, 0x70, 0x3a, 0xa5, 0xa2, 0x7c,
-	0xbf, 0x0b, 0x6b, 0xea, 0x99, 0x20, 0x03, 0xc4, 0x44, 0xc1, 0x1b, 0x61, 0x45, 0x91, 0xa7, 0xab,
-	0x65, 0xfe, 0xb9, 0x35, 0x5b, 0xf0, 0xdc, 0x6a, 0xc0, 0x72, 0xca, 0x0f, 0xf4, 0xee, 0x49, 0xda,
-	0x77, 0x9b, 0x28, 0xbd, 0xe3, 0xc8, 0xbc, 0xa1, 0x9b, 0xd6, 0x75, 0xd8, 0x28, 0x14, 0x86, 0xba,
-	0x7e, 0x2f, 0xeb, 0x7c, 0xa6, 0x81, 0xed, 0x86, 0xde, 0x43, 0x22, 0x32, 0xa3, 0x86, 0xf9, 0x3d,
-	0xac, 0x70, 0x41, 0xa3, 0xb4, 0xf3, 0xce, 0x80, 0x7a, 0xc9, 0xeb, 0xfa, 0x76, 0xc1, 0x04, 0x93,
-	0x6d, 0x8a, 0xd4, 0x23, 0x76, 0x83, 0xe7, 0x41, 0xf9, 0x78, 0xb9, 0x75, 0xa9, 0x01, 0xe3, 0x1f,
-	0x22, 0xaa, 0x27, 0xa3, 0x2e, 0xf3, 0x3d, 0xe7, 0x4a, 0xb3, 0x93, 0xca, 0xf7, 0x8a, 0xe6, 0xc0,
-	0x1f, 0x83, 0x7e, 0x3d, 0x1e, 0x8b, 0x74, 0x8a, 0x7f, 0xf0, 0x3a, 0xa3, 0xf3, 0xf3, 0x11, 0xe6,
-	0x61, 0xb6, 0x90, 0xc8, 0x49, 0x67, 0x9a, 0x70, 0x85, 0x8a, 0x7c, 0x04, 0xd5, 0x7b, 0x6e, 0xef,
-	0x34, 0x1e, 0x4f, 0xb2, 0x5b, 0x50, 0xee, 0xd1, 0xb0, 0x17, 0x33, 0x46, 0xc2, 0xde, 0x08, 0x6b,
-	0x6f, 0x1a, 0x92, 0x3b, 0xd4, 0x73, 0x54, 0xa7, 0x0b, 0xbe, 0x61, 0xd3, 0x90, 0x75, 0x17, 0x6a,
-	0x89, 0x50, 0x34, 0xe1, 0x36, 0xcc, 0x91, 0xe1, 0x24, 0x59, 0x6a, 0x9d, 0xe4, 0x1f, 0x32, 0x7b,
-	0x12, 0xb5, 0x35, 0x11, 0x3b, 0xad, 0xa0, 0x8c, 0xec, 0x33, 0x3a, 0xc8, 0xd8, 0x65, 0xed, 0xca,
-	0x6b, 0x9a, 0xa3, 0xbd, 0x91, 0xf8, 0x26, 0x98, 0x47, 0x81, 0x3b, 0x24, 0xd9, 0xf9, 0x75, 0x1f,
-	0x1a, 0x19, 0xf4, 0x6d, 0xc7, 0x63, 0x13, 0xea, 0xf2, 0xe4, 0x94, 0xac, 0x44, 0xb6, 0xbc, 0x57,
-	0x13, 0x0c, 0x73, 0xfd, 0x7b, 0x3d, 0x27, 0x2a, 0xf0, 0xdd, 0x8e, 0x81, 0x77, 0xe5, 0xb4, 0x36,
-	0x2d, 0xf9, 0x0a, 0x49, 0xa0, 0xcc, 0x74, 0x99, 0xc8, 0xd8, 0x2e, 0xa3, 0x95, 0x02, 0xd1, 0xf8,
-	0xdf, 0xc2, 0xc6, 0x04, 0x7d, 0xe7, 0xe3, 0xde, 0x26, 0xbc, 0x57, 0x2c, 0x1d, 0xb5, 0x9b, 0xfa,
-	0x97, 0x51, 0x49, 0x1d, 0x9f, 0xdf, 0xcf, 0xf4, 0xaf, 0x96, 0x88, 0x5d, 0x3a, 0xe4, 0xfd, 0xc9,
-	0x80, 0xba, 0x6c, 0x71, 0x69, 0x3f, 0x7f, 0x42, 0x0d, 0x18, 0x87, 0xac, 0x6c, 0xc0, 0xe5, 0x70,
-	0x2e, 0x81, 0x82, 0xe6, 0x24, 0x87, 0xf3, 0x1c, 0x09, 0xd9, 0x1e, 0x4f, 0x68, 0xff, 0x6b, 0xe9,
-	0xde, 0x80, 0xf5, 0x02, 0x51, 0x5a, 0xcf, 0xbd, 0x4f, 0x7e, 0xe8, 0x0c, 0x7d, 0x41, 0x38, 0xef,
-	0xf8, 0x74, 0x5b, 0x7f, 0x6d, 0xf7, 0xe9, 0xf6, 0x50, 0x6c, 0xab, 0x7f, 0xb5, 0x6e, 0xe7, 0x7e,
-	0x9b, 0xe9, 0xce, 0x2b, 0xc2, 0x67, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x96, 0x1e, 0xcb, 0x36,
-	0xf4, 0x1d, 0x00, 0x00,
+	0xf5, 0x1f, 0x52, 0x1f, 0x96, 0x0e, 0x3f, 0x44, 0x81, 0x94, 0x48, 0x51, 0xb1, 0x2c, 0xc3, 0x4e,
+	0xe2, 0x7f, 0x32, 0x7f, 0x2a, 0x91, 0x13, 0x4f, 0x26, 0x69, 0x3b, 0x95, 0x6d, 0xc9, 0x76, 0x2c,
+	0xc7, 0x0a, 0xe4, 0x8f, 0x4c, 0xa6, 0x53, 0x0c, 0x48, 0xac, 0x28, 0x8c, 0x40, 0x2c, 0xbc, 0xbb,
+	0xa0, 0xc4, 0x9b, 0x3e, 0x42, 0xfb, 0x02, 0x9d, 0xde, 0x74, 0xa6, 0xbd, 0xef, 0x43, 0xf4, 0x11,
+	0xd2, 0x47, 0xe9, 0x45, 0x2f, 0xda, 0xd9, 0xdd, 0x03, 0x12, 0x20, 0x20, 0x59, 0x56, 0xdd, 0x99,
+	0xdc, 0x68, 0xb0, 0xbf, 0xb3, 0xe7, 0x73, 0xcf, 0x9e, 0x73, 0x96, 0x82, 0xa6, 0x70, 0xba, 0x3e,
+	0x11, 0x03, 0x27, 0x70, 0xfa, 0x84, 0xb9, 0x8e, 0x70, 0x3a, 0x21, 0xa3, 0x82, 0x1a, 0xcb, 0x19,
+	0x42, 0xbb, 0xf4, 0x26, 0x22, 0x6c, 0xa4, 0xe9, 0xed, 0xaa, 0xa0, 0x21, 0x9d, 0xec, 0x6f, 0xaf,
+	0x30, 0x12, 0xfa, 0x5e, 0xcf, 0x11, 0x1e, 0x0d, 0x12, 0x70, 0xc5, 0xa7, 0xfd, 0x48, 0x78, 0xbe,
+	0x5e, 0x9a, 0xff, 0x2e, 0xc0, 0xd2, 0x0b, 0x29, 0xf8, 0x21, 0x39, 0xf2, 0x02, 0x4f, 0x6e, 0x36,
+	0x0c, 0x98, 0x0d, 0x9c, 0x01, 0x69, 0x15, 0x36, 0x0b, 0x77, 0x16, 0x2d, 0xf5, 0x6d, 0xac, 0xc2,
+	0x3c, 0xef, 0x1d, 0x93, 0x81, 0xd3, 0x2a, 0x2a, 0x14, 0x57, 0x46, 0x0b, 0xae, 0xf5, 0xa8, 0x1f,
+	0x0d, 0x02, 0xde, 0x9a, 0xd9, 0x9c, 0xb9, 0xb3, 0x68, 0xc5, 0x4b, 0xa3, 0x03, 0xf5, 0x90, 0x79,
+	0x03, 0x87, 0x8d, 0xec, 0x13, 0x32, 0xb2, 0xe3, 0x5d, 0xb3, 0x6a, 0xd7, 0x32, 0x92, 0x9e, 0x92,
+	0xd1, 0x03, 0xdc, 0x6f, 0xc0, 0xac, 0x18, 0x85, 0xa4, 0x35, 0xa7, 0xb5, 0xca, 0x6f, 0xe3, 0x06,
+	0x94, 0xa4, 0xe9, 0xb6, 0x4f, 0x82, 0xbe, 0x38, 0x6e, 0xcd, 0x6f, 0x16, 0xee, 0xcc, 0x5a, 0x20,
+	0xa1, 0x7d, 0x85, 0x18, 0xeb, 0xb0, 0xc8, 0xe8, 0xa9, 0xdd, 0xa3, 0x51, 0x20, 0x5a, 0xd7, 0x14,
+	0x79, 0x81, 0xd1, 0xd3, 0x07, 0x72, 0x6d, 0xdc, 0x86, 0xf9, 0x23, 0x8f, 0xf8, 0x2e, 0x6f, 0x2d,
+	0x6c, 0xce, 0xdc, 0x29, 0x6d, 0x97, 0x3b, 0x3a, 0x5e, 0x7b, 0x12, 0xb4, 0x90, 0x66, 0xfe, 0xa5,
+	0x00, 0xb5, 0x43, 0xe5, 0x4c, 0x22, 0x04, 0x1f, 0xc3, 0x92, 0xd4, 0xd2, 0x75, 0x38, 0xb1, 0xd1,
+	0x6f, 0x1d, 0x8d, 0x6a, 0x0c, 0x6b, 0x16, 0xe3, 0x39, 0xe8, 0x73, 0xb1, 0xdd, 0x31, 0x33, 0x6f,
+	0x15, 0x95, 0x3a, 0xb3, 0x93, 0x3d, 0xca, 0xa9, 0x50, 0x5b, 0x35, 0x91, 0x06, 0xb8, 0x0c, 0xe8,
+	0x90, 0x30, 0xee, 0xd1, 0xa0, 0x35, 0xa3, 0x34, 0xc6, 0x4b, 0x69, 0xa8, 0xa1, 0xb5, 0x3e, 0x38,
+	0x76, 0x82, 0x3e, 0xb1, 0x08, 0x8f, 0x7c, 0x61, 0x3c, 0x86, 0x4a, 0x97, 0x1c, 0x51, 0x96, 0x32,
+	0xb4, 0xb4, 0x7d, 0x2b, 0x47, 0xfb, 0xb4, 0x9b, 0x56, 0x59, 0x73, 0xa2, 0x2f, 0x7b, 0x50, 0x76,
+	0x8e, 0x04, 0x61, 0x76, 0xe2, 0xa4, 0x2f, 0x29, 0xa8, 0xa4, 0x18, 0x35, 0x6c, 0xfe, 0xb3, 0x00,
+	0xd5, 0x97, 0x9c, 0xb0, 0x03, 0xc2, 0x06, 0x1e, 0xe7, 0x98, 0x52, 0xc7, 0x94, 0x8b, 0x38, 0xa5,
+	0xe4, 0xb7, 0xc4, 0x22, 0x4e, 0x18, 0x26, 0x94, 0xfa, 0x36, 0x3e, 0x85, 0xe5, 0xd0, 0xe1, 0xfc,
+	0x94, 0x32, 0xd7, 0xee, 0x1d, 0x93, 0xde, 0x09, 0x8f, 0x06, 0x2a, 0x0e, 0xb3, 0x56, 0x2d, 0x26,
+	0x3c, 0x40, 0xdc, 0xf8, 0x1e, 0x20, 0x64, 0xde, 0xd0, 0xf3, 0x49, 0x9f, 0xe8, 0xc4, 0x2a, 0x6d,
+	0x7f, 0x9e, 0x63, 0x6d, 0xda, 0x96, 0xce, 0xc1, 0x98, 0x67, 0x37, 0x10, 0x6c, 0x64, 0x25, 0x84,
+	0xb4, 0x7f, 0x09, 0x4b, 0x53, 0x64, 0xa3, 0x06, 0x33, 0x27, 0x64, 0x84, 0x96, 0xcb, 0x4f, 0xa3,
+	0x01, 0x73, 0x43, 0xc7, 0x8f, 0x08, 0x5a, 0xae, 0x17, 0x5f, 0x17, 0xbf, 0x2a, 0x98, 0x3f, 0x15,
+	0xa0, 0xfc, 0xb0, 0xfb, 0x16, 0xbf, 0xab, 0x50, 0x74, 0xbb, 0xc8, 0x5b, 0x74, 0xbb, 0xe3, 0x38,
+	0xcc, 0x24, 0xe2, 0xf0, 0x3c, 0xc7, 0xb5, 0xad, 0x1c, 0xd7, 0x92, 0xca, 0xfe, 0x97, 0x8e, 0xfd,
+	0xb9, 0x00, 0xa5, 0x89, 0x26, 0x6e, 0xec, 0x43, 0x4d, 0xda, 0x69, 0x87, 0x13, 0xac, 0x55, 0x50,
+	0x56, 0xde, 0x7c, 0xeb, 0x01, 0x58, 0x4b, 0x51, 0x6a, 0xcd, 0x8d, 0x3d, 0xa8, 0xba, 0xdd, 0x94,
+	0x2c, 0x7d, 0x83, 0x6e, 0xbc, 0xc5, 0x63, 0xab, 0xe2, 0x26, 0x56, 0xdc, 0xfc, 0x18, 0x4a, 0x07,
+	0x5e, 0xd0, 0xb7, 0xc8, 0x9b, 0x88, 0x70, 0x21, 0xaf, 0x52, 0xe8, 0x8c, 0x7c, 0xea, 0xb8, 0xe8,
+	0x64, 0xbc, 0x34, 0xef, 0x40, 0x59, 0x6f, 0xe4, 0x21, 0x0d, 0x38, 0xb9, 0x60, 0xe7, 0x27, 0x50,
+	0x3e, 0xf4, 0x09, 0x09, 0x63, 0x99, 0x6d, 0x58, 0x70, 0x23, 0xa6, 0x8a, 0xaa, 0xda, 0x3a, 0x63,
+	0x8d, 0xd7, 0xe6, 0x12, 0x54, 0x70, 0xaf, 0x16, 0x6b, 0xfe, 0xa3, 0x00, 0xc6, 0xee, 0x19, 0xe9,
+	0x45, 0x82, 0x3c, 0xa6, 0xf4, 0x24, 0x96, 0x91, 0x57, 0x5f, 0x37, 0x00, 0x42, 0x87, 0x39, 0x03,
+	0x22, 0x08, 0xd3, 0xee, 0x2f, 0x5a, 0x09, 0xc4, 0x38, 0x80, 0x45, 0x72, 0x26, 0x98, 0x63, 0x93,
+	0x60, 0xa8, 0x2a, 0x6d, 0x69, 0xfb, 0x6e, 0x4e, 0x74, 0xb2, 0xda, 0x3a, 0xbb, 0x92, 0x6d, 0x37,
+	0x18, 0xea, 0x9c, 0x58, 0x20, 0xb8, 0x6c, 0x7f, 0x03, 0x95, 0x14, 0xe9, 0x9d, 0xf2, 0xe1, 0x08,
+	0xea, 0x29, 0x55, 0x18, 0xc7, 0x1b, 0x50, 0x22, 0x67, 0x9e, 0xb0, 0xb9, 0x70, 0x44, 0xc4, 0x31,
+	0x40, 0x20, 0xa1, 0x43, 0x85, 0xa8, 0x36, 0x22, 0x5c, 0x1a, 0x89, 0x71, 0x1b, 0x51, 0x2b, 0xc4,
+	0x09, 0x8b, 0x6f, 0x01, 0xae, 0xcc, 0x21, 0xd4, 0x1e, 0x11, 0xa1, 0xeb, 0x4a, 0x1c, 0xbe, 0x55,
+	0x98, 0x57, 0x8e, 0xeb, 0x8c, 0x5b, 0xb4, 0x70, 0x65, 0xdc, 0x82, 0x8a, 0x17, 0xf4, 0xfc, 0xc8,
+	0x25, 0xf6, 0xd0, 0x23, 0xa7, 0x5c, 0xa9, 0x58, 0xb0, 0xca, 0x08, 0xbe, 0x92, 0x98, 0xf1, 0x21,
+	0x54, 0xc9, 0x99, 0xde, 0x84, 0x42, 0x74, 0xdb, 0xaa, 0x20, 0xaa, 0x0a, 0x34, 0x37, 0x09, 0x2c,
+	0x27, 0xf4, 0xa2, 0x77, 0x07, 0xb0, 0xac, 0x2b, 0x63, 0xa2, 0xd8, 0xbf, 0x4b, 0xb5, 0xad, 0xf1,
+	0x29, 0xc4, 0x6c, 0xc2, 0xca, 0x23, 0x22, 0x12, 0x29, 0x8c, 0x3e, 0x9a, 0x3f, 0xc2, 0xea, 0x34,
+	0x01, 0x8d, 0xf8, 0x35, 0x94, 0xd2, 0x97, 0x4e, 0xaa, 0xdf, 0xc8, 0x51, 0x9f, 0x64, 0x4e, 0xb2,
+	0x98, 0x0d, 0x30, 0x0e, 0x89, 0xb0, 0x88, 0xe3, 0x3e, 0x0f, 0xfc, 0x51, 0xac, 0x71, 0x05, 0xea,
+	0x29, 0x14, 0x53, 0x78, 0x02, 0xbf, 0x66, 0x9e, 0x20, 0xf1, 0xee, 0x55, 0x68, 0xa4, 0x61, 0xdc,
+	0xfe, 0x2d, 0x2c, 0xeb, 0xe6, 0xf4, 0x62, 0x14, 0xc6, 0x9b, 0x8d, 0x2f, 0xa1, 0xa4, 0xcd, 0xb3,
+	0x55, 0x83, 0x97, 0x26, 0x57, 0xb7, 0x1b, 0x9d, 0xf1, 0xbc, 0xa2, 0x62, 0x2e, 0x14, 0x07, 0x88,
+	0xf1, 0xb7, 0xb4, 0x33, 0x29, 0x6b, 0x62, 0x90, 0x45, 0x8e, 0x18, 0xe1, 0xc7, 0x32, 0xa5, 0x92,
+	0x06, 0xa5, 0x61, 0xdc, 0xde, 0x84, 0x15, 0x2b, 0x0a, 0x1e, 0x13, 0xc7, 0x17, 0xc7, 0xaa, 0x71,
+	0xc4, 0x0c, 0x2d, 0x58, 0x9d, 0x26, 0x20, 0xcb, 0x17, 0xd0, 0x7a, 0xd2, 0x0f, 0x28, 0x23, 0x9a,
+	0xb8, 0xcb, 0x18, 0x65, 0xa9, 0x92, 0x22, 0x04, 0x61, 0xc1, 0xa4, 0x50, 0xa8, 0xa5, 0xb9, 0x0e,
+	0x6b, 0x39, 0x5c, 0x28, 0xf2, 0x6b, 0x69, 0xb4, 0xac, 0x27, 0xe9, 0x4c, 0xbe, 0x05, 0x95, 0x53,
+	0xc7, 0x13, 0x76, 0x48, 0xf9, 0x24, 0x99, 0x16, 0xad, 0xb2, 0x04, 0x0f, 0x10, 0xd3, 0x9e, 0x25,
+	0x79, 0x51, 0xe6, 0x36, 0xac, 0x1e, 0x30, 0x72, 0xe4, 0x7b, 0xfd, 0xe3, 0xa9, 0x0b, 0x22, 0x67,
+	0x32, 0x15, 0xb8, 0xf8, 0x86, 0xc4, 0x4b, 0xb3, 0x0f, 0xcd, 0x0c, 0x0f, 0xe6, 0xd5, 0x3e, 0x54,
+	0xf5, 0x2e, 0x9b, 0xa9, 0xb9, 0x22, 0xae, 0xe7, 0x1f, 0x9e, 0x9b, 0xd9, 0xc9, 0x29, 0xc4, 0xaa,
+	0xf4, 0x12, 0x2b, 0x6e, 0xfe, 0xab, 0x00, 0xc6, 0x4e, 0x18, 0xfa, 0xa3, 0xb4, 0x65, 0x35, 0x98,
+	0xe1, 0x6f, 0xfc, 0xb8, 0xc4, 0xf0, 0x37, 0xbe, 0x2c, 0x31, 0x47, 0x94, 0xf5, 0x08, 0x5e, 0x56,
+	0xbd, 0x90, 0x63, 0x80, 0xe3, 0xfb, 0xf4, 0xd4, 0x4e, 0xcc, 0xb0, 0xaa, 0x32, 0x2c, 0x58, 0x35,
+	0x45, 0xb0, 0x26, 0x78, 0x76, 0x00, 0x9a, 0x7d, 0x5f, 0x03, 0xd0, 0xdc, 0x15, 0x07, 0xa0, 0xbf,
+	0x16, 0xa0, 0x9e, 0xf2, 0x1e, 0x63, 0xfc, 0xf3, 0x1b, 0xd5, 0xea, 0xb0, 0xbc, 0x4f, 0x7b, 0x27,
+	0xba, 0xea, 0xc5, 0x57, 0xa3, 0x01, 0x46, 0x12, 0x9c, 0x5c, 0xbc, 0x97, 0x81, 0x9f, 0xd9, 0xbc,
+	0x0a, 0x8d, 0x34, 0x8c, 0xdb, 0xff, 0x56, 0x80, 0x16, 0xb6, 0x88, 0x3d, 0x22, 0x7a, 0xc7, 0x3b,
+	0xfc, 0x61, 0x77, 0x9c, 0x07, 0x0d, 0x98, 0x53, 0xa3, 0xb8, 0x0a, 0x40, 0xd9, 0xd2, 0x0b, 0xa3,
+	0x09, 0xd7, 0xdc, 0xae, 0xad, 0x5a, 0x23, 0x76, 0x07, 0xb7, 0xfb, 0x9d, 0x6c, 0x8e, 0x6b, 0xb0,
+	0x30, 0x70, 0xce, 0x6c, 0x46, 0x4f, 0x39, 0x0e, 0x83, 0xd7, 0x06, 0xce, 0x99, 0x45, 0x4f, 0xb9,
+	0x1a, 0xd4, 0x3d, 0xae, 0x26, 0xf0, 0xae, 0x17, 0xf8, 0xb4, 0xcf, 0xd5, 0xf1, 0x2f, 0x58, 0x55,
+	0x84, 0xef, 0x6b, 0x54, 0xde, 0x35, 0xa6, 0xae, 0x51, 0xf2, 0x70, 0x17, 0xac, 0x32, 0x4b, 0xdc,
+	0x2d, 0xf3, 0x11, 0xac, 0xe5, 0xd8, 0x8c, 0xa7, 0xf7, 0x09, 0xcc, 0xeb, 0xab, 0x81, 0xc7, 0x66,
+	0xe0, 0x73, 0xe2, 0x7b, 0xf9, 0x17, 0xaf, 0x01, 0xee, 0x30, 0x7f, 0x5f, 0x80, 0xeb, 0x69, 0x49,
+	0x3b, 0xbe, 0x2f, 0x07, 0x30, 0xfe, 0xfe, 0x43, 0x90, 0xf1, 0x6c, 0x36, 0xc7, 0xb3, 0x7d, 0xd8,
+	0x38, 0xcf, 0x9e, 0x2b, 0xb8, 0xf7, 0x74, 0xfa, 0x6c, 0x77, 0xc2, 0xf0, 0x62, 0xc7, 0x92, 0xf6,
+	0x17, 0x53, 0xf6, 0x67, 0x83, 0xae, 0x84, 0x5d, 0xc1, 0xaa, 0x36, 0xb4, 0x12, 0x75, 0x41, 0x4f,
+	0x1c, 0x71, 0x9a, 0xee, 0xc3, 0x5a, 0x0e, 0x0d, 0x95, 0x6c, 0xc9, 0xe9, 0x63, 0x3c, 0xb1, 0x94,
+	0xb6, 0x9b, 0x9d, 0xe9, 0xb7, 0x33, 0x32, 0xe0, 0x36, 0x79, 0x17, 0x9e, 0x39, 0x5c, 0x5e, 0xa3,
+	0x94, 0x92, 0x67, 0xd0, 0x48, 0xc3, 0x28, 0xff, 0xcb, 0x29, 0xf9, 0xd7, 0x33, 0xf2, 0x53, 0x6c,
+	0xb1, 0x96, 0x26, 0xac, 0x68, 0x3c, 0xee, 0x05, 0xb1, 0x9e, 0x2f, 0x60, 0x75, 0x9a, 0x80, 0x9a,
+	0xda, 0xb0, 0x30, 0xd5, 0x4c, 0xc6, 0x6b, 0xc9, 0xf5, 0xda, 0xf1, 0xc4, 0x1e, 0x9d, 0x96, 0x77,
+	0x21, 0xd7, 0x1a, 0x34, 0x33, 0x5c, 0x78, 0xc5, 0x5b, 0xb0, 0x7a, 0x28, 0x68, 0x98, 0x88, 0x6b,
+	0x6c, 0xe0, 0x1a, 0x34, 0x33, 0x14, 0x64, 0xfa, 0x2d, 0x5c, 0x9f, 0x22, 0x3d, 0xf3, 0x02, 0x6f,
+	0x10, 0x0d, 0x2e, 0x61, 0x8c, 0x71, 0x13, 0x54, 0x6f, 0xb4, 0x85, 0x37, 0x20, 0xf1, 0x10, 0x39,
+	0x63, 0x95, 0x24, 0xf6, 0x42, 0x43, 0xe6, 0x2f, 0x60, 0xe3, 0x3c, 0xf9, 0x97, 0x88, 0x91, 0x32,
+	0xdc, 0x61, 0x22, 0xc7, 0xa7, 0x36, 0xb4, 0xb2, 0x24, 0x74, 0xaa, 0x0b, 0x37, 0xa7, 0x69, 0x2f,
+	0x03, 0xe1, 0xf9, 0x3b, 0xb2, 0xd4, 0xbe, 0x27, 0xc7, 0x6e, 0x83, 0x79, 0x91, 0x0e, 0xb4, 0xa4,
+	0x01, 0xc6, 0x23, 0x12, 0xef, 0x19, 0x27, 0xe6, 0xa7, 0x50, 0x4f, 0xa1, 0x18, 0x89, 0x06, 0xcc,
+	0x39, 0xae, 0xcb, 0xe2, 0x31, 0x41, 0x2f, 0x64, 0x0c, 0x2c, 0xc2, 0xc9, 0x39, 0x31, 0xc8, 0x92,
+	0x50, 0xf3, 0x16, 0x34, 0x5f, 0x25, 0x70, 0x79, 0xa5, 0x73, 0x4b, 0xc2, 0x22, 0x96, 0x04, 0x73,
+	0x0f, 0x5a, 0x59, 0x86, 0x2b, 0x15, 0xa3, 0xeb, 0x49, 0x39, 0x93, 0x6c, 0x8d, 0xd5, 0x57, 0xa1,
+	0xe8, 0xb9, 0xf8, 0x18, 0x29, 0x7a, 0x6e, 0xea, 0x20, 0x8a, 0x53, 0x09, 0xb0, 0x09, 0x1b, 0xe7,
+	0x09, 0x43, 0x3f, 0xeb, 0xb0, 0xfc, 0x24, 0xf0, 0x84, 0xbe, 0x80, 0x71, 0x60, 0x3e, 0x03, 0x23,
+	0x09, 0x5e, 0x22, 0xd3, 0x7e, 0x2a, 0xc0, 0xc6, 0x01, 0x0d, 0x23, 0x5f, 0x4d, 0xab, 0xa1, 0xc3,
+	0x48, 0x20, 0xbe, 0xa5, 0x11, 0x0b, 0x1c, 0x3f, 0xb6, 0xfb, 0x23, 0x58, 0x92, 0xf9, 0x60, 0xf7,
+	0x18, 0x71, 0x04, 0x71, 0xed, 0x20, 0x7e, 0x51, 0x55, 0x24, 0xfc, 0x40, 0xa3, 0xdf, 0x71, 0xf9,
+	0xea, 0x72, 0x7a, 0x52, 0x68, 0xb2, 0x71, 0x80, 0x86, 0x54, 0xf3, 0xf8, 0x0a, 0xca, 0x03, 0x65,
+	0x99, 0xed, 0xf8, 0x9e, 0xa3, 0x1b, 0x48, 0x69, 0x7b, 0x65, 0x7a, 0x02, 0xdf, 0x91, 0x44, 0xab,
+	0xa4, 0xb7, 0xaa, 0x85, 0xf1, 0x39, 0x34, 0x12, 0xa5, 0x6a, 0x32, 0xa8, 0xce, 0x2a, 0x1d, 0xf5,
+	0x04, 0x6d, 0x3c, 0xaf, 0xde, 0x84, 0x1b, 0xe7, 0xfa, 0x85, 0x21, 0xfc, 0x53, 0x41, 0x87, 0x0b,
+	0x03, 0x1d, 0xfb, 0xfb, 0xff, 0x30, 0xaf, 0xf7, 0xe3, 0xa1, 0x9f, 0x63, 0x20, 0x6e, 0x3a, 0xd7,
+	0xb6, 0xe2, 0xb9, 0xb6, 0xe5, 0x45, 0x74, 0x26, 0x27, 0xa2, 0xb2, 0xbe, 0xa7, 0xec, 0x9b, 0x8c,
+	0x40, 0x0f, 0xc9, 0x80, 0x0a, 0x92, 0x3e, 0xfc, 0x3f, 0x14, 0xa0, 0x91, 0xc6, 0xf1, 0xfc, 0xef,
+	0x42, 0xdd, 0x25, 0x21, 0x23, 0x3d, 0xa5, 0x2c, 0x9d, 0x0a, 0xf7, 0x8b, 0xad, 0x82, 0x65, 0x4c,
+	0xc8, 0x63, 0x1b, 0xef, 0x43, 0x05, 0x0f, 0x0b, 0x7b, 0x46, 0xf1, 0x32, 0x3d, 0x03, 0x0f, 0x58,
+	0xaf, 0xe4, 0x15, 0x7e, 0x19, 0xb8, 0x34, 0xcf, 0xd8, 0x36, 0xb4, 0xb2, 0x24, 0xf4, 0x6f, 0x7d,
+	0xdc, 0x24, 0x5f, 0x3b, 0xfc, 0x80, 0x51, 0xb9, 0xc5, 0x8d, 0x19, 0x3f, 0x80, 0x76, 0x1e, 0x11,
+	0x59, 0xff, 0x5e, 0x80, 0xda, 0x21, 0x49, 0xdf, 0x8a, 0x77, 0x3d, 0xd0, 0x9c, 0xd3, 0x29, 0xe6,
+	0xe5, 0xfb, 0x3d, 0x68, 0xaa, 0x67, 0x82, 0x0c, 0x10, 0x13, 0x39, 0x6f, 0x84, 0x15, 0x45, 0x9e,
+	0xae, 0x96, 0xd9, 0xe7, 0xd6, 0x6c, 0xce, 0x73, 0xab, 0x0e, 0xcb, 0x09, 0x3f, 0xd0, 0xbb, 0xa7,
+	0x49, 0xdf, 0x2d, 0xa2, 0xf4, 0x8e, 0x23, 0xf3, 0x8e, 0x6e, 0x9a, 0xd7, 0x61, 0x3d, 0x57, 0x18,
+	0xea, 0xfa, 0x9d, 0xac, 0xf3, 0xa9, 0x06, 0xb6, 0x13, 0xb8, 0x8f, 0x88, 0x48, 0x8d, 0x1a, 0xc6,
+	0x0f, 0xb0, 0xc2, 0x05, 0x0d, 0x93, 0xce, 0xdb, 0x03, 0xea, 0xc6, 0xaf, 0xeb, 0xdb, 0x39, 0x13,
+	0x4c, 0xba, 0x29, 0x52, 0x97, 0x58, 0x75, 0x9e, 0x05, 0xe5, 0xe3, 0xe5, 0xd6, 0x85, 0x06, 0x8c,
+	0x7f, 0x88, 0xa8, 0x1c, 0x8f, 0xba, 0xcc, 0x73, 0xed, 0x4b, 0xcd, 0x4e, 0x2a, 0xdf, 0xcb, 0x9a,
+	0x03, 0x7f, 0x0c, 0xfa, 0xd5, 0x78, 0x2c, 0xd2, 0x29, 0xfe, 0xd1, 0xdb, 0x8c, 0xce, 0xce, 0x47,
+	0x98, 0x87, 0xe9, 0x42, 0x22, 0x27, 0x9d, 0x69, 0xc2, 0x25, 0x2a, 0xf2, 0x21, 0x54, 0xee, 0x3b,
+	0xbd, 0x93, 0x68, 0x3c, 0xc9, 0x6e, 0x42, 0xa9, 0x47, 0x83, 0x5e, 0xc4, 0x18, 0x09, 0x7a, 0x23,
+	0xac, 0xbd, 0x49, 0x48, 0xee, 0x50, 0xcf, 0x51, 0x9d, 0x2e, 0xf8, 0x86, 0x4d, 0x42, 0xe6, 0x3d,
+	0xa8, 0xc6, 0x42, 0xd1, 0x84, 0xdb, 0x30, 0x47, 0x86, 0x93, 0x64, 0xa9, 0x76, 0xe2, 0x7f, 0xc8,
+	0xec, 0x4a, 0xd4, 0xd2, 0x44, 0xec, 0xb4, 0x82, 0x32, 0xb2, 0xc7, 0xe8, 0x20, 0x65, 0x97, 0xb9,
+	0x23, 0xaf, 0x69, 0x86, 0xf6, 0x4e, 0xe2, 0x1b, 0x60, 0x1c, 0xfa, 0xce, 0x90, 0xa4, 0xe7, 0xd7,
+	0x3d, 0xa8, 0xa7, 0xd0, 0xab, 0x8e, 0xc7, 0x06, 0xd4, 0xe4, 0xc9, 0x29, 0x59, 0xb1, 0x6c, 0x79,
+	0xaf, 0x26, 0x18, 0xe6, 0xfa, 0x0f, 0x7a, 0x4e, 0x54, 0xe0, 0xfb, 0x1d, 0x03, 0xef, 0xc9, 0x69,
+	0x6d, 0x5a, 0xf2, 0x25, 0x92, 0x40, 0x99, 0xe9, 0x30, 0x91, 0xb2, 0x5d, 0x46, 0x2b, 0x01, 0xa2,
+	0xf1, 0xbf, 0x81, 0xf5, 0x09, 0xfa, 0xde, 0xc7, 0xbd, 0x0d, 0xf8, 0x20, 0x5f, 0x3a, 0x6a, 0x37,
+	0xf4, 0x2f, 0xa3, 0x92, 0x3a, 0x3e, 0xbf, 0xff, 0xd3, 0xbf, 0x5a, 0x22, 0x76, 0xe1, 0x90, 0xf7,
+	0xc7, 0x02, 0xd4, 0x64, 0x8b, 0x4b, 0xfa, 0xf9, 0x33, 0x6a, 0xc0, 0x38, 0x64, 0xa5, 0x03, 0x2e,
+	0x87, 0x73, 0x09, 0xe4, 0x34, 0x27, 0x39, 0x9c, 0x67, 0x48, 0xc8, 0xf6, 0x64, 0x42, 0xfb, 0x6f,
+	0x4b, 0xf7, 0x3a, 0xac, 0xe5, 0x88, 0x42, 0x3d, 0xb7, 0xa1, 0xfc, 0xea, 0xed, 0x53, 0xef, 0x37,
+	0x50, 0x79, 0x75, 0xd5, 0x51, 0xf7, 0xfe, 0x67, 0x3f, 0x76, 0x86, 0x9e, 0x20, 0x9c, 0x77, 0x3c,
+	0xba, 0xa5, 0xbf, 0xb6, 0xfa, 0x74, 0x6b, 0x28, 0xb6, 0xd4, 0x7f, 0x73, 0xb7, 0x32, 0x3f, 0xff,
+	0x74, 0xe7, 0x15, 0xe1, 0xee, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xf8, 0x35, 0x01, 0x5d, 0x57,
+	0x1e, 0x00, 0x00,
 }
diff --git a/go/vt/proto/tabletmanagerservice/tabletmanagerservice.pb.go b/go/vt/proto/tabletmanagerservice/tabletmanagerservice.pb.go
index ac5081933d4..28e717a9db3 100644
--- a/go/vt/proto/tabletmanagerservice/tabletmanagerservice.pb.go
+++ b/go/vt/proto/tabletmanagerservice/tabletmanagerservice.pb.go
@@ -29,77 +29,78 @@ const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 func init() { proto.RegisterFile("tabletmanagerservice.proto", fileDescriptor_9ee75fe63cfd9360) }
 
 var fileDescriptor_9ee75fe63cfd9360 = []byte{
-	// 1116 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x98, 0xdb, 0x6f, 0x1b, 0x45,
-	0x14, 0xc6, 0x89, 0x04, 0x95, 0x98, 0x72, 0x1d, 0x2a, 0x2a, 0x05, 0x89, 0x5b, 0x13, 0x28, 0x71,
-	0xb1, 0x7b, 0xa1, 0xbc, 0xbb, 0x97, 0xa4, 0x41, 0x8d, 0x30, 0x76, 0x43, 0x10, 0x48, 0x95, 0x26,
-	0xf6, 0x89, 0xbd, 0x64, 0xbd, 0xb3, 0xcc, 0x8c, 0x2d, 0xf2, 0x84, 0xd4, 0x57, 0x24, 0xfe, 0x66,
-	0xb4, 0xeb, 0x9d, 0xdd, 0x33, 0xbb, 0x67, 0x8f, 0x37, 0x6f, 0x96, 0xbf, 0xdf, 0x9c, 0x6f, 0x2e,
-	0x67, 0xce, 0xcc, 0x8e, 0xd8, 0x75, 0xea, 0x3c, 0x06, 0xb7, 0x54, 0x89, 0x9a, 0x83, 0xb1, 0x60,
-	0xd6, 0xd1, 0x14, 0xfa, 0xa9, 0xd1, 0x4e, 0xcb, 0x5b, 0x94, 0xb6, 0x7b, 0x3b, 0xf8, 0x77, 0xa6,
-	0x9c, 0xda, 0xe0, 0x0f, 0xdf, 0xf4, 0xc4, 0xfb, 0xaf, 0x72, 0xed, 0x64, 0xa3, 0xc9, 0x63, 0xf1,
-	0xf6, 0x28, 0x4a, 0xe6, 0xf2, 0xf3, 0x7e, 0xb3, 0x4d, 0x26, 0x8c, 0xe1, 0xaf, 0x15, 0x58, 0xb7,
-	0xfb, 0x45, 0xab, 0x6e, 0x53, 0x9d, 0x58, 0xf8, 0xfa, 0x2d, 0xf9, 0x52, 0xbc, 0x33, 0x89, 0x01,
-	0x52, 0x49, 0xb1, 0xb9, 0xe2, 0x83, 0x7d, 0xd9, 0x0e, 0x94, 0xd1, 0x5e, 0x8b, 0x9b, 0xcf, 0xff,
-	0x86, 0xe9, 0xca, 0xc1, 0x0b, 0xad, 0x2f, 0xe5, 0x3e, 0xd1, 0x04, 0xe9, 0x3e, 0xf2, 0x37, 0xdb,
-	0xb0, 0x32, 0xfe, 0x6f, 0xe2, 0xdd, 0x23, 0x70, 0x93, 0xe9, 0x02, 0x96, 0x4a, 0xde, 0x21, 0x9a,
-	0x95, 0xaa, 0x8f, 0xbd, 0xc7, 0x43, 0x65, 0xe4, 0xb9, 0xf8, 0xe0, 0x08, 0xdc, 0x08, 0xcc, 0x32,
-	0xb2, 0x36, 0xd2, 0x89, 0x95, 0x77, 0xe9, 0x96, 0x08, 0xf1, 0x1e, 0xdf, 0x75, 0x20, 0xf1, 0x14,
-	0x4d, 0xc0, 0x8d, 0x41, 0xcd, 0x7e, 0x4e, 0xe2, 0x2b, 0x72, 0x8a, 0x90, 0xce, 0x4d, 0x51, 0x80,
-	0x95, 0xf1, 0x95, 0x78, 0xaf, 0x10, 0xce, 0x4c, 0xe4, 0x40, 0x32, 0x2d, 0x73, 0xc0, 0x3b, 0x7c,
-	0xbb, 0x95, 0x2b, 0x2d, 0xfe, 0x10, 0xe2, 0xe9, 0x42, 0x25, 0x73, 0x78, 0x75, 0x95, 0x82, 0xa4,
-	0x66, 0xb8, 0x92, 0x7d, 0xf8, 0xfd, 0x2d, 0x14, 0xee, 0xff, 0x18, 0x2e, 0x0c, 0xd8, 0xc5, 0xc4,
-	0xa9, 0x96, 0xfe, 0x63, 0x80, 0xeb, 0x7f, 0xc8, 0xe1, 0xb5, 0x1e, 0xaf, 0x92, 0x17, 0xa0, 0x62,
-	0xb7, 0x78, 0xba, 0x80, 0xe9, 0x25, 0xb9, 0xd6, 0x21, 0xc2, 0xad, 0x75, 0x9d, 0x2c, 0x8d, 0x52,
-	0xf1, 0xf1, 0xf1, 0x3c, 0xd1, 0x06, 0x36, 0xf2, 0x73, 0x63, 0xb4, 0x91, 0x3d, 0x22, 0x42, 0x83,
-	0xf2, 0x76, 0xf7, 0xba, 0xc1, 0xe1, 0xec, 0xc5, 0x5a, 0xcd, 0x8a, 0x3d, 0x42, 0xcf, 0x5e, 0x05,
-	0xf0, 0xb3, 0x87, 0xb9, 0xd2, 0xe2, 0x4f, 0xf1, 0xe1, 0xc8, 0xc0, 0x45, 0x1c, 0xcd, 0x17, 0x7e,
-	0x27, 0x52, 0x93, 0x52, 0x63, 0xbc, 0xd1, 0x41, 0x17, 0x14, 0x6f, 0x96, 0x61, 0x9a, 0xc6, 0x57,
-	0x85, 0x0f, 0x95, 0x44, 0x48, 0xe7, 0x36, 0x4b, 0x80, 0xe1, 0x4c, 0x7e, 0xa9, 0xa7, 0x97, 0x79,
-	0x75, 0xb5, 0x64, 0x26, 0x57, 0x32, 0x97, 0xc9, 0x98, 0xc2, 0x6b, 0x71, 0x9a, 0xc4, 0x55, 0x78,
-	0xaa, 0x5b, 0x18, 0xe0, 0xd6, 0x22, 0xe4, 0x70, 0x82, 0x15, 0x85, 0xf2, 0x10, 0xdc, 0x74, 0x31,
-	0xb4, 0xcf, 0xce, 0x15, 0x99, 0x60, 0x0d, 0x8a, 0x4b, 0x30, 0x02, 0x2e, 0x1d, 0xff, 0x11, 0x9f,
-	0x86, 0xf2, 0x30, 0x8e, 0x47, 0x26, 0x5a, 0x5b, 0x79, 0x7f, 0x6b, 0x24, 0x8f, 0x7a, 0xef, 0x07,
-	0xd7, 0x68, 0xd1, 0x3e, 0xe4, 0x61, 0x9a, 0x76, 0x18, 0xf2, 0x30, 0x4d, 0xbb, 0x0f, 0x39, 0x87,
-	0xb1, 0xe3, 0x18, 0xd2, 0x38, 0x9a, 0x2a, 0x17, 0xe9, 0x24, 0x2b, 0x26, 0x2b, 0x4b, 0x3a, 0x36,
-	0x28, 0xce, 0x91, 0x80, 0x71, 0xe6, 0x9c, 0x28, 0xeb, 0xc0, 0x14, 0x66, 0x54, 0xe6, 0x60, 0x80,
-	0xcb, 0x9c, 0x90, 0xc3, 0x35, 0x70, 0xa3, 0x8c, 0xb4, 0x8d, 0xb2, 0x4e, 0x90, 0x35, 0x30, 0x44,
-	0xb8, 0x1a, 0x58, 0x27, 0x71, 0xb9, 0x38, 0x53, 0x91, 0x3b, 0xd4, 0x95, 0x13, 0xd5, 0xbe, 0xc6,
-	0x70, 0xe5, 0xa2, 0x81, 0x62, 0xaf, 0x89, 0xd3, 0x29, 0x9a, 0x5a, 0xd2, 0xab, 0xc6, 0x70, 0x5e,
-	0x0d, 0x14, 0x6f, 0x84, 0x9a, 0x78, 0x12, 0x25, 0xd1, 0x72, 0xb5, 0x24, 0x37, 0x02, 0x8d, 0x72,
-	0x1b, 0xa1, 0xad, 0x45, 0xd9, 0x81, 0xa5, 0xf8, 0x68, 0xe2, 0x94, 0x71, 0x78, 0xb4, 0xf4, 0x10,
-	0x42, 0xc8, 0x9b, 0xf6, 0x3a, 0xb1, 0xa5, 0xdd, 0xbf, 0x3b, 0x62, 0xb7, 0x2e, 0x9f, 0x26, 0x2e,
-	0x8a, 0x87, 0x17, 0x0e, 0x8c, 0xfc, 0xa1, 0x43, 0xb4, 0x0a, 0xf7, 0x7d, 0x78, 0x7c, 0xcd, 0x56,
-	0xf8, 0x60, 0x38, 0x02, 0x4f, 0x59, 0xf2, 0x60, 0x40, 0x3a, 0x77, 0x30, 0x04, 0x18, 0x9e, 0xdc,
-	0x5f, 0x51, 0x1f, 0xb2, 0xf2, 0x40, 0x4e, 0x6e, 0x1d, 0xe2, 0x26, 0xb7, 0xc9, 0xe2, 0x64, 0xc2,
-	0x6a, 0x95, 0xe1, 0x64, 0x32, 0xd1, 0x28, 0x97, 0x4c, 0x6d, 0x2d, 0xf0, 0x78, 0xc7, 0x60, 0x61,
-	0x6b, 0x32, 0xd5, 0x21, 0x6e, 0xbc, 0x4d, 0x16, 0x9f, 0xbb, 0xc7, 0x49, 0xe4, 0x36, 0x45, 0x83,
-	0x3c, 0x77, 0x2b, 0x99, 0x3b, 0x77, 0x31, 0x55, 0x06, 0x7f, 0xb3, 0x23, 0x6e, 0x8f, 0x74, 0xba,
-	0x8a, 0xf3, 0x5b, 0x5f, 0xaa, 0x0c, 0x24, 0xee, 0x27, 0xbd, 0x32, 0x89, 0x8a, 0x25, 0x35, 0x39,
-	0x2d, 0xac, 0xf7, 0x7d, 0x78, 0x9d, 0x26, 0x38, 0x41, 0xb3, 0xce, 0x15, 0xc3, 0x97, 0x6d, 0x9d,
-	0x2f, 0x74, 0x2e, 0x41, 0x03, 0x0c, 0x1f, 0x11, 0xcf, 0x60, 0xa9, 0x1d, 0x14, 0x73, 0x48, 0xb5,
-	0xc4, 0x00, 0x77, 0x44, 0x84, 0x1c, 0xce, 0x89, 0xd3, 0x64, 0xa6, 0x03, 0x9b, 0x03, 0xf2, 0x6e,
-	0x12, 0x42, 0x5c, 0x4e, 0x34, 0xd9, 0xd2, 0xce, 0x0a, 0x59, 0x0c, 0xf3, 0x4c, 0xd9, 0x91, 0xd1,
-	0x19, 0x34, 0x93, 0xcc, 0xd1, 0x89, 0x30, 0x6f, 0xf9, 0x7d, 0x47, 0x1a, 0x7f, 0x50, 0x4e, 0xc0,
-	0xe7, 0xe1, 0x1d, 0xfa, 0x13, 0x28, 0x1c, 0xd5, 0x1e, 0x0f, 0x95, 0x91, 0xd7, 0xe2, 0x93, 0xca,
-	0x79, 0x0c, 0x36, 0xab, 0x6a, 0x30, 0x93, 0x7c, 0x0f, 0x4b, 0xce, 0xbb, 0xf5, 0xbb, 0xe2, 0xa5,
-	0xef, 0x7f, 0x3b, 0xe2, 0xb3, 0xda, 0xd9, 0x31, 0x4c, 0x66, 0xd9, 0x27, 0xef, 0xe6, 0x2e, 0xf1,
-	0x78, 0xfb, 0x59, 0x83, 0x79, 0xdf, 0x91, 0x1f, 0xaf, 0xdb, 0x0c, 0xdf, 0x34, 0x8a, 0x89, 0xf7,
-	0x9b, 0xe1, 0x2e, 0xf9, 0x0d, 0x80, 0x11, 0xee, 0xa6, 0x51, 0x27, 0x4b, 0xa3, 0x5f, 0xc4, 0x8d,
-	0x27, 0x6a, 0x7a, 0xb9, 0x4a, 0x25, 0xf5, 0x54, 0xb1, 0x91, 0x7c, 0xe0, 0xaf, 0x18, 0xc2, 0x07,
-	0xbc, 0xbf, 0x23, 0x4d, 0x76, 0xf5, 0xb3, 0x4e, 0x1b, 0x38, 0x34, 0x7a, 0x59, 0x44, 0x6f, 0xa9,
-	0x75, 0x21, 0xc5, 0x5f, 0xfd, 0x1a, 0x30, 0xf2, 0x7c, 0x2d, 0x6e, 0x4e, 0x62, 0xb5, 0x86, 0x62,
-	0xbd, 0xc8, 0x07, 0x82, 0x4a, 0x67, 0x1f, 0x08, 0x30, 0x16, 0xa4, 0xbc, 0xd3, 0x69, 0x2e, 0xd2,
-	0x29, 0xef, 0x55, 0x36, 0xe5, 0x2b, 0x28, 0xbc, 0x91, 0x14, 0x7f, 0xfb, 0xcb, 0xd0, 0x01, 0xd7,
-	0xb6, 0x76, 0x0d, 0xea, 0x75, 0x62, 0xf1, 0x21, 0x92, 0xdf, 0x15, 0x36, 0x23, 0xd9, 0x6b, 0xbb,
-	0x4a, 0x04, 0x43, 0xd9, 0xdf, 0x42, 0x95, 0xc1, 0xaf, 0xc4, 0xad, 0xea, 0x7f, 0x74, 0xcf, 0xe9,
-	0xb3, 0x01, 0x9a, 0x37, 0x9c, 0x41, 0x67, 0xbe, 0xfe, 0xc8, 0x95, 0xe9, 0xb6, 0xf5, 0x91, 0x2b,
-	0x57, 0xb7, 0x3d, 0x72, 0x15, 0x10, 0x8e, 0x9c, 0x9d, 0x26, 0xed, 0x4b, 0x5f, 0xaa, 0x5c, 0x64,
-	0x04, 0x05, 0x4b, 0x9f, 0xfd, 0x85, 0x4b, 0xf7, 0x41, 0x5b, 0x4a, 0x12, 0x85, 0xbb, 0xd7, 0x89,
-	0xc5, 0x9f, 0x64, 0x5e, 0xad, 0x4a, 0x2b, 0x17, 0xa3, 0x51, 0x58, 0xef, 0x75, 0x83, 0xbd, 0xe3,
-	0x93, 0x47, 0xbf, 0x3f, 0x58, 0x47, 0x0e, 0xac, 0xed, 0x47, 0x7a, 0xb0, 0xf9, 0x35, 0x98, 0xeb,
-	0xc1, 0xda, 0x0d, 0xf2, 0x47, 0xda, 0x01, 0xf5, 0xa4, 0x7b, 0x7e, 0x23, 0xd7, 0x1e, 0xfd, 0x1f,
-	0x00, 0x00, 0xff, 0xff, 0x6e, 0x16, 0x3b, 0x7d, 0x0d, 0x16, 0x00, 0x00,
+	// 1134 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x98, 0x6d, 0x6f, 0x23, 0x35,
+	0x10, 0xc7, 0xa9, 0x04, 0x27, 0xe1, 0xe3, 0xd1, 0x9c, 0x38, 0xa9, 0x48, 0x70, 0x70, 0x2d, 0x1c,
+	0xcd, 0x91, 0xdc, 0x03, 0xc7, 0xfb, 0xdc, 0x43, 0x7b, 0x45, 0x57, 0x11, 0x92, 0x6b, 0x8b, 0x40,
+	0x3a, 0xc9, 0x4d, 0xa6, 0xc9, 0xd2, 0xcd, 0x7a, 0xb1, 0x9d, 0x88, 0xbe, 0x42, 0xe2, 0x2d, 0x12,
+	0x9f, 0x8d, 0x8f, 0x84, 0xf6, 0xc1, 0xde, 0xf1, 0xee, 0xac, 0xb3, 0x79, 0x17, 0xe5, 0xff, 0xf3,
+	0x8c, 0x3d, 0x1e, 0x8f, 0x67, 0xcd, 0x76, 0x8d, 0xb8, 0x88, 0xc1, 0x2c, 0x45, 0x22, 0xe6, 0xa0,
+	0x34, 0xa8, 0x75, 0x34, 0x85, 0x7e, 0xaa, 0xa4, 0x91, 0xfc, 0x16, 0xa5, 0xed, 0xde, 0xf6, 0xfe,
+	0x9d, 0x09, 0x23, 0x0a, 0xfc, 0xd1, 0x7f, 0x3d, 0xf6, 0xfe, 0xeb, 0x5c, 0x3b, 0x29, 0x34, 0x7e,
+	0xcc, 0xde, 0x1e, 0x45, 0xc9, 0x9c, 0x7f, 0xde, 0x6f, 0x8e, 0xc9, 0x84, 0x31, 0xfc, 0xb1, 0x02,
+	0x6d, 0x76, 0xbf, 0x68, 0xd5, 0x75, 0x2a, 0x13, 0x0d, 0x5f, 0xbd, 0xc5, 0x5f, 0xb1, 0x77, 0x26,
+	0x31, 0x40, 0xca, 0x29, 0x36, 0x57, 0xac, 0xb1, 0x3b, 0xed, 0x80, 0xb3, 0xf6, 0x86, 0xdd, 0x7c,
+	0xf1, 0x27, 0x4c, 0x57, 0x06, 0x5e, 0x4a, 0x79, 0xc5, 0xf7, 0x89, 0x21, 0x48, 0xb7, 0x96, 0xbf,
+	0xde, 0x84, 0x39, 0xfb, 0xbf, 0xb0, 0x77, 0x8f, 0xc0, 0x4c, 0xa6, 0x0b, 0x58, 0x0a, 0x7e, 0x97,
+	0x18, 0xe6, 0x54, 0x6b, 0x7b, 0x2f, 0x0c, 0x39, 0xcb, 0x73, 0xf6, 0xc1, 0x11, 0x98, 0x11, 0xa8,
+	0x65, 0xa4, 0x75, 0x24, 0x13, 0xcd, 0xef, 0xd1, 0x23, 0x11, 0x62, 0x7d, 0x7c, 0xdb, 0x81, 0xc4,
+	0x21, 0x9a, 0x80, 0x19, 0x83, 0x98, 0xfd, 0x94, 0xc4, 0xd7, 0x64, 0x88, 0x90, 0x1e, 0x0a, 0x91,
+	0x87, 0x39, 0xfb, 0x82, 0xbd, 0x57, 0x0a, 0xe7, 0x2a, 0x32, 0xc0, 0x03, 0x23, 0x73, 0xc0, 0x7a,
+	0xf8, 0x66, 0x23, 0xe7, 0x5c, 0xfc, 0xc6, 0xd8, 0xb3, 0x85, 0x48, 0xe6, 0xf0, 0xfa, 0x3a, 0x05,
+	0x4e, 0x45, 0xb8, 0x92, 0xad, 0xf9, 0xfd, 0x0d, 0x14, 0x9e, 0xff, 0x18, 0x2e, 0x15, 0xe8, 0xc5,
+	0xc4, 0x88, 0x96, 0xf9, 0x63, 0x20, 0x34, 0x7f, 0x9f, 0xc3, 0x7b, 0x3d, 0x5e, 0x25, 0x2f, 0x41,
+	0xc4, 0x66, 0xf1, 0x6c, 0x01, 0xd3, 0x2b, 0x72, 0xaf, 0x7d, 0x24, 0xb4, 0xd7, 0x75, 0xd2, 0x39,
+	0x4a, 0xd9, 0xc7, 0xc7, 0xf3, 0x44, 0x2a, 0x28, 0xe4, 0x17, 0x4a, 0x49, 0xc5, 0x7b, 0x84, 0x85,
+	0x06, 0x65, 0xdd, 0xdd, 0xef, 0x06, 0xfb, 0xd1, 0x8b, 0xa5, 0x98, 0x95, 0x67, 0x84, 0x8e, 0x5e,
+	0x05, 0x84, 0xa3, 0x87, 0x39, 0xe7, 0xe2, 0x77, 0xf6, 0xe1, 0x48, 0xc1, 0x65, 0x1c, 0xcd, 0x17,
+	0xf6, 0x24, 0x52, 0x41, 0xa9, 0x31, 0xd6, 0xd1, 0x41, 0x17, 0x14, 0x1f, 0x96, 0x61, 0x9a, 0xc6,
+	0xd7, 0xa5, 0x1f, 0x2a, 0x89, 0x90, 0x1e, 0x3a, 0x2c, 0x1e, 0x86, 0x33, 0xf9, 0x95, 0x9c, 0x5e,
+	0xe5, 0xd5, 0x55, 0x93, 0x99, 0x5c, 0xc9, 0xa1, 0x4c, 0xc6, 0x14, 0xde, 0x8b, 0xd3, 0x24, 0xae,
+	0xcc, 0x53, 0xd3, 0xc2, 0x40, 0x68, 0x2f, 0x7c, 0x0e, 0x27, 0x58, 0x59, 0x28, 0x0f, 0xc1, 0x4c,
+	0x17, 0x43, 0xfd, 0xfc, 0x42, 0x90, 0x09, 0xd6, 0xa0, 0x42, 0x09, 0x46, 0xc0, 0xce, 0xe3, 0x5f,
+	0xec, 0x53, 0x5f, 0x1e, 0xc6, 0xf1, 0x48, 0x45, 0x6b, 0xcd, 0x1f, 0x6c, 0xb4, 0x64, 0x51, 0xeb,
+	0xfb, 0xe1, 0x16, 0x23, 0xda, 0x97, 0x3c, 0x4c, 0xd3, 0x0e, 0x4b, 0x1e, 0xa6, 0x69, 0xf7, 0x25,
+	0xe7, 0x30, 0xf6, 0x38, 0x86, 0x34, 0x8e, 0xa6, 0xc2, 0x44, 0x32, 0xc9, 0x8a, 0xc9, 0x4a, 0x93,
+	0x1e, 0x1b, 0x54, 0xc8, 0x23, 0x01, 0xe3, 0xcc, 0x39, 0x11, 0xda, 0x80, 0x2a, 0x9d, 0x51, 0x99,
+	0x83, 0x81, 0x50, 0xe6, 0xf8, 0x1c, 0xae, 0x81, 0x85, 0x32, 0x92, 0x3a, 0xca, 0x26, 0x41, 0xd6,
+	0x40, 0x1f, 0x09, 0xd5, 0xc0, 0x3a, 0x89, 0xcb, 0xc5, 0xb9, 0x88, 0xcc, 0xa1, 0xac, 0x3c, 0x51,
+	0xe3, 0x6b, 0x4c, 0xa8, 0x5c, 0x34, 0x50, 0xec, 0x6b, 0x62, 0x64, 0x8a, 0x42, 0x4b, 0xfa, 0xaa,
+	0x31, 0x21, 0x5f, 0x0d, 0x14, 0x1f, 0x84, 0x9a, 0x78, 0x12, 0x25, 0xd1, 0x72, 0xb5, 0x24, 0x0f,
+	0x02, 0x8d, 0x86, 0x0e, 0x42, 0xdb, 0x08, 0x37, 0x81, 0x25, 0xfb, 0x68, 0x62, 0x84, 0x32, 0x78,
+	0xb5, 0xf4, 0x12, 0x7c, 0xc8, 0x3a, 0xed, 0x75, 0x62, 0x9d, 0xbb, 0x7f, 0x76, 0xd8, 0x6e, 0x5d,
+	0x3e, 0x4d, 0x4c, 0x14, 0x0f, 0x2f, 0x0d, 0x28, 0xfe, 0x7d, 0x07, 0x6b, 0x15, 0x6e, 0xe7, 0xf0,
+	0x64, 0xcb, 0x51, 0xf8, 0x62, 0x38, 0x02, 0x4b, 0x69, 0xf2, 0x62, 0x40, 0x7a, 0xe8, 0x62, 0xf0,
+	0x30, 0x1c, 0xdc, 0x33, 0x34, 0x87, 0xac, 0x3c, 0x90, 0xc1, 0xad, 0x43, 0xa1, 0xe0, 0x36, 0x59,
+	0x9c, 0x4c, 0x58, 0xad, 0x32, 0x9c, 0x4c, 0x26, 0x1a, 0x0d, 0x25, 0x53, 0xdb, 0x08, 0xbc, 0xde,
+	0x31, 0x68, 0xd8, 0x98, 0x4c, 0x75, 0x28, 0xb4, 0xde, 0x26, 0x8b, 0xef, 0xdd, 0xe3, 0x24, 0x32,
+	0x45, 0xd1, 0x20, 0xef, 0xdd, 0x4a, 0x0e, 0xdd, 0xbb, 0x98, 0x72, 0xc6, 0xff, 0xde, 0x61, 0xb7,
+	0x47, 0x32, 0x5d, 0xc5, 0x79, 0xd7, 0x97, 0x0a, 0x05, 0x89, 0xf9, 0x51, 0xae, 0x54, 0x22, 0x62,
+	0x4e, 0x05, 0xa7, 0x85, 0xb5, 0x7e, 0x1f, 0x6d, 0x33, 0x04, 0x27, 0x68, 0x36, 0xb9, 0x72, 0xf9,
+	0xbc, 0x6d, 0xf2, 0xa5, 0x1e, 0x4a, 0x50, 0x0f, 0xc3, 0x57, 0xc4, 0x73, 0x58, 0x4a, 0x03, 0x65,
+	0x0c, 0xa9, 0x91, 0x18, 0x08, 0x5d, 0x11, 0x3e, 0x87, 0x73, 0xe2, 0x34, 0x99, 0x49, 0xcf, 0xcd,
+	0x01, 0xd9, 0x9b, 0xf8, 0x50, 0x28, 0x27, 0x9a, 0xac, 0x73, 0xa7, 0x19, 0x2f, 0x97, 0x79, 0x2e,
+	0xf4, 0x48, 0xc9, 0x0c, 0x9a, 0xf1, 0xc0, 0xd5, 0x89, 0x30, 0xeb, 0xf2, 0xbb, 0x8e, 0x34, 0xfe,
+	0xa0, 0x9c, 0x80, 0xcd, 0xc3, 0xbb, 0xf4, 0x27, 0x90, 0xbf, 0xaa, 0xbd, 0x30, 0xe4, 0x2c, 0xaf,
+	0xd9, 0x27, 0x95, 0xe7, 0x31, 0xe8, 0xac, 0xaa, 0xc1, 0x8c, 0x87, 0x67, 0xe8, 0x38, 0xeb, 0xad,
+	0xdf, 0x15, 0x77, 0x7e, 0xff, 0xdd, 0x61, 0x9f, 0xd5, 0xee, 0x8e, 0x61, 0x32, 0xcb, 0x3e, 0x79,
+	0x8b, 0x5e, 0xe2, 0xc9, 0xe6, 0xbb, 0x06, 0xf3, 0x76, 0x22, 0x3f, 0x6c, 0x3b, 0x0c, 0x77, 0x1a,
+	0x65, 0xe0, 0xed, 0x61, 0xb8, 0x47, 0x7e, 0x03, 0x60, 0x24, 0xd4, 0x69, 0xd4, 0x49, 0xe7, 0xe8,
+	0x67, 0x76, 0xe3, 0xa9, 0x98, 0x5e, 0xad, 0x52, 0x4e, 0x3d, 0x55, 0x14, 0x92, 0x35, 0xfc, 0x65,
+	0x80, 0xb0, 0x06, 0x1f, 0xec, 0x70, 0x95, 0xb5, 0x7e, 0xda, 0x48, 0x05, 0x87, 0x4a, 0x2e, 0x4b,
+	0xeb, 0x2d, 0xb5, 0xce, 0xa7, 0xc2, 0xad, 0x5f, 0x03, 0x46, 0x3e, 0xdf, 0xb0, 0x9b, 0x93, 0x58,
+	0xac, 0xa1, 0xdc, 0x2f, 0xf2, 0x81, 0xa0, 0xd2, 0x83, 0x0f, 0x04, 0x18, 0xf3, 0x52, 0xde, 0xc8,
+	0x34, 0x17, 0xe9, 0x94, 0xb7, 0x6a, 0x30, 0xe5, 0x2b, 0xc8, 0xef, 0x48, 0xca, 0xbf, 0x6d, 0x33,
+	0x74, 0x10, 0x1a, 0x5b, 0x6b, 0x83, 0x7a, 0x9d, 0x58, 0x7c, 0x89, 0xe4, 0xbd, 0x42, 0xb1, 0x92,
+	0xbd, 0xb6, 0x56, 0xc2, 0x5b, 0xca, 0xfe, 0x06, 0xca, 0x19, 0xbf, 0x66, 0xb7, 0xaa, 0xff, 0x51,
+	0x9f, 0xd3, 0x0f, 0x1a, 0x68, 0x76, 0x38, 0x83, 0xce, 0x7c, 0xfd, 0x91, 0x2b, 0xd3, 0x75, 0xeb,
+	0x23, 0x57, 0xae, 0x6e, 0x7a, 0xe4, 0x2a, 0x21, 0x6c, 0x39, 0xbb, 0x4d, 0xda, 0xb7, 0xde, 0xa9,
+	0x21, 0xcb, 0x08, 0xf2, 0xb6, 0x3e, 0xfb, 0x0b, 0x97, 0xee, 0x83, 0xb6, 0x94, 0x24, 0x0a, 0x77,
+	0xaf, 0x13, 0x8b, 0x3f, 0xc9, 0xac, 0x5a, 0x95, 0xd6, 0x90, 0x8d, 0x46, 0x61, 0xbd, 0xdf, 0x0d,
+	0xc6, 0xef, 0xa4, 0x67, 0x79, 0x17, 0x48, 0xbd, 0x93, 0x9e, 0xe1, 0xd6, 0xef, 0x4e, 0x3b, 0x60,
+	0xad, 0x3d, 0x7d, 0xfc, 0xeb, 0xc3, 0x75, 0x64, 0x40, 0xeb, 0x7e, 0x24, 0x07, 0xc5, 0xaf, 0xc1,
+	0x5c, 0x0e, 0xd6, 0x66, 0x90, 0x3f, 0xf9, 0x0e, 0xa8, 0x07, 0xe2, 0x8b, 0x1b, 0xb9, 0xf6, 0xf8,
+	0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x3f, 0xf9, 0x7a, 0x5b, 0x16, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -207,6 +208,8 @@ type TabletManagerClient interface {
 	SlaveWasPromoted(ctx context.Context, in *tabletmanagerdata.SlaveWasPromotedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveWasPromotedResponse, error)
 	// Deprecated
 	SlaveWasRestarted(ctx context.Context, in *tabletmanagerdata.SlaveWasRestartedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveWasRestartedResponse, error)
+	// Generic VExec request. Can be used for various purposes
+	VExec(ctx context.Context, in *tabletmanagerdata.VExecRequest, opts ...grpc.CallOption) (*tabletmanagerdata.VExecResponse, error)
 }
 
 type tabletManagerClient struct {
@@ -731,6 +734,15 @@ func (c *tabletManagerClient) SlaveWasRestarted(ctx context.Context, in *tabletm
 	return out, nil
 }
 
+func (c *tabletManagerClient) VExec(ctx context.Context, in *tabletmanagerdata.VExecRequest, opts ...grpc.CallOption) (*tabletmanagerdata.VExecResponse, error) {
+	out := new(tabletmanagerdata.VExecResponse)
+	err := c.cc.Invoke(ctx, "/tabletmanagerservice.TabletManager/VExec", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // TabletManagerServer is the server API for TabletManager service.
 type TabletManagerServer interface {
 	// Ping returns the input payload
@@ -826,6 +838,8 @@ type TabletManagerServer interface {
 	SlaveWasPromoted(context.Context, *tabletmanagerdata.SlaveWasPromotedRequest) (*tabletmanagerdata.SlaveWasPromotedResponse, error)
 	// Deprecated
 	SlaveWasRestarted(context.Context, *tabletmanagerdata.SlaveWasRestartedRequest) (*tabletmanagerdata.SlaveWasRestartedResponse, error)
+	// Generic VExec request. Can be used for various purposes
+	VExec(context.Context, *tabletmanagerdata.VExecRequest) (*tabletmanagerdata.VExecResponse, error)
 }
 
 // UnimplementedTabletManagerServer can be embedded to have forward compatible implementations.
@@ -988,6 +1002,9 @@ func (*UnimplementedTabletManagerServer) SlaveWasPromoted(ctx context.Context, r
 func (*UnimplementedTabletManagerServer) SlaveWasRestarted(ctx context.Context, req *tabletmanagerdata.SlaveWasRestartedRequest) (*tabletmanagerdata.SlaveWasRestartedResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SlaveWasRestarted not implemented")
 }
+func (*UnimplementedTabletManagerServer) VExec(ctx context.Context, req *tabletmanagerdata.VExecRequest) (*tabletmanagerdata.VExecResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method VExec not implemented")
+}
 
 func RegisterTabletManagerServer(s *grpc.Server, srv TabletManagerServer) {
 	s.RegisterService(&_TabletManager_serviceDesc, srv)
@@ -1935,6 +1952,24 @@ func _TabletManager_SlaveWasRestarted_Handler(srv interface{}, ctx context.Conte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _TabletManager_VExec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(tabletmanagerdata.VExecRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TabletManagerServer).VExec(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/tabletmanagerservice.TabletManager/VExec",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TabletManagerServer).VExec(ctx, req.(*tabletmanagerdata.VExecRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _TabletManager_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "tabletmanagerservice.TabletManager",
 	HandlerType: (*TabletManagerServer)(nil),
@@ -2139,6 +2174,10 @@ var _TabletManager_serviceDesc = grpc.ServiceDesc{
 			MethodName: "SlaveWasRestarted",
 			Handler:    _TabletManager_SlaveWasRestarted_Handler,
 		},
+		{
+			MethodName: "VExec",
+			Handler:    _TabletManager_VExec_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
diff --git a/go/vt/vtcombo/tablet_map.go b/go/vt/vtcombo/tablet_map.go
index af4a2e2ec02..ec7dc73f7f0 100644
--- a/go/vt/vtcombo/tablet_map.go
+++ b/go/vt/vtcombo/tablet_map.go
@@ -699,6 +699,10 @@ func (itmc *internalTabletManagerClient) GetSlaves(ctx context.Context, tablet *
 	return nil, fmt.Errorf("not implemented in vtcombo")
 }
 
+func (itmc *internalTabletManagerClient) VExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error) {
+	return nil, fmt.Errorf("not implemented in vtcombo")
+}
+
 func (itmc *internalTabletManagerClient) VReplicationExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error) {
 	return nil, fmt.Errorf("not implemented in vtcombo")
 }
diff --git a/go/vt/vttablet/faketmclient/fake_client.go b/go/vt/vttablet/faketmclient/fake_client.go
index 25500ac2775..0987c51b2ec 100644
--- a/go/vt/vttablet/faketmclient/fake_client.go
+++ b/go/vt/vttablet/faketmclient/fake_client.go
@@ -231,6 +231,15 @@ func (client *FakeTabletManagerClient) WaitForPosition(ctx context.Context, tabl
 	return nil
 }
 
+func (c *FakeTabletManagerClient) VExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error) {
+	// This result satisfies a generic VExec command
+	result := sqltypes.MakeTestResult(
+		sqltypes.MakeTestFields("id", "int"),
+		"complete",
+	)
+	return sqltypes.ResultToProto3(result), nil
+}
+
 // VReplicationExec is part of the tmclient.TabletManagerClient interface.
 func (client *FakeTabletManagerClient) VReplicationExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error) {
 	// This result satisfies 'select pos from _vt.vreplication...' called from split clone unit tests in go/vt/worker.
diff --git a/go/vt/vttablet/grpctmclient/client.go b/go/vt/vttablet/grpctmclient/client.go
index 48be10a8b9d..c4e952d22d9 100644
--- a/go/vt/vttablet/grpctmclient/client.go
+++ b/go/vt/vttablet/grpctmclient/client.go
@@ -574,6 +574,19 @@ func (client *Client) GetReplicas(ctx context.Context, tablet *topodatapb.Tablet
 	return response.Addrs, nil
 }
 
+func (client *Client) VExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error) {
+	cc, c, err := client.dial(tablet)
+	if err != nil {
+		return nil, err
+	}
+	defer cc.Close()
+	response, err := c.VExec(ctx, &tabletmanagerdatapb.VExecRequest{Query: query})
+	if err != nil {
+		return nil, err
+	}
+	return response.Result, nil
+}
+
 // VReplicationExec is part of the tmclient.TabletManagerClient interface.
 func (client *Client) VReplicationExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error) {
 	cc, c, err := client.dial(tablet)
diff --git a/go/vt/vttablet/grpctmserver/server.go b/go/vt/vttablet/grpctmserver/server.go
index ddab182cfc8..f66d6bac410 100644
--- a/go/vt/vttablet/grpctmserver/server.go
+++ b/go/vt/vttablet/grpctmserver/server.go
@@ -317,6 +317,14 @@ func (s *server) GetReplicas(ctx context.Context, request *tabletmanagerdatapb.G
 	return response, err
 }
 
+func (s *server) VExec(ctx context.Context, request *tabletmanagerdatapb.VExecRequest) (response *tabletmanagerdatapb.VExecResponse, err error) {
+	defer s.tm.HandleRPCPanic(ctx, "VExec", request, response, true /*verbose*/, &err)
+	ctx = callinfo.GRPCCallInfo(ctx)
+	response = &tabletmanagerdatapb.VExecResponse{}
+	response.Result, err = s.tm.VExec(ctx, request.Query)
+	return response, err
+}
+
 func (s *server) VReplicationExec(ctx context.Context, request *tabletmanagerdatapb.VReplicationExecRequest) (response *tabletmanagerdatapb.VReplicationExecResponse, err error) {
 	defer s.tm.HandleRPCPanic(ctx, "VReplicationExec", request, response, true /*verbose*/, &err)
 	ctx = callinfo.GRPCCallInfo(ctx)
diff --git a/go/vt/vttablet/onlineddl/executor.go b/go/vt/vttablet/onlineddl/executor.go
index ec62cb2d460..a7e4a7ebe24 100644
--- a/go/vt/vttablet/onlineddl/executor.go
+++ b/go/vt/vttablet/onlineddl/executor.go
@@ -851,3 +851,7 @@ func (e *Executor) OnSchemaMigrationStatus(ctx context.Context, uuidParam, statu
 
 	return nil
 }
+
+func (e *Executor) VExec(ctx context.Context, query string, stmt sqlparser.Statement) (*querypb.QueryResult, error) {
+	return nil, nil
+}
diff --git a/go/vt/vttablet/onlineddl/schema.go b/go/vt/vttablet/onlineddl/schema.go
index f8dfd0bb369..c8d2efb921c 100644
--- a/go/vt/vttablet/onlineddl/schema.go
+++ b/go/vt/vttablet/onlineddl/schema.go
@@ -23,6 +23,7 @@ import (
 )
 
 const (
+	SchemaMigrationsTableName      = "schema_migrations"
 	sqlCreateSidecarDB             = "create database if not exists %s"
 	sqlCreateSchemaMigrationsTable = `CREATE TABLE IF NOT EXISTS %s.schema_migrations (
 		id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
diff --git a/go/vt/vttablet/tabletmanager/rpc_agent.go b/go/vt/vttablet/tabletmanager/rpc_agent.go
index 6e50d7510b4..b1bbb8aff5d 100644
--- a/go/vt/vttablet/tabletmanager/rpc_agent.go
+++ b/go/vt/vttablet/tabletmanager/rpc_agent.go
@@ -114,6 +114,9 @@ type RPCTM interface {
 
 	WaitForPosition(ctx context.Context, pos string) error
 
+	// VExec generic API
+	VExec(ctx context.Context, query string) (*querypb.QueryResult, error)
+
 	// VReplication API
 	VReplicationExec(ctx context.Context, query string) (*querypb.QueryResult, error)
 	VReplicationWaitForPos(ctx context.Context, id int, pos string) error
diff --git a/go/vt/vttablet/tabletmanager/rpc_vexec.go b/go/vt/vttablet/tabletmanager/rpc_vexec.go
new file mode 100644
index 00000000000..91b2f1a73c3
--- /dev/null
+++ b/go/vt/vttablet/tabletmanager/rpc_vexec.go
@@ -0,0 +1,59 @@
+/*
+Copyright 2019 The Vitess Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package tabletmanager
+
+import (
+	"fmt"
+
+	querypb "vitess.io/vitess/go/vt/proto/query"
+	"vitess.io/vitess/go/vt/sqlparser"
+	"vitess.io/vitess/go/vt/vttablet/onlineddl"
+
+	"golang.org/x/net/context"
+)
+
+func (tm *TabletManager) extractTableName(stmt sqlparser.Statement) (string, error) {
+	switch stmt := stmt.(type) {
+	case *sqlparser.Update:
+		return sqlparser.String(stmt.TableExprs), nil
+	case *sqlparser.Delete:
+		return sqlparser.String(stmt.TableExprs), nil
+	case *sqlparser.Select:
+		return sqlparser.String(stmt.From), nil
+	}
+	return "", fmt.Errorf("query not supported by vexec: %+v", sqlparser.String(stmt))
+}
+
+// VExec executes a generic VExec command.
+func (tm *TabletManager) VExec(ctx context.Context, query string) (*querypb.QueryResult, error) {
+	stmt, err := sqlparser.Parse(query)
+	if err != nil {
+		return nil, err
+	}
+	tableName, err := tm.extractTableName(stmt)
+	if err != nil {
+		return nil, err
+	}
+	// TODO(shlomi) do something here!!!
+	fmt.Printf("======= VExec query: %x, table: %s \n", query, tableName)
+	switch tableName {
+	case onlineddl.SchemaMigrationsTableName:
+		return tm.QueryServiceControl.OnlineDDLExecutor().VExec(ctx, query, stmt)
+	default:
+		return nil, fmt.Errorf("table not supported by vexec: %v", tableName)
+	}
+}
diff --git a/go/vt/vttablet/tabletserver/controller.go b/go/vt/vttablet/tabletserver/controller.go
index 89547e791e2..9a4e49e5393 100644
--- a/go/vt/vttablet/tabletserver/controller.go
+++ b/go/vt/vttablet/tabletserver/controller.go
@@ -22,6 +22,7 @@ import (
 	"vitess.io/vitess/go/vt/dbconfigs"
 	"vitess.io/vitess/go/vt/mysqlctl"
 	"vitess.io/vitess/go/vt/topo"
+	"vitess.io/vitess/go/vt/vttablet/onlineddl"
 	"vitess.io/vitess/go/vt/vttablet/queryservice"
 	"vitess.io/vitess/go/vt/vttablet/tabletserver/rules"
 	"vitess.io/vitess/go/vt/vttablet/tabletserver/schema"
@@ -81,6 +82,9 @@ type Controller interface {
 	// QueryService returns the QueryService object used by this Controller
 	QueryService() queryservice.QueryService
 
+	// OnlineDDLExecutor the online DDL executor used by this Controller
+	OnlineDDLExecutor() *onlineddl.Executor
+
 	// SchemaEngine returns the SchemaEngine object used by this Controller
 	SchemaEngine() *schema.Engine
 
diff --git a/go/vt/vttablet/tabletserver/tabletserver.go b/go/vt/vttablet/tabletserver/tabletserver.go
index fefc869ac94..87988178f92 100644
--- a/go/vt/vttablet/tabletserver/tabletserver.go
+++ b/go/vt/vttablet/tabletserver/tabletserver.go
@@ -375,6 +375,11 @@ func (tsv *TabletServer) QueryService() queryservice.QueryService {
 	return tsv
 }
 
+// OnlineDDLExecutor returns the onlineddl.Executor part of TabletServer.
+func (tsv *TabletServer) OnlineDDLExecutor() *onlineddl.Executor {
+	return tsv.onlineDDLExecutor
+}
+
 // SchemaEngine returns the SchemaEngine part of TabletServer.
 func (tsv *TabletServer) SchemaEngine() *schema.Engine {
 	return tsv.se
diff --git a/go/vt/vttablet/tabletservermock/controller.go b/go/vt/vttablet/tabletservermock/controller.go
index 0c06672bdc3..277238ba727 100644
--- a/go/vt/vttablet/tabletservermock/controller.go
+++ b/go/vt/vttablet/tabletservermock/controller.go
@@ -28,6 +28,7 @@ import (
 	"vitess.io/vitess/go/vt/mysqlctl"
 	"vitess.io/vitess/go/vt/servenv"
 	"vitess.io/vitess/go/vt/topo"
+	"vitess.io/vitess/go/vt/vttablet/onlineddl"
 	"vitess.io/vitess/go/vt/vttablet/queryservice"
 	"vitess.io/vitess/go/vt/vttablet/tabletserver/rules"
 	"vitess.io/vitess/go/vt/vttablet/tabletserver/schema"
@@ -174,6 +175,11 @@ func (tqsc *Controller) ReloadSchema(ctx context.Context) error {
 	return nil
 }
 
+// OnlineDDLExecutor is part of the tabletserver.Controller interface
+func (tqsc *Controller) OnlineDDLExecutor() *onlineddl.Executor {
+	return nil
+}
+
 //ClearQueryPlanCache is part of the tabletserver.Controller interface
 func (tqsc *Controller) ClearQueryPlanCache() {
 }
diff --git a/go/vt/vttablet/tmclient/rpc_client_api.go b/go/vt/vttablet/tmclient/rpc_client_api.go
index 85206bf0b66..eeab0b24edc 100644
--- a/go/vt/vttablet/tmclient/rpc_client_api.go
+++ b/go/vt/vttablet/tmclient/rpc_client_api.go
@@ -156,6 +156,9 @@ type TabletManagerClient interface {
 	// WaitForPosition waits for the position to be reached
 	WaitForPosition(ctx context.Context, tablet *topodatapb.Tablet, pos string) error
 
+	// VExec executes a generic VExec command
+	VExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error)
+
 	// VReplicationExec executes a VReplication command
 	VReplicationExec(ctx context.Context, tablet *topodatapb.Tablet, query string) (*querypb.QueryResult, error)
 	VReplicationWaitForPos(ctx context.Context, tablet *topodatapb.Tablet, id int, pos string) error
diff --git a/go/vt/vttablet/tmrpctest/test_tm_rpc.go b/go/vt/vttablet/tmrpctest/test_tm_rpc.go
index babb5ec25ac..6b448e1c983 100644
--- a/go/vt/vttablet/tmrpctest/test_tm_rpc.go
+++ b/go/vt/vttablet/tmrpctest/test_tm_rpc.go
@@ -960,6 +960,14 @@ func tmRPCTestGetReplicasPanic(ctx context.Context, t *testing.T, client tmclien
 	expectHandleRPCPanic(t, "GetReplicas", false /*verbose*/, err)
 }
 
+func (fra *fakeRPCTM) VExec(ctx context.Context, query string) (*querypb.QueryResult, error) {
+	if fra.panics {
+		panic(fmt.Errorf("test-triggered panic"))
+	}
+	compare(fra.t, "VExec query", query, "query")
+	return testExecuteFetchResult, nil
+}
+
 var testVRQuery = "query"
 
 func (fra *fakeRPCTM) VReplicationExec(ctx context.Context, query string) (*querypb.QueryResult, error) {
diff --git a/go/vt/wrangler/tablet.go b/go/vt/wrangler/tablet.go
index 11f210c75a5..dfb5b759d7e 100644
--- a/go/vt/wrangler/tablet.go
+++ b/go/vt/wrangler/tablet.go
@@ -209,6 +209,15 @@ func (wr *Wrangler) VReplicationExec(ctx context.Context, tabletAlias *topodatap
 	return wr.tmc.VReplicationExec(ctx, ti.Tablet, query)
 }
 
+// VReplicationExec executes a query remotely using the DBA pool
+func (wr *Wrangler) GenericVExec(ctx context.Context, tabletAlias *topodatapb.TabletAlias, query string) (*querypb.QueryResult, error) {
+	ti, err := wr.ts.GetTablet(ctx, tabletAlias)
+	if err != nil {
+		return nil, err
+	}
+	return wr.tmc.VExec(ctx, ti.Tablet, query)
+}
+
 // isMasterTablet is a shortcut way to determine whether the current tablet
 // is a master before we allow its tablet record to be deleted. The canonical
 // way to determine the only true master in a shard is to list all the tablets
diff --git a/go/vt/wrangler/vexec.go b/go/vt/wrangler/vexec.go
index f60415f0705..9074f5bea2a 100644
--- a/go/vt/wrangler/vexec.go
+++ b/go/vt/wrangler/vexec.go
@@ -30,7 +30,6 @@ import (
 	topodatapb "vitess.io/vitess/go/vt/proto/topodata"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/olekukonko/tablewriter"
 	"vitess.io/vitess/go/sqltypes"
 	"vitess.io/vitess/go/vt/concurrency"
 	binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata"
@@ -41,7 +40,8 @@ import (
 )
 
 const (
-	vreplicationTableName = "_vt.vreplication"
+	vreplicationTableName     = "_vt.vreplication"
+	schemaMigrationsTableName = "_vt.schema_migrations"
 )
 
 type vexec struct {
@@ -66,7 +66,7 @@ func newVExec(ctx context.Context, workflow, keyspace, query string, wr *Wrangle
 	}
 }
 
-// VExec executes queries on _vt.vreplication on all masters in the target keyspace of the workflow
+// VExec executes queries on a table on all masters in the target keyspace of the workflow
 func (wr *Wrangler) VExec(ctx context.Context, workflow, keyspace, query string, dryRun bool) (map[*topo.TabletInfo]*sqltypes.Result, error) {
 	results, err := wr.runVexec(ctx, workflow, keyspace, query, dryRun)
 	retResults := make(map[*topo.TabletInfo]*sqltypes.Result)
@@ -86,40 +86,17 @@ func (wr *Wrangler) runVexec(ctx context.Context, workflow, keyspace, query stri
 	}
 	fullQuery := vx.plan.parsedQuery.Query
 	if dryRun {
-		return nil, vx.outputDryRunInfo(wr)
+		return nil, vx.outputDryRunInfo()
 	}
 	return vx.exec(fullQuery)
 }
 
-func (vx *vexec) outputDryRunInfo(wr *Wrangler) error {
-	rsr, err := vx.wr.getStreams(vx.ctx, vx.workflow, vx.keyspace)
-	if err != nil {
-		return err
-	}
-
-	wr.Logger().Printf("Query: %s\nwill be run on the following streams in keyspace %s for workflow %s:\n\n",
-		vx.plan.parsedQuery.Query, vx.keyspace, vx.workflow)
-	tableString := &strings.Builder{}
-	table := tablewriter.NewWriter(tableString)
-	table.SetHeader([]string{"Tablet", "ID", "BinLogSource", "State", "DBName", "Current GTID", "MaxReplicationLag"})
-	for _, master := range vx.masters {
-		key := fmt.Sprintf("%s/%s", master.Shard, master.AliasString())
-		for _, stream := range rsr.ShardStatuses[key].MasterReplicationStatuses {
-			table.Append([]string{key, fmt.Sprintf("%d", stream.ID), stream.Bls.String(), stream.State, stream.DBName, stream.Pos, fmt.Sprintf("%d", stream.MaxReplicationLag)})
-		}
-	}
-	table.SetAutoMergeCellsByColumnIndex([]int{0})
-	table.SetRowLine(true)
-	table.Render()
-	wr.Logger().Printf(tableString.String())
-	wr.Logger().Printf("\n\n")
-
-	return nil
+func (vx *vexec) outputDryRunInfo() error {
+	return vx.plan.planner.dryRun()
 }
 
 func (vx *vexec) exec(query string) (map[*topo.TabletInfo]*querypb.QueryResult, error) {
 	var wg sync.WaitGroup
-	workflow := vx.workflow
 	allErrors := &concurrency.AllErrorRecorder{}
 	results := make(map[*topo.TabletInfo]*querypb.QueryResult)
 	var mu sync.Mutex
@@ -130,14 +107,12 @@ func (vx *vexec) exec(query string) (map[*topo.TabletInfo]*querypb.QueryResult,
 		go func(ctx context.Context, master *topo.TabletInfo) {
 			defer wg.Done()
 			log.Infof("Running %s on %s\n", query, master.AliasString())
-			qr, err := vx.wr.VReplicationExec(ctx, master.Alias, query)
+			qr, err := vx.plan.planner.exec(ctx, master.Alias, query)
 			log.Infof("Result is %s: %v", master.AliasString(), qr)
 			if err != nil {
 				allErrors.RecordError(err)
 			} else {
-				if qr.RowsAffected == 0 {
-					log.Infof("no matching streams found for workflow %s, tablet %s, query %s", workflow, master.Alias, query)
-				} else {
+				if qr.RowsAffected > 0 {
 					mu.Lock()
 					results[master] = qr
 					mu.Unlock()
@@ -240,7 +215,7 @@ func (wr *Wrangler) execWorkflowAction(ctx context.Context, workflow, keyspace,
 	}
 	fullQuery := vx.plan.parsedQuery.Query
 	if dryRun {
-		return nil, vx.outputDryRunInfo(wr)
+		return nil, vx.outputDryRunInfo()
 	}
 	results, err := vx.exec(fullQuery)
 	return results, err
diff --git a/go/vt/wrangler/vexec_plan.go b/go/vt/wrangler/vexec_plan.go
index 07634322223..f1d6db811b8 100644
--- a/go/vt/wrangler/vexec_plan.go
+++ b/go/vt/wrangler/vexec_plan.go
@@ -17,16 +17,98 @@ limitations under the License.
 package wrangler
 
 import (
+	"context"
 	"fmt"
+	"strings"
 
+	"vitess.io/vitess/go/vt/log"
+	querypb "vitess.io/vitess/go/vt/proto/query"
+	topodatapb "vitess.io/vitess/go/vt/proto/topodata"
 	"vitess.io/vitess/go/vt/sqlparser"
+
+	"github.com/olekukonko/tablewriter"
 )
 
 type vexecPlan struct {
 	query       string
 	opcode      int
 	parsedQuery *sqlparser.ParsedQuery
+	planner     vexecPlanner
+}
+
+type vexecPlanner interface {
+	dbNameColumn() (colName string)
+	workflowColumn() (colName string)
+	immutableColumnNames() (colNames []string)
+	updatableColumnNames() (colNames []string)
+	exec(ctx context.Context, masterAlias *topodatapb.TabletAlias, query string) (*querypb.QueryResult, error)
+	dryRun() error
+}
+
+type vreplicationPlanner struct{ vx *vexec }
+
+func (p vreplicationPlanner) dbNameColumn() (colName string)            { return "db_name" }
+func (p vreplicationPlanner) workflowColumn() (colName string)          { return "workflow" }
+func (p vreplicationPlanner) immutableColumnNames() (colNames []string) { return []string{"id"} }
+func (p vreplicationPlanner) updatableColumnNames() (colNames []string) { return []string{} }
+func (p vreplicationPlanner) exec(ctx context.Context, masterAlias *topodatapb.TabletAlias, query string) (*querypb.QueryResult, error) {
+	qr, err := p.vx.wr.VReplicationExec(ctx, masterAlias, query)
+	if err != nil {
+		return nil, err
+	}
+	if qr.RowsAffected == 0 {
+		log.Infof("no matching streams found for workflow %s, tablet %s, query %s", p.vx.workflow, masterAlias, query)
+	}
+	return qr, nil
+}
+func (p vreplicationPlanner) dryRun() error {
+	rsr, err := p.vx.wr.getStreams(p.vx.ctx, p.vx.workflow, p.vx.keyspace)
+	if err != nil {
+		return err
+	}
+
+	p.vx.wr.Logger().Printf("Query: %s\nwill be run on the following streams in keyspace %s for workflow %s:\n\n",
+		p.vx.plan.parsedQuery.Query, p.vx.keyspace, p.vx.workflow)
+	tableString := &strings.Builder{}
+	table := tablewriter.NewWriter(tableString)
+	table.SetHeader([]string{"Tablet", "ID", "BinLogSource", "State", "DBName", "Current GTID", "MaxReplicationLag"})
+	for _, master := range p.vx.masters {
+		key := fmt.Sprintf("%s/%s", master.Shard, master.AliasString())
+		for _, stream := range rsr.ShardStatuses[key].MasterReplicationStatuses {
+			table.Append([]string{key, fmt.Sprintf("%d", stream.ID), stream.Bls.String(), stream.State, stream.DBName, stream.Pos, fmt.Sprintf("%d", stream.MaxReplicationLag)})
+		}
+	}
+	table.SetAutoMergeCellsByColumnIndex([]int{0})
+	table.SetRowLine(true)
+	table.Render()
+	p.vx.wr.Logger().Printf(tableString.String())
+	p.vx.wr.Logger().Printf("\n\n")
+
+	return nil
+}
+
+type schemaMigrationsPlanner struct{ vx *vexec }
+
+func (p schemaMigrationsPlanner) dbNameColumn() (colName string)            { return "mysql_schema" }
+func (p schemaMigrationsPlanner) workflowColumn() (colName string)          { return "migration_uuid" }
+func (p schemaMigrationsPlanner) immutableColumnNames() (colNames []string) { return []string{""} }
+func (p schemaMigrationsPlanner) updatableColumnNames() (colNames []string) {
+	return []string{"migration_status"}
+}
+func (p schemaMigrationsPlanner) exec(ctx context.Context, masterAlias *topodatapb.TabletAlias, query string) (*querypb.QueryResult, error) {
+	qr, err := p.vx.wr.GenericVExec(ctx, masterAlias, query)
+	if err != nil {
+		return nil, err
+	}
+	if qr.RowsAffected == 0 {
+		return nil, fmt.Errorf("\nno matching migrations found for workflow %s, tablet %s, query %s", p.vx.workflow, masterAlias, query)
+	}
+	return qr, nil
 }
+func (p schemaMigrationsPlanner) dryRun() error { return nil }
+
+var _ vexecPlanner = vreplicationPlanner{}
+var _ vexecPlanner = schemaMigrationsPlanner{}
 
 const (
 	updateQuery = iota
@@ -34,19 +116,47 @@ const (
 	selectQuery
 )
 
+func extractTableName(stmt sqlparser.Statement) (string, error) {
+	switch stmt := stmt.(type) {
+	case *sqlparser.Update:
+		return sqlparser.String(stmt.TableExprs), nil
+	case *sqlparser.Delete:
+		return sqlparser.String(stmt.TableExprs), nil
+	case *sqlparser.Select:
+		return sqlparser.String(stmt.From), nil
+	}
+	return "", fmt.Errorf("query not supported by vexec: %+v", sqlparser.String(stmt))
+}
+
 func (vx *vexec) buildVExecPlan() (*vexecPlan, error) {
 	stmt, err := sqlparser.Parse(vx.query)
 	if err != nil {
 		return nil, err
 	}
+
+	tableName, err := extractTableName(stmt)
+	if err != nil {
+		return nil, err
+	}
+
+	var planner vexecPlanner
+	switch tableName {
+	case schemaMigrationsTableName:
+		planner = schemaMigrationsPlanner{vx: vx}
+	case vreplicationTableName:
+		planner = vreplicationPlanner{vx: vx}
+	default:
+		return nil, fmt.Errorf("table not supported by vexec: %v", tableName)
+	}
+
 	var plan *vexecPlan
 	switch stmt := stmt.(type) {
 	case *sqlparser.Update:
-		plan, err = vx.buildUpdatePlan(stmt)
+		plan, err = vx.buildUpdatePlan(planner, stmt)
 	case *sqlparser.Delete:
-		plan, err = vx.buildDeletePlan(stmt)
+		plan, err = vx.buildDeletePlan(planner, stmt)
 	case *sqlparser.Select:
-		plan, err = vx.buildSelectPlan(stmt)
+		plan, err = vx.buildSelectPlan(planner, stmt)
 	default:
 		return nil, fmt.Errorf("query not supported by vexec: %s", sqlparser.String(stmt))
 	}
@@ -54,6 +164,7 @@ func (vx *vexec) buildVExecPlan() (*vexecPlan, error) {
 	if err != nil {
 		return nil, err
 	}
+	plan.planner = planner
 	plan.query = vx.query
 	vx.plan = plan
 	return plan, nil
@@ -89,20 +200,20 @@ func (vx *vexec) analyzeWhere(where *sqlparser.Where) []string {
 	return cols
 }
 
-func (vx *vexec) addDefaultWheres(where *sqlparser.Where) *sqlparser.Where {
+func (vx *vexec) addDefaultWheres(planner vexecPlanner, where *sqlparser.Where) *sqlparser.Where {
 	cols := vx.analyzeWhere(where)
 	var hasDBName, hasWorkflow bool
 	for _, col := range cols {
-		if col == "db_name" {
+		if col == planner.dbNameColumn() {
 			hasDBName = true
-		} else if col == "workflow" {
+		} else if col == planner.workflowColumn() {
 			hasWorkflow = true
 		}
 	}
 	newWhere := where
 	if !hasDBName {
 		expr := &sqlparser.ComparisonExpr{
-			Left:     &sqlparser.ColName{Name: sqlparser.NewColIdent("db_name")},
+			Left:     &sqlparser.ColName{Name: sqlparser.NewColIdent(planner.dbNameColumn())},
 			Operator: sqlparser.EqualStr,
 			Right:    sqlparser.NewStrLiteral([]byte(vx.masters[0].DbName())),
 		}
@@ -120,7 +231,7 @@ func (vx *vexec) addDefaultWheres(where *sqlparser.Where) *sqlparser.Where {
 	}
 	if !hasWorkflow && vx.workflow != "" {
 		expr := &sqlparser.ComparisonExpr{
-			Left:     &sqlparser.ColName{Name: sqlparser.NewColIdent("workflow")},
+			Left:     &sqlparser.ColName{Name: sqlparser.NewColIdent(planner.workflowColumn())},
 			Operator: sqlparser.EqualStr,
 			Right:    sqlparser.NewStrLiteral([]byte(vx.workflow)),
 		}
@@ -132,23 +243,33 @@ func (vx *vexec) addDefaultWheres(where *sqlparser.Where) *sqlparser.Where {
 	return newWhere
 }
 
-func (vx *vexec) buildUpdatePlan(upd *sqlparser.Update) (*vexecPlan, error) {
-	switch sqlparser.String(upd.TableExprs) {
-	case vreplicationTableName:
-		// no-op
-	default:
-		return nil, fmt.Errorf("vexec does not support: %v", sqlparser.String(upd.TableExprs))
-	}
+func (vx *vexec) buildUpdatePlan(planner vexecPlanner, upd *sqlparser.Update) (*vexecPlan, error) {
 	if upd.OrderBy != nil || upd.Limit != nil {
 		return nil, fmt.Errorf("unsupported construct: %v", sqlparser.String(upd))
 	}
 	for _, expr := range upd.Exprs {
-		if expr.Name.Name.EqualString("id") {
-			return nil, fmt.Errorf("id cannot be changed: %v", sqlparser.String(expr))
+		for _, immutableColName := range planner.immutableColumnNames() {
+			if expr.Name.Name.EqualString(immutableColName) {
+				return nil, fmt.Errorf("%s cannot be changed: %v", immutableColName, sqlparser.String(expr))
+			}
+		}
+	}
+	if updatableColumnNames := planner.updatableColumnNames(); len(updatableColumnNames) > 0 {
+		// if updatableColumnNames is non empty, then we must only accept changes to columns listed there
+		for _, expr := range upd.Exprs {
+			isUpdatable := false
+			for _, updatableColName := range updatableColumnNames {
+				if expr.Name.Name.EqualString(updatableColName) {
+					isUpdatable = true
+				}
+			}
+			if !isUpdatable {
+				return nil, fmt.Errorf("%+v cannot be changed: %v", expr.Name.Name, sqlparser.String(expr))
+			}
 		}
 	}
 
-	upd.Where = vx.addDefaultWheres(upd.Where)
+	upd.Where = vx.addDefaultWheres(planner, upd.Where)
 
 	buf := sqlparser.NewTrackedBuffer(nil)
 	buf.Myprintf("%v", upd)
@@ -159,13 +280,7 @@ func (vx *vexec) buildUpdatePlan(upd *sqlparser.Update) (*vexecPlan, error) {
 	}, nil
 }
 
-func (vx *vexec) buildDeletePlan(del *sqlparser.Delete) (*vexecPlan, error) {
-	switch sqlparser.String(del.TableExprs) {
-	case vreplicationTableName:
-		// no-op
-	default:
-		return nil, fmt.Errorf("invalid table name: %v", sqlparser.String(del.TableExprs))
-	}
+func (vx *vexec) buildDeletePlan(planner vexecPlanner, del *sqlparser.Delete) (*vexecPlan, error) {
 	if del.Targets != nil {
 		return nil, fmt.Errorf("unsupported construct: %v", sqlparser.String(del))
 	}
@@ -176,7 +291,7 @@ func (vx *vexec) buildDeletePlan(del *sqlparser.Delete) (*vexecPlan, error) {
 		return nil, fmt.Errorf("unsupported construct: %v", sqlparser.String(del))
 	}
 
-	del.Where = vx.addDefaultWheres(del.Where)
+	del.Where = vx.addDefaultWheres(planner, del.Where)
 
 	buf := sqlparser.NewTrackedBuffer(nil)
 	buf.Myprintf("%v", del)
@@ -187,14 +302,8 @@ func (vx *vexec) buildDeletePlan(del *sqlparser.Delete) (*vexecPlan, error) {
 	}, nil
 }
 
-func (vx *vexec) buildSelectPlan(sel *sqlparser.Select) (*vexecPlan, error) {
-	switch sqlparser.String(sel.From) {
-	case vreplicationTableName:
-		// no-op
-	default:
-		return nil, fmt.Errorf("invalid table name: %v", sqlparser.String(sel.From))
-	}
-	sel.Where = vx.addDefaultWheres(sel.Where)
+func (vx *vexec) buildSelectPlan(planner vexecPlanner, sel *sqlparser.Select) (*vexecPlan, error) {
+	sel.Where = vx.addDefaultWheres(planner, sel.Where)
 	buf := sqlparser.NewTrackedBuffer(nil)
 	buf.Myprintf("%v", sel)
 
diff --git a/go/vt/wrangler/vexec_test.go b/go/vt/wrangler/vexec_test.go
index f816498fdb5..51ae6f215f2 100644
--- a/go/vt/wrangler/vexec_test.go
+++ b/go/vt/wrangler/vexec_test.go
@@ -132,7 +132,7 @@ func TestVExec(t *testing.T) {
 		errorString: errorString,
 	})
 
-	errorString = "invalid table name"
+	errorString = "table not supported by vexec"
 	testCases = append(testCases, &TestCase{
 		name:        "delete invalid-other-table",
 		query:       "delete from _vt.copy_state",
@@ -360,7 +360,7 @@ func TestVExecValidations(t *testing.T) {
 		{
 			name:        "incorrect table",
 			query:       "select * from _vt.vreplication2",
-			errorString: "invalid table name: _vt.vreplication2",
+			errorString: "table not supported by vexec: _vt.vreplication2",
 		},
 		{
 			name:        "unsupported query",
diff --git a/proto/tabletmanagerdata.proto b/proto/tabletmanagerdata.proto
index b684e401713..bebb3dade89 100644
--- a/proto/tabletmanagerdata.proto
+++ b/proto/tabletmanagerdata.proto
@@ -536,3 +536,11 @@ message SlaveWasRestartedRequest {
 // Deprecated
 message SlaveWasRestartedResponse {
 }
+
+message VExecRequest {
+  string query = 1;
+}
+
+message VExecResponse {
+  query.QueryResult result = 1;
+}
diff --git a/proto/tabletmanagerservice.proto b/proto/tabletmanagerservice.proto
index d00b1dfd3bf..4fc66525f39 100644
--- a/proto/tabletmanagerservice.proto
+++ b/proto/tabletmanagerservice.proto
@@ -189,4 +189,7 @@ service TabletManager {
 
   // Deprecated
   rpc SlaveWasRestarted(tabletmanagerdata.SlaveWasRestartedRequest) returns (tabletmanagerdata.SlaveWasRestartedResponse) {};
+
+  // Generic VExec request. Can be used for various purposes
+  rpc VExec(tabletmanagerdata.VExecRequest) returns(tabletmanagerdata.VExecResponse) {};
 }