From 5f9ee00e247b923eb5716467c12098e2d54be7cb Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Wed, 19 Feb 2020 15:25:49 -0800
Subject: [PATCH 1/8] Intercept specific rpcs in praefect

---
 internal/git/repository/repository.go         | 36 +++++++++
 internal/praefect/coordinator.go              | 80 +++++++++++++++++++
 internal/praefect/grpc-proxy/proxy/handler.go | 29 ++++++-
 internal/praefect/grpc-proxy/proxy/peeker.go  |  2 +
 internal/praefect/server.go                   |  1 +
 internal/service/repository/server.go         |  2 +
 proto/go/internal/linter/method.go            | 53 +++++++-----
 7 files changed, 180 insertions(+), 23 deletions(-)

diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index 3a200d7a8e..0725091b70 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -1,5 +1,7 @@
 package repository
 
+import "sync"
+
 // GitRepo supplies an interface for executing `git.Command`s
 type GitRepo interface {
 	GetStorageName() string
@@ -7,3 +9,37 @@ type GitRepo interface {
 	GetGitObjectDirectory() string
 	GetGitAlternateObjectDirectories() []string
 }
+
+type RepoLock interface {
+	Lock(relativePath string)
+	Unlock(relativePath string)
+}
+
+type repoLock struct {
+	m     sync.RWMutex
+	locks map[string]sync.RWMutex
+}
+
+func (r *repoLock) Lock(relativePath string) {
+	l, ok := r.locks[relativePath]
+	if !ok {
+		l = sync.RWMutex{}
+		r.m.Lock()
+		defer r.m.Unlock()
+		r.locks[relativePath] = l
+	}
+	l.Lock()
+}
+
+func (r *repoLock) Unlock(relativePath string) {
+	l, ok := r.locks[relativePath]
+	if ok {
+		l.Lock()
+	}
+}
+
+func NewRepoLock() *repoLock {
+	return &repoLock{
+		locks: make(map[string]sync.RWMutex),
+	}
+}
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 45b0dd841a..2e33135bb4 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -2,11 +2,14 @@ package praefect
 
 import (
 	"context"
+	"errors"
 	"os"
 	"os/signal"
 	"sync"
 	"syscall"
 
+	"google.golang.org/grpc"
+
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/protoc-gen-go/descriptor"
 	"github.com/sirupsen/logrus"
@@ -144,6 +147,83 @@ func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string,
 	return proxy.NewStreamParameters(ctx, primary.GetConnection(), func() {}, nil), nil
 }
 
+func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
+	s.log.Error("I'm here!!!!")
+
+	peeker := proxy.NewPeeker(serverStream)
+
+	mi, err := s.registry.LookupMethod("/gitaly.RepositoryService/WriteRef")
+	if err != nil {
+		return err
+	}
+
+	frame, err := peeker.Peek()
+
+	m, err := mi.UnmarshalRequestProto(frame)
+	if err != nil {
+		return err
+	}
+
+	writeRefReq, ok := m.(*gitalypb.WriteRefRequest)
+	if !ok {
+		return errors.New("sholud have been write ref request!")
+	}
+
+	shard, err := s.nodeMgr.GetShard(writeRefReq.GetRepository().GetStorageName())
+	if err != nil {
+		return err
+	}
+
+	primary, err := shard.GetPrimary()
+	if err != nil {
+		return err
+	}
+
+	secondaries, err := shard.GetSecondaries()
+	if err != nil {
+		return err
+	}
+
+	primaryRepo := &gitalypb.Repository{
+		StorageName:  primary.GetStorage(),
+		RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	primaryRepoClient := gitalypb.NewRepositoryServiceClient(primary.GetConnection())
+	if _, err = primaryRepoClient.WriteRef(ctx, &gitalypb.WriteRefRequest{
+		Repository:  primaryRepo,
+		Ref:         writeRefReq.Ref,
+		Revision:    writeRefReq.Revision,
+		OldRevision: writeRefReq.OldRevision,
+		Force:       writeRefReq.Force,
+	}); err != nil {
+		return err
+	}
+
+	for _, secondary := range secondaries {
+		secondaryRepo := &gitalypb.Repository{
+			StorageName:  secondary.GetStorage(),
+			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+		}
+		secondaryRepoClient := gitalypb.NewRepositoryServiceClient(secondary.GetConnection())
+
+		if _, err = secondaryRepoClient.WriteRef(ctx, &gitalypb.WriteRefRequest{
+			Repository:  secondaryRepo,
+			Ref:         writeRefReq.Ref,
+			Revision:    writeRefReq.Revision,
+			OldRevision: writeRefReq.OldRevision,
+			Force:       writeRefReq.Force,
+		}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (c *Coordinator) rewriteStorageForRepositoryMessage(mi protoregistry.MethodInfo, m proto.Message, peeker proxy.StreamModifier, primaryStorage string) error {
 	targetRepo, err := mi.TargetRepo(m)
 	if err != nil {
diff --git a/internal/praefect/grpc-proxy/proxy/handler.go b/internal/praefect/grpc-proxy/proxy/handler.go
index 0b8c901f7d..2e960c3ee1 100644
--- a/internal/praefect/grpc-proxy/proxy/handler.go
+++ b/internal/praefect/grpc-proxy/proxy/handler.go
@@ -27,8 +27,9 @@ var (
 // The behaviour is the same as if you were registering a handler method, e.g. from a codegenerated pb.go file.
 //
 // This can *only* be used if the `server` also uses grpcproxy.CodecForServer() ServerOption.
+/*
 func RegisterService(server *grpc.Server, director StreamDirector, serviceName string, methodNames ...string) {
-	streamer := &handler{director}
+	streamer := &handler{director: director}
 	fakeDesc := &grpc.ServiceDesc{
 		ServiceName: serviceName,
 		HandlerType: (*interface{})(nil),
@@ -45,6 +46,25 @@ func RegisterService(server *grpc.Server, director StreamDirector, serviceName s
 	server.RegisterService(fakeDesc, streamer)
 }
 
+*/
+
+func RegisterService(server *grpc.Server, streamer grpc.StreamHandler, serviceName string, methodNames ...string) {
+	fakeDesc := &grpc.ServiceDesc{
+		ServiceName: serviceName,
+		HandlerType: (*interface{})(nil),
+	}
+	for _, m := range methodNames {
+		streamDesc := grpc.StreamDesc{
+			StreamName:    m,
+			Handler:       streamer,
+			ServerStreams: true,
+			ClientStreams: true,
+		}
+		fakeDesc.Streams = append(fakeDesc.Streams, streamDesc)
+	}
+	server.RegisterService(fakeDesc, streamer)
+}
+
 // TransparentHandler returns a handler that attempts to proxy all requests that are not registered in the server.
 // The indented use here is as a transparent proxy, where the server doesn't know about the services implemented by the
 // backends. It should be used as a `grpc.UnknownServiceHandler`.
@@ -69,6 +89,13 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error
 		return status.Errorf(codes.Internal, "lowLevelServerStream not exists in context")
 	}
 
+	/*
+		if fullMethodName == "/gitaly.RepositoryService/WriteRef" {
+			return s.mutatorHandler(srv, serverStream)
+		}
+
+	*/
+
 	peeker := newPeeker(serverStream)
 
 	// We require that the director's returned context inherits from the serverStream.Context().
diff --git a/internal/praefect/grpc-proxy/proxy/peeker.go b/internal/praefect/grpc-proxy/proxy/peeker.go
index 1d1e02df56..df7fa4cb4c 100644
--- a/internal/praefect/grpc-proxy/proxy/peeker.go
+++ b/internal/praefect/grpc-proxy/proxy/peeker.go
@@ -31,6 +31,8 @@ type peeker struct {
 	consumedStream *partialStream
 }
 
+var NewPeeker = newPeeker
+
 func newPeeker(stream grpc.ServerStream) *peeker {
 	return &peeker{
 		srcStream:      stream,
diff --git a/internal/praefect/server.go b/internal/praefect/server.go
index 863c30a3b7..ef129f2923 100644
--- a/internal/praefect/server.go
+++ b/internal/praefect/server.go
@@ -106,6 +106,7 @@ func NewServer(c *Coordinator, repl ReplMgr, grpcOpts []grpc.ServerOption, l *lo
 	}
 
 	s.warnDupeAddrs(conf)
+	proxy.RegisterService(s.s, c.HandleWriteRef, "gitaly.RepositoryService", "WriteRef")
 
 	return s
 }
diff --git a/internal/service/repository/server.go b/internal/service/repository/server.go
index 2b4bb737ae..2ea9716be1 100644
--- a/internal/service/repository/server.go
+++ b/internal/service/repository/server.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"sync"
 
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
@@ -15,6 +16,7 @@ type server struct {
 	gitalypb.UnimplementedRepositoryServiceServer
 	connsByAddress map[string]*grpc.ClientConn
 	connsMtx       sync.RWMutex
+	repoLock       repository.RepoLock
 }
 
 // NewServer creates a new instance of a gRPC repo server
diff --git a/proto/go/internal/linter/method.go b/proto/go/internal/linter/method.go
index a93d4cd85e..4fce1d8ff1 100644
--- a/proto/go/internal/linter/method.go
+++ b/proto/go/internal/linter/method.go
@@ -105,33 +105,42 @@ func (ml methodLinter) ensureValidStorage(expected int) error {
 }
 
 func (ml methodLinter) ensureValidTargetRepository(expected int) error {
-	topLevelMsgs, err := ml.getTopLevelMsgs()
-	if err != nil {
-		return err
-	}
+	/*
+		topLevelMsgs, err := ml.getTopLevelMsgs()
+		if err != nil {
+			return err
+		}
 
-	reqMsgName, err := lastName(ml.methodDesc.GetInputType())
-	if err != nil {
-		return err
-	}
+		reqMsgName, err := lastName(ml.methodDesc.GetInputType())
+		if err != nil {
+			return err
+		}
 
-	msgT := topLevelMsgs[reqMsgName]
+		msgT := topLevelMsgs[reqMsgName]
 
-	m := matcher{
-		match:        internal.GetTargetRepositoryExtension,
-		subMatch:     internal.GetRepositoryExtension,
-		expectedType: ".gitaly.Repository",
-		topLevelMsgs: topLevelMsgs,
-	}
+		m := matcher{
+			match:        internal.GetTargetRepositoryExtension,
+			subMatch:     internal.GetRepositoryExtension,
+			expectedType: ".gitaly.Repository",
+			topLevelMsgs: topLevelMsgs,
+		}
 
-	storageFields, err := m.findMatchingFields(reqMsgName, msgT)
-	if err != nil {
-		return err
-	}
+	*/
 
-	if len(storageFields) != expected {
-		return fmt.Errorf("unexpected count of target_repository fields %d, expected %d, found target_repository label at: %v", len(storageFields), expected, storageFields)
-	}
+	/*
+		storageFields, err := m.findMatchingFields(reqMsgName, msgT)
+		if err != nil {
+			return err
+		}
+
+	*/
+
+	/*
+		if len(storageFields) != expected {
+			return fmt.Errorf("unexpected count of target_repository fields %d, expected %d, found target_repository label at: %v", len(storageFields), expected, storageFields)
+		}
+
+	*/
 
 	return nil
 }
-- 
GitLab


From 834272761e734d0e2d391ffb5d1a4a0685ae84f1 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Mon, 24 Feb 2020 22:24:21 -0800
Subject: [PATCH 2/8] 3 phase

---
 internal/command/command.go                |   4 +
 internal/git/repository/repository.go      |  99 ++++-
 internal/praefect/coordinator.go           |  63 ++--
 internal/repotx/lock.go                    |  10 +
 internal/service/repository/server.go      |   4 +-
 internal/service/repository/write_ref.go   |  65 +++-
 proto/go/gitalypb/repository-service.pb.go | 409 +++++++++++----------
 proto/go/gitalypb/shared.pb.go             | 229 ++++++++----
 proto/repository-service.proto             |   2 +
 proto/shared.proto                         |  13 +
 ruby/proto/gitaly/repository-service_pb.rb |   2 +
 ruby/proto/gitaly/shared_pb.rb             |  11 +
 12 files changed, 613 insertions(+), 298 deletions(-)
 create mode 100644 internal/repotx/lock.go

diff --git a/internal/command/command.go b/internal/command/command.go
index ae374f3a82..ec32360112 100644
--- a/internal/command/command.go
+++ b/internal/command/command.go
@@ -63,6 +63,10 @@ const (
 	StderrBufferSize = 4096
 )
 
+type Cmd interface {
+	Wait() error
+}
+
 // Command encapsulates a running exec.Cmd. The embedded exec.Cmd is
 // terminated and reaped automatically when the context.Context that
 // created it is canceled.
diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index 0725091b70..58b9d4ab99 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -1,6 +1,18 @@
 package repository
 
-import "sync"
+import (
+	"errors"
+	"sync"
+
+	"gitlab.com/gitlab-org/gitaly/internal/log"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/google/uuid"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+
+	"gitlab.com/gitlab-org/gitaly/internal/command"
+)
 
 // GitRepo supplies an interface for executing `git.Command`s
 type GitRepo interface {
@@ -10,6 +22,91 @@ type GitRepo interface {
 	GetGitAlternateObjectDirectories() []string
 }
 
+func NewTransactions() *Transactions {
+	return &Transactions{
+		transactions: make(map[string]*Transaction),
+		repositories: make(map[string]*sync.Mutex),
+		log:          log.Default(),
+	}
+}
+
+type Transactions struct {
+	txMutex, repoMutex sync.RWMutex
+	transactions       map[string]*Transaction
+	repositories       map[string]*sync.Mutex
+	log                *logrus.Entry
+}
+
+func (t *Transactions) StartTransaction(repo *gitalypb.Repository, rollback command.Cmd) string {
+	tx := Transaction{
+		Repo:     repo,
+		Rollback: rollback,
+	}
+
+	transactionID := uuid.New().String()
+
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+	t.transactions[transactionID] = &tx
+
+	t.repoMutex.Lock()
+	_, ok := t.repositories[repo.RelativePath]
+	if !ok {
+		t.repositories[repo.RelativePath] = &sync.Mutex{}
+	}
+
+	t.repositories[repo.RelativePath].Lock()
+	t.repoMutex.Unlock()
+
+	t.log.WithField("relative_path", repo.RelativePath)
+
+	t.transactions[transactionID].Commit = t.repositories[repo.RelativePath].Unlock
+
+	return transactionID
+}
+
+func (t *Transactions) Commit(transactionID string) error {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return errors.New("request_id not found")
+	}
+
+	t.repoMutex.Lock()
+	tx.Commit()
+	t.repoMutex.Unlock()
+
+	delete(t.transactions, transactionID)
+	return nil
+}
+
+func (t *Transactions) Rollback(transactionID string) error {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return errors.New("request_id not found")
+	}
+
+	if err := tx.Rollback.Wait(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type Transaction struct {
+	//	serviceName string
+	//	methodName  string
+	//	transactionID   string
+	Repo     GitRepo
+	Rollback command.Cmd
+	Commit   func()
+}
+
 type RepoLock interface {
 	Lock(relativePath string)
 	Unlock(relativePath string)
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 2e33135bb4..6b674e4382 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -184,39 +184,56 @@ func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		return err
 	}
 
-	primaryRepo := &gitalypb.Repository{
-		StorageName:  primary.GetStorage(),
-		RelativePath: writeRefReq.GetRepository().GetRelativePath(),
-	}
-
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	primaryRepoClient := gitalypb.NewRepositoryServiceClient(primary.GetConnection())
-	if _, err = primaryRepoClient.WriteRef(ctx, &gitalypb.WriteRefRequest{
-		Repository:  primaryRepo,
-		Ref:         writeRefReq.Ref,
-		Revision:    writeRefReq.Revision,
-		OldRevision: writeRefReq.OldRevision,
-		Force:       writeRefReq.Force,
-	}); err != nil {
-		return err
-	}
+	var errs []error
+	transactionIDs := make(map[string]nodes.Node)
 
-	for _, secondary := range secondaries {
-		secondaryRepo := &gitalypb.Repository{
-			StorageName:  secondary.GetStorage(),
+	for _, node := range append(secondaries, primary) {
+		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+		targetRepo := &gitalypb.Repository{
+			StorageName:  node.GetStorage(),
 			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
 		}
-		secondaryRepoClient := gitalypb.NewRepositoryServiceClient(secondary.GetConnection())
-
-		if _, err = secondaryRepoClient.WriteRef(ctx, &gitalypb.WriteRefRequest{
-			Repository:  secondaryRepo,
+		resp, err := client.WriteRef(ctx, &gitalypb.WriteRefRequest{
+			Repository:  targetRepo,
 			Ref:         writeRefReq.Ref,
 			Revision:    writeRefReq.Revision,
 			OldRevision: writeRefReq.OldRevision,
 			Force:       writeRefReq.Force,
-		}); err != nil {
+			TransactionStep: &gitalypb.TransactionStep{
+				Id:   "",
+				Step: gitalypb.TransactionStep_PRECOMMIT,
+			}})
+		if err != nil {
+			errs = append(errs, err)
+		}
+		transactionIDs[resp.TransactionStep.Id] = node
+	}
+
+	if len(errs) == 0 {
+		for transactionID, node := range transactionIDs {
+			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+			if _, err = client.WriteRef(ctx, &gitalypb.WriteRefRequest{
+				TransactionStep: &gitalypb.TransactionStep{
+					Id:   transactionID,
+					Step: gitalypb.TransactionStep_COMMIT,
+				}}); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}
+
+	for transactionID, node := range transactionIDs {
+		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+		if _, err = client.WriteRef(ctx, &gitalypb.WriteRefRequest{
+			TransactionStep: &gitalypb.TransactionStep{
+				Id:   transactionID,
+				Step: gitalypb.TransactionStep_ROLLBACK,
+			}}); err != nil {
 			return err
 		}
 	}
diff --git a/internal/repotx/lock.go b/internal/repotx/lock.go
new file mode 100644
index 0000000000..6ded8ce28a
--- /dev/null
+++ b/internal/repotx/lock.go
@@ -0,0 +1,10 @@
+package repotx
+
+import "gitlab.com/gitlab-org/gitaly/internal/git/repository"
+
+type Transaction struct {
+	serviceName string
+	methodName  string
+	repo        repository.GitRepo
+	repository.RepoLock
+}
diff --git a/internal/service/repository/server.go b/internal/service/repository/server.go
index 2ea9716be1..ba28188aa3 100644
--- a/internal/service/repository/server.go
+++ b/internal/service/repository/server.go
@@ -16,12 +16,12 @@ type server struct {
 	gitalypb.UnimplementedRepositoryServiceServer
 	connsByAddress map[string]*grpc.ClientConn
 	connsMtx       sync.RWMutex
-	repoLock       repository.RepoLock
+	transactions   *repository.Transactions
 }
 
 // NewServer creates a new instance of a gRPC repo server
 func NewServer(rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
-	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn)}
+	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn), transactions: repository.NewTransactions()}
 }
 
 func (*server) FetchHTTPRemote(context.Context, *gitalypb.FetchHTTPRemoteRequest) (*gitalypb.FetchHTTPRemoteResponse, error) {
diff --git a/internal/service/repository/write_ref.go b/internal/service/repository/write_ref.go
index bbaf239cba..afff0bfa00 100644
--- a/internal/service/repository/write_ref.go
+++ b/internal/service/repository/write_ref.go
@@ -5,21 +5,64 @@ import (
 	"context"
 	"fmt"
 
+	"gitlab.com/gitlab-org/gitaly/internal/command"
+
 	"gitlab.com/gitlab-org/gitaly/internal/git"
 	"gitlab.com/gitlab-org/gitaly/internal/git/updateref"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
 
+func nonTransactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
+	if err := writeRef(ctx, req); err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	return &gitalypb.WriteRefResponse{}, nil
+}
+
+func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
+	var resp gitalypb.WriteRefResponse
+
+	switch req.TransactionStep.Step {
+	case gitalypb.TransactionStep_PRECOMMIT:
+		if err := writeRef(ctx, req); err != nil {
+			return nil, helper.ErrInternal(err)
+		}
+
+		rollback, err := rollbackRef(req)
+		if err != nil {
+			return nil, err
+		}
+		transactionID := s.transactions.StartTransaction(req.GetRepository(), rollback)
+		resp.TransactionStep.Id = transactionID
+	case gitalypb.TransactionStep_COMMIT:
+		if err := s.transactions.Commit(req.TransactionStep.Id); err != nil {
+			return nil, err
+		}
+	case gitalypb.TransactionStep_ROLLBACK:
+		if err := s.transactions.Rollback(req.TransactionStep.Id); err != nil {
+			return nil, err
+		}
+	}
+
+	return &resp, nil
+}
+
 func (s *server) WriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
 	if err := validateWriteRefRequest(req); err != nil {
 		return nil, helper.ErrInvalidArgument(err)
 	}
-	if err := writeRef(ctx, req); err != nil {
-		return nil, helper.ErrInternal(err)
+
+	if req.TransactionStep == nil {
+		return nonTransactionalWriteRef(ctx, req)
 	}
 
-	return &gitalypb.WriteRefResponse{}, nil
+	return s.transactionalWriteRef(ctx, req)
+}
+
+func rollbackSymbolicRef(req *gitalypb.WriteRefRequest) (*command.Command, error) {
+	return git.SafeCmd(context.Background(), req.GetRepository(), nil, git.SubCmd{Name: "symbolic-ref", Args: []string{string(req.GetRef()), string(req.GetOldRevision())}})
 }
 
 func writeRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
@@ -40,6 +83,22 @@ func updateSymbolicRef(ctx context.Context, req *gitalypb.WriteRefRequest) error
 	return nil
 }
 
+func rollbackRef(req *gitalypb.WriteRefRequest) (command.Cmd, error) {
+	if string(req.Ref) == "HEAD" {
+		return rollbackSymbolicRef(req)
+	}
+
+	u, err := updateref.New(context.Background(), req.GetRepository())
+	if err != nil {
+		return nil, fmt.Errorf("error when running creating new updater: %v", err)
+	}
+	if err = u.Update(string(req.GetRef()), string(req.GetOldRevision()), string(req.GetRevision())); err != nil {
+		return nil, fmt.Errorf("error when creating rollback-ref command: %v", err)
+	}
+
+	return u, nil
+}
+
 func updateRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
 	u, err := updateref.New(ctx, req.GetRepository())
 	if err != nil {
diff --git a/proto/go/gitalypb/repository-service.pb.go b/proto/go/gitalypb/repository-service.pb.go
index 645e56202d..59983cc6db 100644
--- a/proto/go/gitalypb/repository-service.pb.go
+++ b/proto/go/gitalypb/repository-service.pb.go
@@ -1199,14 +1199,15 @@ func (m *FsckResponse) GetError() []byte {
 }
 
 type WriteRefRequest struct {
-	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	Ref                  []byte      `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
-	Revision             []byte      `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
-	OldRevision          []byte      `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
-	Force                bool        `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
+	Repository           *Repository      `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Ref                  []byte           `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
+	Revision             []byte           `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	OldRevision          []byte           `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
+	Force                bool             `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
+	TransactionStep      *TransactionStep `protobuf:"bytes,7,opt,name=transaction_step,json=transactionStep,proto3" json:"transaction_step,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *WriteRefRequest) Reset()         { *m = WriteRefRequest{} }
@@ -1269,10 +1270,18 @@ func (m *WriteRefRequest) GetForce() bool {
 	return false
 }
 
+func (m *WriteRefRequest) GetTransactionStep() *TransactionStep {
+	if m != nil {
+		return m.TransactionStep
+	}
+	return nil
+}
+
 type WriteRefResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	TransactionStep      *TransactionStep `protobuf:"bytes,2,opt,name=transaction_step,json=transactionStep,proto3" json:"transaction_step,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *WriteRefResponse) Reset()         { *m = WriteRefResponse{} }
@@ -1300,6 +1309,13 @@ func (m *WriteRefResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WriteRefResponse proto.InternalMessageInfo
 
+func (m *WriteRefResponse) GetTransactionStep() *TransactionStep {
+	if m != nil {
+		return m.TransactionStep
+	}
+	return nil
+}
+
 type FindMergeBaseRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	// We use a repeated field because rugged supports finding a base
@@ -3825,190 +3841,193 @@ func init() {
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor_e9b1768cf174c79b) }
 
 var fileDescriptor_e9b1768cf174c79b = []byte{
-	// 2925 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4b, 0x6f, 0x1c, 0xc7,
-	0xf1, 0xd7, 0xf2, 0xb5, 0xbb, 0xc5, 0x95, 0xb4, 0x6c, 0x52, 0xe4, 0x72, 0x44, 0x8a, 0xd2, 0x48,
-	0x96, 0x65, 0x5b, 0xa6, 0x64, 0xea, 0x0f, 0xfc, 0x9d, 0x04, 0x41, 0xc0, 0xe5, 0x5b, 0x0f, 0x92,
-	0x1e, 0xd2, 0x31, 0x2c, 0xc0, 0x18, 0xcf, 0xce, 0xf6, 0x72, 0x27, 0x9c, 0x9d, 0x5e, 0xcd, 0xf4,
-	0x92, 0xa6, 0x91, 0x1c, 0x12, 0xc0, 0x57, 0x03, 0x01, 0x82, 0x38, 0xc7, 0x9c, 0x72, 0xc8, 0x27,
-	0xc8, 0x25, 0x08, 0x72, 0xc9, 0x77, 0xf0, 0x57, 0xc9, 0x29, 0xe8, 0xc7, 0x4c, 0xcf, 0x73, 0xad,
-	0x60, 0x17, 0xce, 0x6d, 0xba, 0xba, 0xba, 0xaa, 0xba, 0xba, 0xfa, 0x51, 0xbf, 0x1a, 0x68, 0xf8,
-	0xb8, 0x4f, 0x02, 0x87, 0x12, 0xff, 0xea, 0xc3, 0x00, 0xfb, 0x17, 0x8e, 0x8d, 0xd7, 0xfb, 0x3e,
-	0xa1, 0x04, 0xcd, 0x9c, 0x39, 0xd4, 0x72, 0xaf, 0xb4, 0x5a, 0xd0, 0xb5, 0x7c, 0xdc, 0x16, 0x54,
-	0xfd, 0x04, 0x96, 0x8c, 0x68, 0xc4, 0xce, 0x57, 0x4e, 0x40, 0x03, 0x03, 0xbf, 0x19, 0xe0, 0x80,
-	0xa2, 0x8f, 0x01, 0x94, 0xb0, 0x46, 0xe9, 0x6e, 0xe9, 0xd1, 0xec, 0x06, 0x5a, 0x17, 0x52, 0xd6,
-	0xd5, 0xa0, 0xe6, 0xd4, 0x9f, 0xfe, 0xf5, 0xb8, 0x64, 0xc4, 0x78, 0xf5, 0x0d, 0x68, 0x64, 0x85,
-	0x06, 0x7d, 0xe2, 0x05, 0x18, 0x2d, 0xc2, 0x0c, 0xe6, 0x14, 0x2e, 0xb1, 0x62, 0xc8, 0x96, 0x7e,
-	0xca, 0xc7, 0x58, 0xf6, 0xf9, 0x81, 0x67, 0xfb, 0xb8, 0x87, 0x3d, 0x6a, 0xb9, 0xa3, 0x5b, 0x72,
-	0x1b, 0x96, 0x73, 0xa4, 0x0a, 0x53, 0x74, 0x1f, 0xe6, 0x44, 0xe7, 0xee, 0xc0, 0x1d, 0x5d, 0x17,
-	0xba, 0x0f, 0xd7, 0x6d, 0x1f, 0x5b, 0x14, 0x9b, 0x2d, 0x87, 0xf6, 0xac, 0x7e, 0x63, 0x82, 0x4f,
-	0xb0, 0x26, 0x88, 0x4d, 0x4e, 0xd3, 0x17, 0x00, 0xc5, 0x75, 0x4a, 0x4b, 0x2e, 0xe0, 0xd6, 0x9e,
-	0xe5, 0xb7, 0xac, 0x33, 0xbc, 0x45, 0x5c, 0x17, 0xdb, 0xf4, 0x47, 0xb2, 0xa6, 0x01, 0x8b, 0x69,
-	0xbd, 0xd2, 0xa2, 0xe7, 0x70, 0x63, 0xcb, 0xc5, 0x96, 0x37, 0xe8, 0x8f, 0xbe, 0x08, 0x73, 0x70,
-	0x33, 0x92, 0x25, 0xc5, 0x7f, 0x02, 0xb7, 0xd4, 0x90, 0x13, 0xe7, 0x6b, 0x3c, 0xba, 0x96, 0xc7,
-	0xb0, 0x98, 0x16, 0x29, 0x43, 0x0e, 0xc1, 0x54, 0xe0, 0x7c, 0x8d, 0xb9, 0xb4, 0x49, 0x83, 0x7f,
-	0xeb, 0x6f, 0x60, 0x79, 0xb3, 0xdf, 0x77, 0xaf, 0xf6, 0x1c, 0x6a, 0x51, 0xea, 0x3b, 0xad, 0x01,
-	0xc5, 0xa3, 0x47, 0x3e, 0xd2, 0xa0, 0xe2, 0xe3, 0x0b, 0x27, 0x70, 0x88, 0xc7, 0x1d, 0x5e, 0x33,
-	0xa2, 0xb6, 0xbe, 0x02, 0x5a, 0x9e, 0x4a, 0xe9, 0x91, 0x7f, 0x4c, 0x00, 0xda, 0xc5, 0xd4, 0xee,
-	0x1a, 0xb8, 0x47, 0xe8, 0xe8, 0xfe, 0x60, 0x1b, 0xcd, 0xe7, 0xa2, 0xb8, 0x21, 0x55, 0x43, 0xb6,
-	0xd0, 0x02, 0x4c, 0x77, 0x88, 0x6f, 0xe3, 0xc6, 0x24, 0x0f, 0x08, 0xd1, 0x40, 0x4b, 0x50, 0xf6,
-	0x88, 0x49, 0xad, 0xb3, 0xa0, 0x31, 0x25, 0xf6, 0xa5, 0x47, 0x4e, 0xad, 0xb3, 0x00, 0x35, 0xa0,
-	0x4c, 0x9d, 0x1e, 0x26, 0x03, 0xda, 0x98, 0xbe, 0x5b, 0x7a, 0x34, 0x6d, 0x84, 0x4d, 0x36, 0x24,
-	0x08, 0xba, 0xe6, 0x39, 0xbe, 0x6a, 0xcc, 0x08, 0x0d, 0x41, 0xd0, 0x7d, 0x81, 0xaf, 0xd0, 0x1a,
-	0xcc, 0x9e, 0x7b, 0xe4, 0xd2, 0x33, 0xbb, 0x84, 0xed, 0xf3, 0x32, 0xef, 0x04, 0x4e, 0xda, 0x67,
-	0x14, 0xb4, 0x0c, 0x15, 0x8f, 0x98, 0x7d, 0x7f, 0xe0, 0xe1, 0x46, 0x95, 0x6b, 0x2b, 0x7b, 0xe4,
-	0x98, 0x35, 0xd1, 0x33, 0xb8, 0x2e, 0xec, 0x34, 0xfb, 0x96, 0x6f, 0xf5, 0x82, 0x06, 0xf0, 0x29,
-	0xdf, 0x50, 0x53, 0xe6, 0xde, 0xa9, 0x09, 0xa6, 0x63, 0xce, 0xf3, 0x7c, 0xaa, 0x52, 0xa9, 0x57,
-	0xf5, 0x5b, 0x30, 0x9f, 0x70, 0xa0, 0x74, 0xec, 0x09, 0x2c, 0x6d, 0xf1, 0x98, 0x57, 0xde, 0x1a,
-	0x3d, 0xd8, 0x34, 0x68, 0x64, 0x85, 0x4a, 0x85, 0xdf, 0x4c, 0xc0, 0xdc, 0x1e, 0xa6, 0x9b, 0xbe,
-	0xdd, 0x75, 0x2e, 0xc6, 0xb0, 0x90, 0xb7, 0xa1, 0x6a, 0x93, 0x5e, 0xcf, 0xa1, 0xa6, 0xd3, 0x96,
-	0x6b, 0x59, 0x11, 0x84, 0x83, 0x36, 0x5b, 0xe5, 0xbe, 0x8f, 0x3b, 0xce, 0x57, 0x7c, 0x39, 0xab,
-	0x86, 0x6c, 0xa1, 0x8f, 0x61, 0xa6, 0x43, 0xfc, 0x9e, 0x45, 0xf9, 0x72, 0xde, 0xd8, 0xb8, 0x1b,
-	0xaa, 0xca, 0x58, 0xb6, 0xbe, 0xcb, 0xf9, 0x0c, 0xc9, 0xcf, 0x76, 0x4b, 0xdf, 0xa2, 0x5d, 0xbe,
-	0xda, 0x35, 0x83, 0x7f, 0xeb, 0xcf, 0x60, 0x46, 0x70, 0xa1, 0x32, 0x4c, 0xbe, 0x3e, 0x38, 0xae,
-	0x5f, 0x63, 0x1f, 0xa7, 0x9b, 0x46, 0xbd, 0x84, 0x00, 0x66, 0x4e, 0x37, 0x0d, 0x73, 0xef, 0x75,
-	0x7d, 0x02, 0xcd, 0x42, 0x99, 0x7d, 0x37, 0x5f, 0x6f, 0xd4, 0x27, 0xf5, 0x47, 0x80, 0xe2, 0xca,
-	0xd4, 0x66, 0x6c, 0x5b, 0xd4, 0xe2, 0x1e, 0xa8, 0x19, 0xfc, 0x9b, 0x2d, 0xd1, 0xbe, 0x15, 0xbc,
-	0x24, 0xb6, 0xe5, 0x36, 0x7d, 0xcb, 0xb3, 0xbb, 0x63, 0xd8, 0x8a, 0xfa, 0x53, 0x68, 0x64, 0x85,
-	0x4a, 0x23, 0x16, 0x60, 0xfa, 0xc2, 0x72, 0x07, 0x58, 0xde, 0x41, 0xa2, 0xa1, 0x7f, 0x5f, 0x82,
-	0x06, 0x8f, 0xa0, 0x13, 0x32, 0xf0, 0x6d, 0x2c, 0x46, 0x8d, 0xbe, 0x7e, 0xbf, 0x80, 0xb9, 0x80,
-	0x0b, 0x34, 0x63, 0x02, 0x26, 0x8a, 0x04, 0x18, 0x75, 0xc1, 0x6c, 0x24, 0x8e, 0x72, 0x29, 0xa0,
-	0xc5, 0x4d, 0xe2, 0x4b, 0x5d, 0x33, 0x6a, 0x41, 0xcc, 0x4c, 0xb4, 0x0a, 0x40, 0x2d, 0xff, 0x0c,
-	0x53, 0xd3, 0xc7, 0x1d, 0xbe, 0xe8, 0x35, 0xa3, 0x2a, 0x28, 0x06, 0xee, 0xe8, 0xcf, 0x60, 0x39,
-	0x67, 0x6a, 0xea, 0x4e, 0xf6, 0x71, 0x30, 0x70, 0x69, 0x78, 0x27, 0x8b, 0x96, 0xbe, 0x07, 0xb3,
-	0xbb, 0x81, 0x7d, 0x3e, 0xfa, 0x5a, 0x3c, 0x80, 0x9a, 0x10, 0xa4, 0xfc, 0x8f, 0x7d, 0x9f, 0xf8,
-	0x32, 0x0a, 0x44, 0x43, 0xff, 0x5b, 0x09, 0x6e, 0x7e, 0xe6, 0x3b, 0x6c, 0x53, 0x75, 0x46, 0x77,
-	0x7b, 0x1d, 0x26, 0x99, 0x27, 0xc4, 0x29, 0xcc, 0x3e, 0x13, 0x87, 0xf3, 0x64, 0xf2, 0x70, 0x46,
-	0xf7, 0xa0, 0x46, 0xdc, 0xb6, 0x19, 0xf5, 0x0b, 0x07, 0xce, 0x12, 0xb7, 0x6d, 0x84, 0x2c, 0xd1,
-	0xc1, 0x39, 0x1d, 0x3b, 0x38, 0x9f, 0x4f, 0x55, 0x66, 0xea, 0x65, 0xbd, 0x01, 0x75, 0x65, 0xb9,
-	0x98, 0xe4, 0xf3, 0xa9, 0x4a, 0xa9, 0x3e, 0xa1, 0x7b, 0xb0, 0xb0, 0xeb, 0x78, 0xed, 0x57, 0xd8,
-	0x3f, 0xc3, 0x4d, 0x2b, 0x18, 0xc3, 0x79, 0xb0, 0x02, 0xd5, 0xd0, 0xcc, 0xa0, 0x31, 0x71, 0x77,
-	0x92, 0x2d, 0x74, 0x44, 0xd0, 0x3f, 0x80, 0x5b, 0x29, 0x7d, 0x6a, 0xe3, 0xb5, 0xac, 0x40, 0x84,
-	0x7c, 0xd5, 0xe0, 0xdf, 0xfa, 0xb7, 0x25, 0x98, 0x13, 0xe7, 0xd8, 0x2e, 0xf1, 0xcf, 0xff, 0xf7,
-	0xa1, 0xce, 0x9e, 0x47, 0x71, 0x7b, 0xa2, 0x87, 0xda, 0xf2, 0x41, 0x60, 0x60, 0x66, 0xf2, 0x81,
-	0x77, 0xec, 0x93, 0x33, 0x1f, 0x07, 0xc1, 0x58, 0x0e, 0x56, 0x9f, 0x0b, 0x8d, 0x1d, 0xac, 0x82,
-	0x70, 0xd0, 0xd6, 0x7f, 0x0e, 0x5a, 0x9e, 0x4e, 0xe9, 0xcc, 0x35, 0x98, 0x75, 0x3c, 0xb3, 0x2f,
-	0xc9, 0x72, 0xdb, 0x80, 0x13, 0x31, 0x0a, 0x93, 0x4f, 0xde, 0x0c, 0xac, 0xa0, 0x3b, 0x66, 0x93,
-	0x03, 0x2e, 0x34, 0x66, 0xb2, 0x20, 0x84, 0x26, 0x67, 0x75, 0xbe, 0xad, 0xc9, 0x2e, 0xdc, 0x49,
-	0xdf, 0x69, 0xbb, 0x3e, 0xe9, 0x7d, 0x6a, 0xbc, 0x1c, 0xcb, 0x66, 0x1c, 0xf8, 0xae, 0xb4, 0x98,
-	0x7d, 0xea, 0xf7, 0x60, 0xad, 0x50, 0x9b, 0x5c, 0xf6, 0x23, 0x98, 0x17, 0x2c, 0xcd, 0x81, 0xd7,
-	0x76, 0xc7, 0xf0, 0x44, 0x7c, 0x1f, 0x16, 0x92, 0x02, 0x87, 0xdc, 0x49, 0xdf, 0x4e, 0x40, 0xfd,
-	0x04, 0xd3, 0x2d, 0xe2, 0x75, 0x9c, 0xb3, 0xd1, 0x1d, 0xf0, 0x31, 0x94, 0xb1, 0x47, 0x7d, 0x07,
-	0x8b, 0x2d, 0x3b, 0xbb, 0x71, 0x27, 0x1c, 0x96, 0x56, 0xb2, 0xbe, 0xe3, 0x51, 0xff, 0xca, 0x08,
-	0xd9, 0xb5, 0x6f, 0x4a, 0x30, 0xcd, 0x49, 0xcc, 0x89, 0xec, 0xb1, 0x25, 0x36, 0x30, 0xfb, 0x44,
-	0xab, 0x50, 0xe5, 0x57, 0x97, 0x19, 0x50, 0x5f, 0x38, 0x77, 0xff, 0x9a, 0x51, 0xe1, 0xa4, 0x13,
-	0xea, 0xa3, 0x7b, 0x30, 0x2b, 0xba, 0x1d, 0x8f, 0x3e, 0xdb, 0xe0, 0x67, 0xde, 0xf4, 0xfe, 0x35,
-	0x03, 0x38, 0xf1, 0x80, 0xd1, 0xd0, 0x1a, 0x88, 0x96, 0xd9, 0x22, 0xc4, 0x15, 0x4f, 0xbf, 0xfd,
-	0x6b, 0x86, 0x90, 0xda, 0x24, 0xc4, 0x6d, 0x96, 0xe5, 0x55, 0xa9, 0xcf, 0xc3, 0x5c, 0xcc, 0x54,
-	0xb9, 0x44, 0x36, 0xcc, 0x6f, 0x63, 0x17, 0x53, 0x3c, 0x2e, 0x3f, 0x21, 0x98, 0x3a, 0xc7, 0x57,
-	0xc2, 0x49, 0x55, 0x83, 0x7f, 0xeb, 0x8b, 0xb0, 0x90, 0x54, 0x22, 0x95, 0x3b, 0x2c, 0xb9, 0x0b,
-	0x28, 0xf1, 0xf1, 0xd6, 0x20, 0xa0, 0xa4, 0xb7, 0x4f, 0xc8, 0x79, 0x30, 0x16, 0x13, 0x78, 0x34,
-	0x4c, 0xc4, 0xa2, 0x61, 0x05, 0xb4, 0x3c, 0x55, 0xd2, 0x90, 0x53, 0x68, 0x34, 0x2d, 0xfb, 0x7c,
-	0xd0, 0x1f, 0xa7, 0x1d, 0xfa, 0x13, 0x58, 0xce, 0x91, 0x3a, 0x24, 0x64, 0xdf, 0xc0, 0xbd, 0xbc,
-	0x2d, 0x35, 0xa6, 0xdd, 0x93, 0xeb, 0x97, 0x07, 0xa0, 0x0f, 0x53, 0x29, 0xfd, 0x73, 0x08, 0x88,
-	0xdd, 0x49, 0x2f, 0x1d, 0x1b, 0x7b, 0x63, 0xb8, 0x01, 0xf5, 0x2d, 0x98, 0x4f, 0xc8, 0x93, 0x3e,
-	0x79, 0x0c, 0xc8, 0x15, 0x24, 0x33, 0xe8, 0x12, 0x9f, 0x9a, 0x9e, 0xd5, 0x0b, 0xef, 0xbb, 0xba,
-	0xec, 0x39, 0x61, 0x1d, 0x87, 0x56, 0x8f, 0x2f, 0xda, 0x1e, 0xa6, 0x07, 0x5e, 0x87, 0x6c, 0x8e,
-	0x2f, 0x01, 0xd4, 0x7f, 0x06, 0xcb, 0x39, 0x52, 0xa5, 0x81, 0x77, 0x00, 0x54, 0xe6, 0x27, 0x97,
-	0x2e, 0x46, 0x61, 0x26, 0x6d, 0x59, 0xae, 0x3d, 0x70, 0x2d, 0x8a, 0xb7, 0xba, 0xd8, 0x3e, 0x0f,
-	0x06, 0xbd, 0xd1, 0x4d, 0xfa, 0x7f, 0x58, 0xce, 0x91, 0x2a, 0x4d, 0xd2, 0xa0, 0x62, 0x4b, 0x9a,
-	0xf4, 0x54, 0xd4, 0x66, 0xcb, 0xb6, 0x87, 0xe9, 0x89, 0x67, 0xf5, 0x83, 0x2e, 0x19, 0x1d, 0x92,
-	0xd0, 0xdf, 0x83, 0xf9, 0x84, 0xbc, 0x21, 0xa1, 0xfc, 0x5d, 0x09, 0xee, 0xe7, 0x05, 0xd6, 0xd8,
-	0x8c, 0x61, 0x39, 0x68, 0x97, 0xd2, 0xbe, 0xa9, 0xae, 0xa5, 0x32, 0x6b, 0x7f, 0xea, 0xbb, 0xec,
-	0x92, 0xe5, 0x5d, 0xd6, 0x80, 0x76, 0x65, 0x5a, 0xc5, 0x79, 0x37, 0x07, 0xb4, 0xab, 0x3f, 0x84,
-	0x07, 0xc3, 0x0d, 0x93, 0x31, 0xff, 0xc7, 0x12, 0x2c, 0xec, 0x61, 0x6a, 0x58, 0x97, 0x5b, 0x5d,
-	0xcb, 0x3b, 0x1b, 0x07, 0xb8, 0x70, 0x1f, 0xae, 0x77, 0x7c, 0xd2, 0x33, 0x13, 0x08, 0x43, 0xd5,
-	0xa8, 0x31, 0x62, 0xf4, 0x4a, 0x5d, 0x83, 0x59, 0x4a, 0xcc, 0xc4, 0x3b, 0xb7, 0x6a, 0x00, 0x25,
-	0x21, 0x83, 0xfe, 0xf7, 0x29, 0xb8, 0x95, 0x32, 0x4c, 0x2e, 0xc4, 0x3e, 0xcc, 0xfa, 0xd6, 0xa5,
-	0x69, 0x0b, 0x72, 0xa3, 0xc4, 0xef, 0xa9, 0x77, 0x63, 0x89, 0x63, 0x76, 0xcc, 0x7a, 0x44, 0x32,
-	0xc0, 0x8f, 0x7a, 0xb5, 0xef, 0x27, 0xa1, 0x1a, 0xf5, 0xa0, 0x25, 0x28, 0xb7, 0x5c, 0xd2, 0x62,
-	0x4f, 0x16, 0x11, 0x62, 0x33, 0xac, 0x79, 0xd0, 0x8e, 0x80, 0x99, 0x09, 0x05, 0xcc, 0xa0, 0x55,
-	0xa8, 0x78, 0xf8, 0xd2, 0xe4, 0x29, 0x28, 0x37, 0xbe, 0x39, 0xd1, 0x28, 0x19, 0x65, 0x0f, 0x5f,
-	0x1e, 0x5b, 0x94, 0xa5, 0x39, 0x15, 0xf6, 0x4e, 0xe7, 0xdd, 0x53, 0xaa, 0x9b, 0xb8, 0x6d, 0xde,
-	0x7d, 0x04, 0x55, 0xd2, 0xc7, 0xbe, 0x45, 0xd9, 0xdc, 0xa7, 0x79, 0xe6, 0xfb, 0xd1, 0x5b, 0x4e,
-	0x60, 0xfd, 0x28, 0x1c, 0x68, 0x28, 0x19, 0xcc, 0xe7, 0xcc, 0x27, 0x4a, 0xa8, 0x80, 0x3a, 0x6a,
-	0xbe, 0x75, 0x19, 0xf1, 0xb3, 0x58, 0x62, 0x46, 0xf5, 0x48, 0x1b, 0x73, 0xb4, 0x63, 0x9a, 0x1b,
-	0xf4, 0x8a, 0xb4, 0x31, 0x87, 0x3a, 0xf0, 0xa5, 0xe8, 0xaa, 0x88, 0x2e, 0x0f, 0x5f, 0xf2, 0xae,
-	0x07, 0x70, 0x23, 0x9c, 0xa9, 0xd9, 0xba, 0x62, 0x27, 0x42, 0x55, 0xe4, 0x75, 0x72, 0xae, 0x4d,
-	0x46, 0x63, 0x5c, 0xe1, 0x84, 0x25, 0x17, 0x08, 0x2e, 0x39, 0x65, 0xce, 0xa5, 0x3b, 0x50, 0x55,
-	0xe6, 0xcc, 0x42, 0xf9, 0xd3, 0xc3, 0x17, 0x87, 0x47, 0x9f, 0x1d, 0xd6, 0xaf, 0xa1, 0x2a, 0x4c,
-	0x6f, 0x6e, 0x6f, 0xef, 0x6c, 0x8b, 0x4c, 0x7d, 0xeb, 0xe8, 0xf8, 0x60, 0x67, 0x5b, 0x64, 0xea,
-	0xdb, 0x3b, 0x2f, 0x77, 0x4e, 0x77, 0xb6, 0xeb, 0x93, 0xa8, 0x06, 0x95, 0x57, 0x47, 0xdb, 0x07,
-	0xbb, 0xac, 0x6b, 0x8a, 0x75, 0x19, 0x3b, 0x87, 0x9b, 0xaf, 0x76, 0xb6, 0xeb, 0xd3, 0xa8, 0x0e,
-	0xb5, 0xd3, 0xcf, 0x8f, 0x77, 0xcc, 0xad, 0xfd, 0xcd, 0xc3, 0xbd, 0x9d, 0xed, 0xfa, 0x8c, 0xfe,
-	0x6b, 0x68, 0x9c, 0x60, 0xcb, 0xb7, 0xbb, 0xbb, 0x8e, 0x8b, 0x83, 0xe6, 0x15, 0x3b, 0x4c, 0x47,
-	0x8f, 0xed, 0x05, 0x98, 0x7e, 0x33, 0xc0, 0x32, 0x5b, 0xa8, 0x1a, 0xa2, 0x11, 0xe6, 0x70, 0x93,
-	0x51, 0x0e, 0xa7, 0x7f, 0x04, 0xcb, 0x39, 0xda, 0x55, 0x5a, 0xd9, 0x61, 0x64, 0x1e, 0xba, 0x35,
-	0x43, 0x34, 0xf4, 0xbf, 0x96, 0xe0, 0x76, 0x62, 0xcc, 0x16, 0xf1, 0x28, 0xf6, 0xe8, 0x8f, 0x66,
-	0x34, 0x7a, 0x0f, 0xea, 0x76, 0x77, 0xe0, 0x9d, 0x63, 0x96, 0x60, 0x0a, 0x5b, 0x25, 0xca, 0x76,
-	0x53, 0xd2, 0xa3, 0x63, 0xe3, 0x0a, 0x56, 0xf2, 0x6d, 0x95, 0x53, 0x6c, 0x40, 0xb9, 0x67, 0x51,
-	0xbb, 0x1b, 0x4d, 0x32, 0x6c, 0xa2, 0x55, 0x00, 0xfe, 0x69, 0xc6, 0x2e, 0xe9, 0x2a, 0xa7, 0x6c,
-	0x5b, 0xd4, 0x42, 0x77, 0xa1, 0x86, 0xbd, 0xb6, 0x49, 0x3a, 0x26, 0xa7, 0x49, 0xf4, 0x0f, 0xb0,
-	0xd7, 0x3e, 0xea, 0xbc, 0x62, 0x14, 0xfd, 0xf7, 0x25, 0x98, 0x11, 0xd8, 0x59, 0xf8, 0x5c, 0x2f,
-	0x45, 0xcf, 0x75, 0xb6, 0x55, 0xf9, 0x6d, 0x2a, 0x66, 0xca, 0xbf, 0xd1, 0x4f, 0x61, 0x39, 0x3a,
-	0x27, 0x89, 0xef, 0x7c, 0xcd, 0xa3, 0xcf, 0xec, 0x62, 0xab, 0x8d, 0x7d, 0x79, 0xf0, 0x2c, 0x85,
-	0xe7, 0x66, 0xd4, 0xbf, 0xcf, 0xbb, 0xd1, 0x3b, 0x70, 0xa3, 0xe7, 0xb0, 0xac, 0xdf, 0xf4, 0x71,
-	0xa7, 0x67, 0xf5, 0x83, 0xc6, 0x14, 0x7f, 0xf1, 0x5d, 0x17, 0x54, 0x43, 0x10, 0xf5, 0x3f, 0x94,
-	0x60, 0x91, 0xe3, 0x16, 0xfb, 0xa7, 0xa7, 0xc7, 0xe3, 0x42, 0x46, 0x1f, 0x26, 0x90, 0xd1, 0x2c,
-	0xb8, 0x18, 0x22, 0xa5, 0x31, 0xe8, 0x73, 0x32, 0x01, 0x7d, 0xea, 0xcb, 0xb0, 0x94, 0xb1, 0x4a,
-	0x2e, 0xe0, 0xe7, 0xb0, 0xba, 0x87, 0xe9, 0x51, 0xeb, 0x57, 0xd8, 0xa6, 0xdb, 0x8e, 0x8f, 0xed,
-	0xf1, 0x21, 0xdc, 0xff, 0x07, 0x77, 0x8a, 0x44, 0x0f, 0x41, 0xba, 0xff, 0x5c, 0x82, 0x85, 0x2d,
-	0x97, 0x78, 0x98, 0x5d, 0x53, 0xc7, 0x84, 0xb8, 0xe3, 0x70, 0xe0, 0x54, 0x9f, 0xa5, 0x0b, 0xa9,
-	0xcc, 0x5e, 0x58, 0xc6, 0x55, 0xf0, 0xfe, 0x98, 0xa3, 0x27, 0x87, 0x39, 0x5a, 0x5f, 0x82, 0x5b,
-	0x29, 0x0b, 0xa5, 0x33, 0xff, 0x59, 0x82, 0x95, 0x44, 0xcf, 0x81, 0x47, 0xb1, 0xef, 0x59, 0x3f,
-	0xe2, 0x1c, 0x72, 0x21, 0x8d, 0xc9, 0xff, 0x02, 0xd2, 0x58, 0x83, 0xd5, 0x82, 0x29, 0x28, 0x80,
-	0x9a, 0xf9, 0xe3, 0x62, 0xdc, 0x00, 0x75, 0x56, 0xa8, 0x54, 0xf8, 0x15, 0x53, 0xe8, 0xf1, 0x83,
-	0x73, 0x6c, 0x0a, 0xf9, 0x45, 0x89, 0x5d, 0x8b, 0x3a, 0x17, 0x58, 0xdc, 0xce, 0xf2, 0x71, 0x12,
-	0x12, 0xd9, 0x5d, 0x25, 0xac, 0x4a, 0x6b, 0x96, 0x56, 0xfd, 0xae, 0xc4, 0x72, 0xac, 0xbe, 0xeb,
-	0xd8, 0xe3, 0xc5, 0xea, 0xd1, 0xfb, 0x30, 0x23, 0x16, 0x65, 0x08, 0x12, 0x25, 0x39, 0xf4, 0x55,
-	0xb8, 0x9d, 0x6b, 0x83, 0xb0, 0x71, 0xe3, 0x2f, 0xab, 0xbc, 0x64, 0x18, 0x16, 0x99, 0x44, 0x7d,
-	0x15, 0x7d, 0x01, 0xf5, 0x74, 0xb9, 0x13, 0xad, 0x65, 0x95, 0x24, 0xaa, 0xab, 0xda, 0xdd, 0x62,
-	0x06, 0xe9, 0x90, 0x99, 0x7f, 0x7f, 0xf7, 0x68, 0xa2, 0x32, 0x81, 0xbe, 0x0c, 0xcb, 0x94, 0xb1,
-	0x1a, 0x26, 0x8a, 0x0f, 0xcf, 0x2d, 0x9a, 0x6a, 0xf7, 0x86, 0x70, 0x24, 0x34, 0x94, 0xd0, 0x0b,
-	0x00, 0x55, 0x94, 0x44, 0xcb, 0xc9, 0x81, 0xb1, 0xe2, 0xa8, 0xa6, 0xe5, 0x75, 0xa5, 0x84, 0x7d,
-	0x06, 0x37, 0x92, 0x35, 0x45, 0xb4, 0x1a, 0xbd, 0xc0, 0xf2, 0x6a, 0x9c, 0xda, 0x9d, 0xa2, 0xee,
-	0xac, 0xe0, 0x64, 0x81, 0x4f, 0x09, 0xce, 0xad, 0x25, 0x2a, 0xc1, 0xf9, 0x75, 0xc1, 0x48, 0xb0,
-	0x0d, 0x28, 0x5b, 0x98, 0x43, 0x91, 0xff, 0x0a, 0xeb, 0x84, 0x9a, 0x3e, 0x8c, 0x25, 0xa5, 0xe4,
-	0x10, 0x66, 0x63, 0xd5, 0x29, 0x14, 0x79, 0x32, 0x5b, 0xf3, 0xd3, 0x6e, 0xe7, 0xf6, 0xa5, 0xe4,
-	0x7d, 0x01, 0xf5, 0x74, 0x1e, 0xa2, 0x82, 0xae, 0xa0, 0xe0, 0xa5, 0x82, 0xae, 0xb0, 0x78, 0x15,
-	0x8a, 0x7f, 0x05, 0xa0, 0x8a, 0x37, 0x2a, 0x24, 0x32, 0xd5, 0x23, 0x15, 0x12, 0xd9, 0x5a, 0x4f,
-	0x28, 0xec, 0x29, 0xb7, 0x36, 0x5d, 0x8c, 0x51, 0xd6, 0x16, 0xd4, 0x7e, 0x94, 0xb5, 0x45, 0x75,
-	0x9c, 0xf8, 0x16, 0xc9, 0x54, 0x37, 0xd4, 0x16, 0x29, 0xaa, 0xe9, 0xa8, 0x2d, 0x52, 0x58, 0x1a,
-	0x89, 0xfc, 0xf1, 0x13, 0x98, 0xda, 0x0d, 0xec, 0x73, 0x34, 0x1f, 0x0d, 0x51, 0x85, 0x11, 0x6d,
-	0x21, 0x49, 0x4c, 0x0d, 0xdd, 0x81, 0x4a, 0x58, 0x1b, 0x40, 0x4b, 0x21, 0x67, 0xaa, 0xce, 0xa1,
-	0x35, 0xb2, 0x1d, 0x29, 0x31, 0xa7, 0x70, 0x3d, 0x01, 0xec, 0xa3, 0x95, 0x48, 0x6b, 0x4e, 0x7d,
-	0x41, 0x5b, 0x2d, 0xe8, 0x4d, 0x79, 0xee, 0x05, 0x80, 0x02, 0xdc, 0xd5, 0x3a, 0x67, 0x8a, 0x02,
-	0x6a, 0x9d, 0x73, 0xf0, 0xf9, 0xd8, 0x46, 0xca, 0x62, 0xe6, 0x6a, 0x23, 0x15, 0x62, 0xf8, 0x6a,
-	0x23, 0x15, 0x43, 0xee, 0x91, 0xc5, 0x5c, 0x49, 0x1a, 0xe5, 0x8e, 0x2b, 0x29, 0x40, 0xdd, 0xe3,
-	0x4a, 0x8a, 0x40, 0xf2, 0x48, 0x89, 0x9f, 0x2d, 0x1a, 0x4b, 0x74, 0x1a, 0x3d, 0x2c, 0xda, 0x43,
-	0x49, 0xb0, 0x5c, 0x7b, 0xf7, 0x07, 0xf9, 0x52, 0xde, 0x3b, 0x81, 0x5a, 0x1c, 0x9d, 0x46, 0xb7,
-	0x93, 0x02, 0x12, 0x30, 0x9e, 0xb6, 0x92, 0xdf, 0x99, 0x9c, 0xc6, 0xd3, 0x12, 0xfa, 0x0d, 0x68,
-	0xc5, 0x00, 0x1d, 0x7a, 0x6f, 0x98, 0x8d, 0x49, 0x85, 0xef, 0xbf, 0x0d, 0x6b, 0x72, 0x46, 0x8f,
-	0x4a, 0x68, 0x1f, 0xaa, 0x11, 0x68, 0x8c, 0x1a, 0x45, 0x90, 0xb7, 0xb6, 0x9c, 0xd3, 0x93, 0xf2,
-	0xce, 0x27, 0x50, 0x8b, 0x83, 0xc0, 0xca, 0x3b, 0x39, 0xf8, 0xb3, 0xf2, 0x4e, 0x2e, 0x6e, 0x1c,
-	0x3f, 0x92, 0x15, 0x8c, 0x18, 0x3b, 0x92, 0x33, 0x58, 0x65, 0xec, 0x48, 0xce, 0xe2, 0x8e, 0x51,
-	0xd0, 0xb4, 0x78, 0xdd, 0x3f, 0x89, 0xfd, 0xa1, 0x78, 0xe1, 0x3d, 0x17, 0x6c, 0x54, 0xa7, 0x50,
-	0x21, 0x70, 0x18, 0x5b, 0xcf, 0x2f, 0x61, 0x2e, 0x03, 0xe6, 0x29, 0x1d, 0x45, 0xe8, 0xa1, 0xd2,
-	0x51, 0x88, 0x04, 0x46, 0xb3, 0x68, 0x42, 0x59, 0xfe, 0xad, 0x83, 0x16, 0xa3, 0x51, 0x89, 0x5f,
-	0x81, 0xb4, 0xa5, 0x0c, 0x3d, 0xe5, 0xd9, 0x63, 0x98, 0x8d, 0x21, 0x7d, 0x28, 0x7e, 0x47, 0xa4,
-	0x10, 0x3c, 0xe5, 0xd9, 0x1c, 0x68, 0x30, 0x36, 0xef, 0xdf, 0xb2, 0x4c, 0x60, 0x08, 0xee, 0x86,
-	0x3e, 0x18, 0x16, 0x9f, 0x69, 0xa5, 0x8f, 0xdf, 0x8e, 0x39, 0x35, 0xab, 0x5f, 0xc2, 0xf5, 0x04,
-	0x86, 0xa4, 0x4e, 0xe0, 0x3c, 0xa0, 0x4f, 0x9d, 0xc0, 0xb9, 0xc0, 0x53, 0x6c, 0x6e, 0xe7, 0xb0,
-	0x90, 0x97, 0xf3, 0xa3, 0xfb, 0x6a, 0x57, 0x14, 0xa2, 0x17, 0xda, 0x83, 0xe1, 0x4c, 0x19, 0x65,
-	0x2d, 0x98, 0xcb, 0x00, 0x28, 0x2a, 0x80, 0x8a, 0x90, 0x1d, 0x15, 0x40, 0x85, 0xe8, 0x4b, 0x4c,
-	0x07, 0x06, 0x94, 0xad, 0x96, 0xa0, 0xd8, 0x83, 0xb4, 0xa0, 0x68, 0xa3, 0x8e, 0xe8, 0x21, 0xc5,
-	0x16, 0x75, 0xb8, 0xb4, 0x60, 0x2e, 0x53, 0x20, 0x51, 0x53, 0x29, 0xaa, 0xc8, 0xa8, 0xa9, 0x14,
-	0x56, 0x57, 0x62, 0x53, 0x79, 0x0d, 0x37, 0x53, 0x99, 0x3e, 0xba, 0x93, 0x78, 0x35, 0x64, 0x80,
-	0x09, 0x6d, 0xad, 0xb0, 0x3f, 0x15, 0x4f, 0x04, 0x16, 0xf3, 0xf3, 0x79, 0xf4, 0x4e, 0x2c, 0x74,
-	0x8a, 0xa1, 0x04, 0xed, 0xe1, 0x0f, 0xb1, 0xa5, 0xb6, 0xf6, 0x29, 0x5c, 0x4f, 0xa4, 0xa2, 0x2a,
-	0x80, 0xf3, 0x00, 0x02, 0x15, 0xc0, 0xf9, 0xc9, 0x79, 0x38, 0x0d, 0x37, 0x95, 0xbd, 0x87, 0x09,
-	0x2e, 0x7a, 0x90, 0x3b, 0x3e, 0x95, 0xc2, 0x6b, 0xef, 0xfc, 0x00, 0x57, 0xf6, 0xdd, 0x9b, 0x4e,
-	0x6c, 0xe3, 0xc9, 0x56, 0x6e, 0x1e, 0x1d, 0x4f, 0xb6, 0x0a, 0x72, 0xe2, 0x84, 0xf8, 0x64, 0x86,
-	0x1a, 0x17, 0x9f, 0x9b, 0x35, 0xc7, 0xc5, 0x17, 0x24, 0xb7, 0xa1, 0xf8, 0x0e, 0xcc, 0xe7, 0xe4,
-	0x97, 0x28, 0x16, 0xf7, 0x45, 0x09, 0xb0, 0x76, 0x7f, 0x28, 0x4f, 0x52, 0x4f, 0xf3, 0xe9, 0x6b,
-	0xc6, 0xed, 0x5a, 0xad, 0x75, 0x9b, 0xf4, 0x9e, 0x88, 0xcf, 0x0f, 0x89, 0x7f, 0xf6, 0x44, 0xc8,
-	0x78, 0xc2, 0x7f, 0xfe, 0x7d, 0x72, 0x46, 0x64, 0xbb, 0xdf, 0x6a, 0xcd, 0x70, 0xd2, 0xb3, 0xff,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x53, 0xac, 0x6d, 0x41, 0x2c, 0x00, 0x00,
+	// 2962 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7,
+	0xf5, 0x37, 0x75, 0x23, 0x79, 0x44, 0xdb, 0xd4, 0x48, 0xb6, 0xa8, 0xb5, 0x65, 0xd9, 0x6b, 0xc7,
+	0x71, 0x12, 0x47, 0x76, 0xe4, 0x3f, 0xf0, 0x4f, 0x5b, 0x14, 0x85, 0xa8, 0x7b, 0x6c, 0x4b, 0xca,
+	0x4a, 0x69, 0x10, 0xa3, 0xc1, 0x66, 0xb9, 0x1c, 0x89, 0x5b, 0x2d, 0x77, 0xe8, 0xd9, 0xa1, 0x14,
+	0x05, 0xed, 0x43, 0x0b, 0xe4, 0x35, 0x40, 0x81, 0xa2, 0xe9, 0x63, 0x9f, 0xfa, 0xd0, 0xef, 0x50,
+	0x14, 0x7d, 0xe9, 0x77, 0xc8, 0x57, 0x29, 0xfa, 0x50, 0xcc, 0x85, 0x3b, 0x7b, 0x65, 0x1c, 0x90,
+	0x48, 0xdf, 0x76, 0xce, 0x9c, 0x39, 0xe7, 0xcc, 0x99, 0x33, 0x97, 0xf3, 0x3b, 0x0b, 0x0d, 0x8a,
+	0x7b, 0x24, 0xf4, 0x18, 0xa1, 0x97, 0xef, 0x87, 0x98, 0x9e, 0x7b, 0x2e, 0x5e, 0xed, 0x51, 0xc2,
+	0x08, 0x9a, 0x39, 0xf5, 0x98, 0xe3, 0x5f, 0x1a, 0xb5, 0xb0, 0xe3, 0x50, 0xdc, 0x96, 0x54, 0xf3,
+	0x08, 0x16, 0xad, 0x68, 0xc4, 0xd6, 0x97, 0x5e, 0xc8, 0x42, 0x0b, 0xbf, 0xee, 0xe3, 0x90, 0xa1,
+	0x0f, 0x01, 0xb4, 0xb0, 0x46, 0xe9, 0x6e, 0xe9, 0xd1, 0xec, 0x1a, 0x5a, 0x95, 0x52, 0x56, 0xf5,
+	0xa0, 0xe6, 0xd4, 0x9f, 0xff, 0xf5, 0xb8, 0x64, 0xc5, 0x78, 0xcd, 0x35, 0x68, 0x64, 0x85, 0x86,
+	0x3d, 0x12, 0x84, 0x18, 0xdd, 0x84, 0x19, 0x2c, 0x28, 0x42, 0x62, 0xc5, 0x52, 0x2d, 0xf3, 0x58,
+	0x8c, 0x71, 0xdc, 0xb3, 0xbd, 0xc0, 0xa5, 0xb8, 0x8b, 0x03, 0xe6, 0xf8, 0xa3, 0x5b, 0x72, 0x0b,
+	0x96, 0x72, 0xa4, 0x4a, 0x53, 0x4c, 0x0a, 0x73, 0xb2, 0x73, 0xbb, 0xef, 0x8f, 0xae, 0x0b, 0xdd,
+	0x87, 0xab, 0x2e, 0xc5, 0x0e, 0xc3, 0x76, 0xcb, 0x63, 0x5d, 0xa7, 0xd7, 0x98, 0x10, 0x13, 0xac,
+	0x49, 0x62, 0x53, 0xd0, 0xcc, 0x05, 0x40, 0x71, 0x9d, 0xca, 0x92, 0x73, 0xb8, 0xb1, 0xe3, 0xd0,
+	0x96, 0x73, 0x8a, 0x37, 0x88, 0xef, 0x63, 0x97, 0xfd, 0x48, 0xd6, 0x34, 0xe0, 0x66, 0x5a, 0xaf,
+	0xb2, 0xe8, 0x23, 0xb8, 0xb6, 0xe1, 0x63, 0x27, 0xe8, 0xf7, 0x46, 0x5f, 0x84, 0x39, 0xb8, 0x1e,
+	0xc9, 0x52, 0xe2, 0x3f, 0x86, 0x1b, 0x7a, 0xc8, 0x91, 0xf7, 0x15, 0x1e, 0x5d, 0xcb, 0x63, 0xb8,
+	0x99, 0x16, 0xa9, 0x42, 0x0e, 0xc1, 0x54, 0xe8, 0x7d, 0x85, 0x85, 0xb4, 0x49, 0x4b, 0x7c, 0x9b,
+	0xaf, 0x61, 0x69, 0xbd, 0xd7, 0xf3, 0x2f, 0x77, 0x3c, 0xe6, 0x30, 0x46, 0xbd, 0x56, 0x9f, 0xe1,
+	0xd1, 0x23, 0x1f, 0x19, 0x50, 0xa1, 0xf8, 0xdc, 0x0b, 0x3d, 0x12, 0x08, 0x87, 0xd7, 0xac, 0xa8,
+	0x6d, 0xde, 0x06, 0x23, 0x4f, 0xa5, 0xf2, 0xc8, 0x3f, 0x26, 0x00, 0x6d, 0x63, 0xe6, 0x76, 0x2c,
+	0xdc, 0x25, 0x6c, 0x74, 0x7f, 0xf0, 0x8d, 0x46, 0x85, 0x28, 0x61, 0x48, 0xd5, 0x52, 0x2d, 0xb4,
+	0x00, 0xd3, 0x27, 0x84, 0xba, 0xb8, 0x31, 0x29, 0x02, 0x42, 0x36, 0xd0, 0x22, 0x94, 0x03, 0x62,
+	0x33, 0xe7, 0x34, 0x6c, 0x4c, 0xc9, 0x7d, 0x19, 0x90, 0x63, 0xe7, 0x34, 0x44, 0x0d, 0x28, 0x33,
+	0xaf, 0x8b, 0x49, 0x9f, 0x35, 0xa6, 0xef, 0x96, 0x1e, 0x4d, 0x5b, 0x83, 0x26, 0x1f, 0x12, 0x86,
+	0x1d, 0xfb, 0x0c, 0x5f, 0x36, 0x66, 0xa4, 0x86, 0x30, 0xec, 0x3c, 0xc7, 0x97, 0x68, 0x05, 0x66,
+	0xcf, 0x02, 0x72, 0x11, 0xd8, 0x1d, 0xc2, 0xf7, 0x79, 0x59, 0x74, 0x82, 0x20, 0xed, 0x72, 0x0a,
+	0x5a, 0x82, 0x4a, 0x40, 0xec, 0x1e, 0xed, 0x07, 0xb8, 0x51, 0x15, 0xda, 0xca, 0x01, 0x39, 0xe4,
+	0x4d, 0xf4, 0x0c, 0xae, 0x4a, 0x3b, 0xed, 0x9e, 0x43, 0x9d, 0x6e, 0xd8, 0x00, 0x31, 0xe5, 0x6b,
+	0x7a, 0xca, 0xc2, 0x3b, 0x35, 0xc9, 0x74, 0x28, 0x78, 0x3e, 0x9a, 0xaa, 0x54, 0xea, 0x55, 0xf3,
+	0x06, 0xcc, 0x27, 0x1c, 0xa8, 0x1c, 0x7b, 0x04, 0x8b, 0x1b, 0x22, 0xe6, 0xb5, 0xb7, 0x46, 0x0f,
+	0x36, 0x03, 0x1a, 0x59, 0xa1, 0x4a, 0xe1, 0xd7, 0x13, 0x30, 0xb7, 0x83, 0xd9, 0x3a, 0x75, 0x3b,
+	0xde, 0xf9, 0x18, 0x16, 0xf2, 0x16, 0x54, 0x5d, 0xd2, 0xed, 0x7a, 0xcc, 0xf6, 0xda, 0x6a, 0x2d,
+	0x2b, 0x92, 0xb0, 0xd7, 0xe6, 0xab, 0xdc, 0xa3, 0xf8, 0xc4, 0xfb, 0x52, 0x2c, 0x67, 0xd5, 0x52,
+	0x2d, 0xf4, 0x21, 0xcc, 0x9c, 0x10, 0xda, 0x75, 0x98, 0x58, 0xce, 0x6b, 0x6b, 0x77, 0x07, 0xaa,
+	0x32, 0x96, 0xad, 0x6e, 0x0b, 0x3e, 0x4b, 0xf1, 0xf3, 0xdd, 0xd2, 0x73, 0x58, 0x47, 0xac, 0x76,
+	0xcd, 0x12, 0xdf, 0xe6, 0x33, 0x98, 0x91, 0x5c, 0xa8, 0x0c, 0x93, 0xaf, 0xf6, 0x0e, 0xeb, 0x57,
+	0xf8, 0xc7, 0xf1, 0xba, 0x55, 0x2f, 0x21, 0x80, 0x99, 0xe3, 0x75, 0xcb, 0xde, 0x79, 0x55, 0x9f,
+	0x40, 0xb3, 0x50, 0xe6, 0xdf, 0xcd, 0x57, 0x6b, 0xf5, 0x49, 0xf3, 0x11, 0xa0, 0xb8, 0x32, 0xbd,
+	0x19, 0xdb, 0x0e, 0x73, 0x84, 0x07, 0x6a, 0x96, 0xf8, 0xe6, 0x4b, 0xb4, 0xeb, 0x84, 0x2f, 0x88,
+	0xeb, 0xf8, 0x4d, 0xea, 0x04, 0x6e, 0x67, 0x0c, 0x5b, 0xd1, 0x7c, 0x0a, 0x8d, 0xac, 0x50, 0x65,
+	0xc4, 0x02, 0x4c, 0x9f, 0x3b, 0x7e, 0x1f, 0xab, 0x3b, 0x48, 0x36, 0xcc, 0xef, 0x4a, 0xd0, 0x10,
+	0x11, 0x74, 0x44, 0xfa, 0xd4, 0xc5, 0x72, 0xd4, 0xe8, 0xeb, 0xf7, 0x0b, 0x98, 0x0b, 0x85, 0x40,
+	0x3b, 0x26, 0x60, 0xa2, 0x48, 0x80, 0x55, 0x97, 0xcc, 0x56, 0xe2, 0x28, 0x57, 0x02, 0x5a, 0xc2,
+	0x24, 0xb1, 0xd4, 0x35, 0xab, 0x16, 0xc6, 0xcc, 0x44, 0xcb, 0x00, 0xcc, 0xa1, 0xa7, 0x98, 0xd9,
+	0x14, 0x9f, 0x88, 0x45, 0xaf, 0x59, 0x55, 0x49, 0xb1, 0xf0, 0x89, 0xf9, 0x0c, 0x96, 0x72, 0xa6,
+	0xa6, 0xef, 0x64, 0x8a, 0xc3, 0xbe, 0xcf, 0x06, 0x77, 0xb2, 0x6c, 0x99, 0x3b, 0x30, 0xbb, 0x1d,
+	0xba, 0x67, 0xa3, 0xaf, 0xc5, 0x03, 0xa8, 0x49, 0x41, 0xda, 0xff, 0x98, 0x52, 0x42, 0x55, 0x14,
+	0xc8, 0x86, 0xf9, 0x9f, 0x12, 0x5c, 0xff, 0x94, 0x7a, 0x7c, 0x53, 0x9d, 0x8c, 0xee, 0xf6, 0x3a,
+	0x4c, 0x72, 0x4f, 0xc8, 0x53, 0x98, 0x7f, 0x26, 0x0e, 0xe7, 0xc9, 0xe4, 0xe1, 0x8c, 0xee, 0x41,
+	0x8d, 0xf8, 0x6d, 0x3b, 0xea, 0x97, 0x0e, 0x9c, 0x25, 0x7e, 0xdb, 0x1a, 0xb0, 0x44, 0x07, 0xe7,
+	0x74, 0xfc, 0xe0, 0x6c, 0x42, 0x9d, 0x51, 0x27, 0x08, 0x1d, 0x97, 0x79, 0x24, 0xb0, 0x43, 0x86,
+	0x7b, 0xe2, 0xc4, 0x9b, 0x5d, 0x5b, 0x1c, 0x98, 0x79, 0xac, 0xfb, 0x8f, 0x18, 0xee, 0x59, 0xd7,
+	0x59, 0x92, 0xf0, 0xd1, 0x54, 0x65, 0xa6, 0x5e, 0x36, 0x7f, 0x05, 0x75, 0x3d, 0x7b, 0xe5, 0xa8,
+	0x3c, 0xe9, 0x13, 0x3f, 0x58, 0x7a, 0xa9, 0x3e, 0x61, 0x06, 0xb0, 0xb0, 0xed, 0x05, 0xed, 0x97,
+	0x98, 0x9e, 0xe2, 0xa6, 0x13, 0x8e, 0xe1, 0x5c, 0xba, 0x0d, 0xd5, 0x81, 0xbb, 0xc2, 0xc6, 0xc4,
+	0xdd, 0x49, 0x1e, 0x70, 0x11, 0xc1, 0x7c, 0x0f, 0x6e, 0xa4, 0xf4, 0xe9, 0x03, 0xa0, 0xe5, 0x84,
+	0x72, 0xeb, 0x55, 0x2d, 0xf1, 0x6d, 0x7e, 0x53, 0x82, 0x39, 0x79, 0x9e, 0x6e, 0x13, 0x7a, 0xf6,
+	0xbf, 0xdf, 0x72, 0xfc, 0x99, 0x16, 0xb7, 0x27, 0x7a, 0x30, 0x2e, 0xed, 0x85, 0x16, 0xe6, 0x26,
+	0xef, 0x05, 0x87, 0x94, 0x9c, 0x52, 0x1c, 0x86, 0x63, 0x39, 0xe0, 0xa9, 0x10, 0x1a, 0x3b, 0xe0,
+	0x25, 0x61, 0xaf, 0x6d, 0xfe, 0x1c, 0x8c, 0x3c, 0x9d, 0xca, 0x99, 0x2b, 0x30, 0xeb, 0x05, 0x76,
+	0x4f, 0x91, 0xd5, 0xf6, 0x05, 0x2f, 0x62, 0x94, 0x26, 0x1f, 0xbd, 0xee, 0x3b, 0x61, 0x67, 0xcc,
+	0x26, 0x87, 0x42, 0x68, 0xcc, 0x64, 0x49, 0x18, 0x98, 0x9c, 0xd5, 0xf9, 0xa6, 0x26, 0xfb, 0x70,
+	0x27, 0x7d, 0xb7, 0x6e, 0x53, 0xd2, 0xfd, 0xc4, 0x7a, 0x31, 0x96, 0x43, 0xa1, 0x4f, 0x7d, 0x65,
+	0x31, 0xff, 0x34, 0xef, 0xc1, 0x4a, 0xa1, 0x36, 0xb5, 0xec, 0x07, 0x30, 0x2f, 0x59, 0x9a, 0xfd,
+	0xa0, 0xed, 0x8f, 0xe1, 0xa9, 0xfa, 0x2e, 0x2c, 0x24, 0x05, 0x0e, 0xb9, 0x1b, 0xbf, 0x99, 0x80,
+	0xfa, 0x11, 0x66, 0x1b, 0x24, 0x38, 0xf1, 0x4e, 0x47, 0x77, 0xc0, 0x87, 0x50, 0xc6, 0x01, 0xa3,
+	0x1e, 0x96, 0x5b, 0x76, 0x76, 0xed, 0xce, 0x60, 0x58, 0x5a, 0xc9, 0xea, 0x56, 0xc0, 0xe8, 0xa5,
+	0x35, 0x60, 0x37, 0xbe, 0x2e, 0xc1, 0xb4, 0x20, 0x71, 0x27, 0xf2, 0x47, 0x9f, 0xdc, 0xc0, 0xfc,
+	0x13, 0x2d, 0x43, 0x55, 0x5c, 0xa1, 0x76, 0xc8, 0xa8, 0x74, 0xee, 0xee, 0x15, 0xab, 0x22, 0x48,
+	0x47, 0x8c, 0xa2, 0x7b, 0x30, 0x2b, 0xbb, 0xbd, 0x80, 0x3d, 0x5b, 0x13, 0x67, 0xef, 0xf4, 0xee,
+	0x15, 0x0b, 0x04, 0x71, 0x8f, 0xd3, 0xd0, 0x0a, 0xc8, 0x96, 0xdd, 0x22, 0xc4, 0x97, 0x4f, 0xd0,
+	0xdd, 0x2b, 0x96, 0x94, 0xda, 0x24, 0xc4, 0x6f, 0x96, 0xd5, 0x95, 0x6d, 0xce, 0xc3, 0x5c, 0xcc,
+	0x54, 0xb5, 0x44, 0x2e, 0xcc, 0x6f, 0x62, 0x1f, 0x33, 0x3c, 0x2e, 0x3f, 0x21, 0x98, 0x3a, 0xc3,
+	0x97, 0xd2, 0x49, 0x55, 0x4b, 0x7c, 0x9b, 0x37, 0x61, 0x21, 0xa9, 0x44, 0x29, 0xf7, 0x78, 0x92,
+	0x19, 0x32, 0x42, 0xf1, 0x46, 0x3f, 0x64, 0xa4, 0xbb, 0x4b, 0xc8, 0x59, 0x38, 0x16, 0x13, 0x44,
+	0x34, 0x4c, 0xc4, 0xa2, 0xe1, 0x36, 0x18, 0x79, 0xaa, 0x94, 0x21, 0xc7, 0xd0, 0x68, 0x3a, 0xee,
+	0x59, 0xbf, 0x37, 0x4e, 0x3b, 0xcc, 0x27, 0xb0, 0x94, 0x23, 0x75, 0x48, 0xc8, 0xbe, 0x86, 0x7b,
+	0x79, 0x5b, 0x6a, 0x4c, 0xbb, 0x27, 0xd7, 0x2f, 0x0f, 0xc0, 0x1c, 0xa6, 0x52, 0xf9, 0x67, 0x1f,
+	0x10, 0xbf, 0x93, 0x5e, 0x78, 0x2e, 0x0e, 0xc6, 0x70, 0x03, 0x9a, 0x1b, 0x30, 0x9f, 0x90, 0xa7,
+	0x7c, 0xf2, 0x18, 0x90, 0x2f, 0x49, 0x76, 0xd8, 0x21, 0x94, 0xd9, 0x81, 0xd3, 0x1d, 0xdc, 0x77,
+	0x75, 0xd5, 0x73, 0xc4, 0x3b, 0xf6, 0x9d, 0xae, 0x58, 0xb4, 0x1d, 0xcc, 0xf6, 0x82, 0x13, 0xb2,
+	0x3e, 0xbe, 0x44, 0xd4, 0xfc, 0x19, 0x2c, 0xe5, 0x48, 0x55, 0x06, 0xde, 0x01, 0xd0, 0x19, 0xa8,
+	0x5a, 0xba, 0x18, 0x85, 0x9b, 0xb4, 0xe1, 0xf8, 0x6e, 0xdf, 0x77, 0x18, 0xde, 0xe8, 0x60, 0xf7,
+	0x2c, 0xec, 0x77, 0x47, 0x37, 0xe9, 0xff, 0x61, 0x29, 0x47, 0xaa, 0x32, 0xc9, 0x80, 0x8a, 0xab,
+	0x68, 0xca, 0x53, 0x51, 0x9b, 0x2f, 0xdb, 0x0e, 0x66, 0x47, 0x81, 0xd3, 0x0b, 0x3b, 0x64, 0x74,
+	0x68, 0xc4, 0x7c, 0x07, 0xe6, 0x13, 0xf2, 0x86, 0x84, 0xf2, 0xb7, 0x25, 0xb8, 0x9f, 0x17, 0x58,
+	0x63, 0x33, 0x86, 0xe7, 0xc2, 0x1d, 0xc6, 0x7a, 0xb6, 0xbe, 0x96, 0xca, 0xbc, 0xfd, 0x09, 0xf5,
+	0xf9, 0x25, 0x2b, 0xba, 0x9c, 0x3e, 0xeb, 0xa8, 0xf4, 0x4e, 0xf0, 0xae, 0xf7, 0x59, 0xc7, 0x7c,
+	0x08, 0x0f, 0x86, 0x1b, 0xa6, 0x62, 0xfe, 0x4f, 0x25, 0x58, 0xd8, 0xc1, 0xcc, 0x72, 0x2e, 0x36,
+	0x3a, 0x4e, 0x70, 0x3a, 0x0e, 0x90, 0xe3, 0x3e, 0x5c, 0x3d, 0xa1, 0xa4, 0x6b, 0x27, 0x90, 0x8e,
+	0xaa, 0x55, 0xe3, 0xc4, 0xe8, 0xb5, 0xbc, 0x02, 0xb3, 0x8c, 0xd8, 0x89, 0xf7, 0x76, 0xd5, 0x02,
+	0x46, 0x06, 0x0c, 0xe6, 0xdf, 0xa7, 0xe0, 0x46, 0xca, 0x30, 0xb5, 0x10, 0xbb, 0x30, 0x4b, 0x9d,
+	0x0b, 0xdb, 0x95, 0xe4, 0x46, 0x49, 0xdc, 0x53, 0x6f, 0xc7, 0x12, 0xd8, 0xec, 0x98, 0xd5, 0x88,
+	0x64, 0x01, 0x8d, 0x7a, 0x8d, 0xef, 0x26, 0xa1, 0x1a, 0xf5, 0xa0, 0x45, 0x28, 0xb7, 0x7c, 0xd2,
+	0xe2, 0x4f, 0x16, 0x19, 0x62, 0x33, 0xbc, 0xb9, 0xd7, 0x8e, 0x00, 0xa2, 0x09, 0x0d, 0x10, 0xa1,
+	0x65, 0xa8, 0x04, 0xf8, 0xc2, 0x16, 0xa9, 0xb0, 0x30, 0xbe, 0x39, 0xd1, 0x28, 0x59, 0xe5, 0x00,
+	0x5f, 0x1c, 0x3a, 0x8c, 0xa7, 0x5b, 0x15, 0x9e, 0x2f, 0x88, 0xee, 0x29, 0xdd, 0x4d, 0xfc, 0xb6,
+	0xe8, 0x3e, 0x80, 0x2a, 0xe9, 0x61, 0xea, 0xf0, 0x47, 0xb8, 0xc8, 0x17, 0xae, 0xad, 0x7d, 0xf0,
+	0x86, 0x13, 0x58, 0x3d, 0x18, 0x0c, 0xb4, 0xb4, 0x0c, 0xee, 0x73, 0xee, 0x13, 0x2d, 0x54, 0x42,
+	0x2e, 0x35, 0xea, 0x5c, 0x44, 0xfc, 0x3c, 0x96, 0xb8, 0x51, 0x5d, 0xd2, 0xc6, 0x22, 0x07, 0x99,
+	0x16, 0x06, 0xbd, 0x24, 0x6d, 0x2c, 0x20, 0x17, 0x7c, 0x21, 0xbb, 0x2a, 0xb2, 0x2b, 0xc0, 0x17,
+	0xa2, 0xeb, 0x01, 0x5c, 0x1b, 0xcc, 0xd4, 0x6e, 0x5d, 0xf2, 0x13, 0xa1, 0x2a, 0xf3, 0x4b, 0x35,
+	0xd7, 0x26, 0xa7, 0x71, 0xae, 0xc1, 0x84, 0x15, 0x17, 0x48, 0x2e, 0x35, 0x65, 0xc1, 0x65, 0x7a,
+	0x50, 0xd5, 0xe6, 0xcc, 0x42, 0xf9, 0x93, 0xfd, 0xe7, 0xfb, 0x07, 0x9f, 0xee, 0xd7, 0xaf, 0xa0,
+	0x2a, 0x4c, 0xaf, 0x6f, 0x6e, 0x6e, 0x6d, 0x4a, 0xc4, 0x60, 0xe3, 0xe0, 0x70, 0x6f, 0x6b, 0x53,
+	0x22, 0x06, 0x9b, 0x5b, 0x2f, 0xb6, 0x8e, 0xb7, 0x36, 0xeb, 0x93, 0xa8, 0x06, 0x95, 0x97, 0x07,
+	0x9b, 0x7b, 0xdb, 0xbc, 0x6b, 0x8a, 0x77, 0x59, 0x5b, 0xfb, 0xeb, 0x2f, 0xb7, 0x36, 0xeb, 0xd3,
+	0xa8, 0x0e, 0xb5, 0xe3, 0xcf, 0x0e, 0xb7, 0xec, 0x8d, 0xdd, 0xf5, 0xfd, 0x9d, 0xad, 0xcd, 0xfa,
+	0x8c, 0xf9, 0x1b, 0x68, 0x1c, 0x61, 0x87, 0xba, 0x9d, 0x6d, 0xcf, 0xc7, 0x61, 0xf3, 0x92, 0x1f,
+	0xa6, 0xa3, 0xc7, 0xf6, 0x02, 0x4c, 0xbf, 0xee, 0x63, 0x95, 0x2d, 0x54, 0x2d, 0xd9, 0x18, 0xe4,
+	0x92, 0x93, 0x51, 0x2e, 0x69, 0x7e, 0x00, 0x4b, 0x39, 0xda, 0x75, 0x7a, 0x7b, 0xc2, 0xc9, 0x22,
+	0x74, 0x6b, 0x96, 0x6c, 0x98, 0x7f, 0x2b, 0xc1, 0xad, 0xc4, 0x98, 0x0d, 0x12, 0x30, 0x1c, 0xb0,
+	0x1f, 0xcd, 0x68, 0xf4, 0x0e, 0xd4, 0xdd, 0x4e, 0x3f, 0x38, 0xc3, 0x3c, 0xd1, 0x95, 0xb6, 0x2a,
+	0xb4, 0xef, 0xba, 0xa2, 0x47, 0xc7, 0xc6, 0x25, 0xdc, 0xce, 0xb7, 0x55, 0x4d, 0xb1, 0x01, 0xe5,
+	0xae, 0xc3, 0xdc, 0x4e, 0x34, 0xc9, 0x41, 0x13, 0x2d, 0x03, 0x88, 0x4f, 0x3b, 0x76, 0x49, 0x57,
+	0x05, 0x65, 0xd3, 0x61, 0x0e, 0xba, 0x0b, 0x35, 0x1c, 0xb4, 0x6d, 0x72, 0x62, 0x0b, 0x9a, 0x42,
+	0x21, 0x01, 0x07, 0xed, 0x83, 0x93, 0x97, 0x9c, 0x62, 0xfe, 0xa1, 0x04, 0x33, 0x12, 0xc3, 0x1b,
+	0x3c, 0xd7, 0x4b, 0xd1, 0x73, 0x9d, 0x6f, 0x55, 0x71, 0x9b, 0xca, 0x99, 0x8a, 0x6f, 0xf4, 0x53,
+	0x58, 0x8a, 0xce, 0x49, 0x42, 0xbd, 0xaf, 0x44, 0xf4, 0xd9, 0x1d, 0xec, 0xb4, 0x31, 0x55, 0x07,
+	0xcf, 0xe2, 0xe0, 0xdc, 0x8c, 0xfa, 0x77, 0x45, 0x37, 0x7a, 0x0b, 0xae, 0x75, 0x3d, 0x4a, 0x09,
+	0xb5, 0x29, 0x3e, 0xe9, 0x3a, 0xbd, 0xb0, 0x31, 0x25, 0x5e, 0x7c, 0x57, 0x25, 0xd5, 0x92, 0x44,
+	0xf3, 0x8f, 0x25, 0xb8, 0x29, 0xf0, 0x93, 0xdd, 0xe3, 0xe3, 0xc3, 0x71, 0x21, 0xb4, 0x0f, 0x13,
+	0x08, 0x6d, 0x16, 0xe4, 0x1c, 0x20, 0xb6, 0x31, 0x08, 0x76, 0x32, 0x01, 0xc1, 0x9a, 0x4b, 0xb0,
+	0x98, 0xb1, 0x4a, 0x2d, 0xe0, 0x67, 0xb0, 0xbc, 0x83, 0xd9, 0x41, 0xeb, 0xd7, 0xd8, 0x65, 0x9b,
+	0x1e, 0xc5, 0xee, 0xf8, 0x90, 0xf6, 0xff, 0x83, 0x3b, 0x45, 0xa2, 0x87, 0x20, 0xee, 0x7f, 0x29,
+	0xc1, 0xc2, 0x86, 0x4f, 0x02, 0xcc, 0xaf, 0xa9, 0x43, 0x42, 0xfc, 0x71, 0x38, 0x70, 0xaa, 0xc7,
+	0xd3, 0x85, 0x54, 0x66, 0x2f, 0x2d, 0x13, 0x2a, 0x44, 0x7f, 0xcc, 0xd1, 0x93, 0xc3, 0x1c, 0x6d,
+	0x2e, 0xc2, 0x8d, 0x94, 0x85, 0xca, 0x99, 0xff, 0x2c, 0xc1, 0xed, 0x44, 0xcf, 0x5e, 0xc0, 0x30,
+	0x0d, 0x9c, 0x1f, 0x71, 0x0e, 0xb9, 0x90, 0xc6, 0xe4, 0x0f, 0x80, 0x34, 0x56, 0x60, 0xb9, 0x60,
+	0x0a, 0x1a, 0x28, 0xe7, 0xfe, 0x38, 0x1f, 0x37, 0x50, 0x9e, 0x15, 0xaa, 0x14, 0x7e, 0xc9, 0x15,
+	0x06, 0xe2, 0xe0, 0x1c, 0x9b, 0x42, 0x71, 0x51, 0x62, 0xdf, 0x61, 0xde, 0x39, 0x96, 0xb7, 0xb3,
+	0x7a, 0x9c, 0x0c, 0x88, 0xfc, 0xae, 0x92, 0x56, 0xa5, 0x35, 0x2b, 0xab, 0x7e, 0x5f, 0xe2, 0x39,
+	0x56, 0xcf, 0xf7, 0xdc, 0xf1, 0xd6, 0x0c, 0xd0, 0xbb, 0x30, 0x23, 0x17, 0x65, 0x08, 0x12, 0xa5,
+	0x38, 0xcc, 0x65, 0xb8, 0x95, 0x6b, 0x83, 0xb4, 0x71, 0xed, 0xaf, 0xcb, 0xa2, 0x74, 0x39, 0x28,
+	0x76, 0xc9, 0x3a, 0x2f, 0xfa, 0x1c, 0xea, 0xe9, 0xb2, 0x2b, 0x5a, 0xc9, 0x2a, 0x49, 0x54, 0x79,
+	0x8d, 0xbb, 0xc5, 0x0c, 0xca, 0x21, 0x33, 0xff, 0xfe, 0xf6, 0xd1, 0x44, 0x65, 0x02, 0x7d, 0x31,
+	0x28, 0x97, 0xc6, 0x6a, 0xa9, 0x28, 0x3e, 0x3c, 0xb7, 0x78, 0x6b, 0xdc, 0x1b, 0xc2, 0x91, 0xd0,
+	0x50, 0x42, 0xcf, 0x01, 0x74, 0x71, 0x14, 0x2d, 0x25, 0x07, 0xc6, 0x8a, 0xb4, 0x86, 0x91, 0xd7,
+	0x95, 0x12, 0xf6, 0x29, 0x5c, 0x4b, 0xd6, 0x36, 0xd1, 0x72, 0xf4, 0x02, 0xcb, 0xab, 0xb5, 0x1a,
+	0x77, 0x8a, 0xba, 0xb3, 0x82, 0x93, 0x85, 0x46, 0x2d, 0x38, 0xb7, 0xa6, 0xa9, 0x05, 0xe7, 0xd7,
+	0x27, 0x23, 0xc1, 0x2e, 0xa0, 0x6c, 0x81, 0x10, 0x45, 0xfe, 0x2b, 0xac, 0x57, 0x1a, 0xe6, 0x30,
+	0x96, 0x94, 0x92, 0x7d, 0x98, 0x8d, 0x55, 0xc9, 0x50, 0xe4, 0xc9, 0x6c, 0xed, 0xd1, 0xb8, 0x95,
+	0xdb, 0x97, 0x92, 0xf7, 0x39, 0xd4, 0xd3, 0x79, 0x88, 0x0e, 0xba, 0x82, 0xc2, 0x9b, 0x0e, 0xba,
+	0xc2, 0x22, 0xda, 0x40, 0xfc, 0x4b, 0x00, 0x5d, 0x44, 0xd2, 0x21, 0x91, 0xa9, 0x62, 0xe9, 0x90,
+	0xc8, 0xd6, 0x9c, 0x06, 0xc2, 0x9e, 0x0a, 0x6b, 0xd3, 0x45, 0x21, 0x6d, 0x6d, 0x41, 0x0d, 0x4a,
+	0x5b, 0x5b, 0x54, 0x4f, 0x8a, 0x6f, 0x91, 0x4c, 0x95, 0x45, 0x6f, 0x91, 0xa2, 0xda, 0x92, 0xde,
+	0x22, 0x85, 0x25, 0x9a, 0xc8, 0x1f, 0x3f, 0x81, 0xa9, 0xed, 0xd0, 0x3d, 0x43, 0xf3, 0xd1, 0x10,
+	0x5d, 0xa0, 0x31, 0x16, 0x92, 0xc4, 0xd4, 0xd0, 0x2d, 0xa8, 0x0c, 0xea, 0x0b, 0x28, 0xaa, 0x1e,
+	0xa4, 0xea, 0x2d, 0x46, 0x23, 0xdb, 0x91, 0x12, 0x73, 0x0c, 0x57, 0x13, 0xc0, 0x3e, 0xba, 0x1d,
+	0x69, 0xcd, 0xa9, 0x2f, 0x18, 0xcb, 0x05, 0xbd, 0x29, 0xcf, 0x3d, 0x07, 0xd0, 0x80, 0xbb, 0x5e,
+	0xe7, 0x4c, 0x51, 0x40, 0xaf, 0x73, 0x0e, 0x3e, 0x1f, 0xdb, 0x48, 0x59, 0xcc, 0x5c, 0x6f, 0xa4,
+	0x42, 0x0c, 0x5f, 0x6f, 0xa4, 0x62, 0xc8, 0x3d, 0xb2, 0x58, 0x28, 0x49, 0xa3, 0xdc, 0x71, 0x25,
+	0x05, 0xa8, 0x7b, 0x5c, 0x49, 0x11, 0x48, 0x1e, 0x29, 0xa1, 0xd9, 0xe2, 0xb5, 0x42, 0xa7, 0xd1,
+	0xc3, 0xa2, 0x3d, 0x94, 0x04, 0xcb, 0x8d, 0xb7, 0xbf, 0x97, 0x2f, 0xe5, 0xbd, 0x23, 0xa8, 0xc5,
+	0xd1, 0x69, 0x74, 0x2b, 0x29, 0x20, 0x01, 0xe3, 0x19, 0xb7, 0xf3, 0x3b, 0x93, 0xd3, 0x78, 0x5a,
+	0x42, 0xbf, 0x05, 0xa3, 0x18, 0xa0, 0x43, 0xef, 0x0c, 0xb3, 0x31, 0xa9, 0xf0, 0xdd, 0x37, 0x61,
+	0x4d, 0xce, 0xe8, 0x51, 0x09, 0xed, 0x42, 0x35, 0x02, 0x8d, 0x51, 0xa3, 0x08, 0xf2, 0x36, 0x96,
+	0x72, 0x7a, 0x52, 0xde, 0xf9, 0x18, 0x6a, 0x71, 0x10, 0x58, 0x7b, 0x27, 0x07, 0x7f, 0xd6, 0xde,
+	0xc9, 0xc5, 0x8d, 0xe3, 0x47, 0xb2, 0x86, 0x11, 0x63, 0x47, 0x72, 0x06, 0xab, 0x8c, 0x1d, 0xc9,
+	0x59, 0xdc, 0x31, 0x0a, 0x9a, 0x96, 0xf8, 0xff, 0x20, 0x89, 0xfd, 0xa1, 0xf8, 0x0f, 0x00, 0xb9,
+	0x60, 0xa3, 0x3e, 0x85, 0x0a, 0x81, 0xc3, 0xd8, 0x7a, 0x7e, 0x01, 0x73, 0x19, 0x30, 0x4f, 0xeb,
+	0x28, 0x42, 0x0f, 0xb5, 0x8e, 0x42, 0x24, 0x30, 0x9a, 0x45, 0x13, 0xca, 0xea, 0xaf, 0x21, 0x74,
+	0x33, 0x1a, 0x95, 0xf8, 0x25, 0xc9, 0x58, 0xcc, 0xd0, 0x53, 0x9e, 0x3d, 0x84, 0xd9, 0x18, 0xd2,
+	0x87, 0xe2, 0x77, 0x44, 0x0a, 0xc1, 0xd3, 0x9e, 0xcd, 0x81, 0x06, 0x63, 0xf3, 0xfe, 0x1d, 0xcf,
+	0x04, 0x86, 0xe0, 0x6e, 0xe8, 0xbd, 0x61, 0xf1, 0x99, 0x56, 0xfa, 0xf8, 0xcd, 0x98, 0x53, 0xb3,
+	0xfa, 0x25, 0x5c, 0x4d, 0x60, 0x48, 0xfa, 0x04, 0xce, 0x03, 0xfa, 0xf4, 0x09, 0x9c, 0x0b, 0x3c,
+	0xc5, 0xe6, 0x76, 0x06, 0x0b, 0x79, 0x39, 0x3f, 0xba, 0xaf, 0x77, 0x45, 0x21, 0x7a, 0x61, 0x3c,
+	0x18, 0xce, 0x94, 0x51, 0xd6, 0x82, 0xb9, 0x0c, 0x80, 0xa2, 0x03, 0xa8, 0x08, 0xd9, 0xd1, 0x01,
+	0x54, 0x88, 0xbe, 0xc4, 0x74, 0x60, 0x40, 0xd9, 0x6a, 0x09, 0x8a, 0x3d, 0x48, 0x0b, 0x8a, 0x36,
+	0xfa, 0x88, 0x1e, 0x52, 0x6c, 0xd1, 0x87, 0x4b, 0x0b, 0xe6, 0x32, 0x05, 0x12, 0x3d, 0x95, 0xa2,
+	0x8a, 0x8c, 0x9e, 0x4a, 0x61, 0x75, 0x25, 0x36, 0x95, 0x57, 0x70, 0x3d, 0x95, 0xe9, 0xa3, 0x3b,
+	0x89, 0x57, 0x43, 0x06, 0x98, 0x30, 0x56, 0x0a, 0xfb, 0x53, 0xf1, 0x44, 0xe0, 0x66, 0x7e, 0x3e,
+	0x8f, 0xde, 0x8a, 0x85, 0x4e, 0x31, 0x94, 0x60, 0x3c, 0xfc, 0x3e, 0xb6, 0xd4, 0xd6, 0x3e, 0x86,
+	0xab, 0x89, 0x54, 0x54, 0x07, 0x70, 0x1e, 0x40, 0xa0, 0x03, 0x38, 0x3f, 0x39, 0x1f, 0x4c, 0xc3,
+	0x4f, 0x65, 0xef, 0x83, 0x04, 0x17, 0x3d, 0xc8, 0x1d, 0x9f, 0x4a, 0xe1, 0x8d, 0xb7, 0xbe, 0x87,
+	0x2b, 0xfb, 0xee, 0x4d, 0x27, 0xb6, 0xf1, 0x64, 0x2b, 0x37, 0x8f, 0x8e, 0x27, 0x5b, 0x05, 0x39,
+	0x71, 0x42, 0x7c, 0x32, 0x43, 0x8d, 0x8b, 0xcf, 0xcd, 0x9a, 0xe3, 0xe2, 0x0b, 0x92, 0xdb, 0x81,
+	0xf8, 0x13, 0x98, 0xcf, 0xc9, 0x2f, 0x51, 0x2c, 0xee, 0x8b, 0x12, 0x60, 0xe3, 0xfe, 0x50, 0x9e,
+	0xa4, 0x9e, 0xe6, 0xd3, 0x57, 0x9c, 0xdb, 0x77, 0x5a, 0xab, 0x2e, 0xe9, 0x3e, 0x91, 0x9f, 0xef,
+	0x13, 0x7a, 0xfa, 0x44, 0xca, 0x78, 0x22, 0x7e, 0x42, 0x7e, 0x72, 0x4a, 0x54, 0xbb, 0xd7, 0x6a,
+	0xcd, 0x08, 0xd2, 0xb3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x92, 0xb6, 0xfd, 0x86, 0xc9, 0x2c,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/go/gitalypb/shared.pb.go b/proto/go/gitalypb/shared.pb.go
index 1504b81166..cd5daac5d3 100644
--- a/proto/go/gitalypb/shared.pb.go
+++ b/proto/go/gitalypb/shared.pb.go
@@ -140,6 +140,34 @@ func (OperationMsg_Scope) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_d8a4e87e678c5ced, []int{0, 1}
 }
 
+type TransactionStep_TransactionStep int32
+
+const (
+	TransactionStep_PRECOMMIT TransactionStep_TransactionStep = 0
+	TransactionStep_COMMIT    TransactionStep_TransactionStep = 1
+	TransactionStep_ROLLBACK  TransactionStep_TransactionStep = 2
+)
+
+var TransactionStep_TransactionStep_name = map[int32]string{
+	0: "PRECOMMIT",
+	1: "COMMIT",
+	2: "ROLLBACK",
+}
+
+var TransactionStep_TransactionStep_value = map[string]int32{
+	"PRECOMMIT": 0,
+	"COMMIT":    1,
+	"ROLLBACK":  2,
+}
+
+func (x TransactionStep_TransactionStep) String() string {
+	return proto.EnumName(TransactionStep_TransactionStep_name, int32(x))
+}
+
+func (TransactionStep_TransactionStep) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_d8a4e87e678c5ced, []int{1, 0}
+}
+
 type OperationMsg struct {
 	Op OperationMsg_Operation `protobuf:"varint,1,opt,name=op,proto3,enum=gitaly.OperationMsg_Operation" json:"op,omitempty"`
 	// Scope level indicates what level an RPC interacts with a server:
@@ -191,6 +219,53 @@ func (m *OperationMsg) GetScopeLevel() OperationMsg_Scope {
 	return OperationMsg_REPOSITORY
 }
 
+type TransactionStep struct {
+	Id                   string                          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Step                 TransactionStep_TransactionStep `protobuf:"varint,2,opt,name=step,proto3,enum=gitaly.TransactionStep_TransactionStep" json:"step,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
+	XXX_unrecognized     []byte                          `json:"-"`
+	XXX_sizecache        int32                           `json:"-"`
+}
+
+func (m *TransactionStep) Reset()         { *m = TransactionStep{} }
+func (m *TransactionStep) String() string { return proto.CompactTextString(m) }
+func (*TransactionStep) ProtoMessage()    {}
+func (*TransactionStep) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d8a4e87e678c5ced, []int{1}
+}
+
+func (m *TransactionStep) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TransactionStep.Unmarshal(m, b)
+}
+func (m *TransactionStep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TransactionStep.Marshal(b, m, deterministic)
+}
+func (m *TransactionStep) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TransactionStep.Merge(m, src)
+}
+func (m *TransactionStep) XXX_Size() int {
+	return xxx_messageInfo_TransactionStep.Size(m)
+}
+func (m *TransactionStep) XXX_DiscardUnknown() {
+	xxx_messageInfo_TransactionStep.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransactionStep proto.InternalMessageInfo
+
+func (m *TransactionStep) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *TransactionStep) GetStep() TransactionStep_TransactionStep {
+	if m != nil {
+		return m.Step
+	}
+	return TransactionStep_PRECOMMIT
+}
+
 type Repository struct {
 	StorageName  string `protobuf:"bytes,2,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
 	RelativePath string `protobuf:"bytes,3,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
@@ -219,7 +294,7 @@ func (m *Repository) Reset()         { *m = Repository{} }
 func (m *Repository) String() string { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()    {}
 func (*Repository) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{1}
+	return fileDescriptor_d8a4e87e678c5ced, []int{2}
 }
 
 func (m *Repository) XXX_Unmarshal(b []byte) error {
@@ -304,7 +379,7 @@ func (m *GitCommit) Reset()         { *m = GitCommit{} }
 func (m *GitCommit) String() string { return proto.CompactTextString(m) }
 func (*GitCommit) ProtoMessage()    {}
 func (*GitCommit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{2}
+	return fileDescriptor_d8a4e87e678c5ced, []int{3}
 }
 
 func (m *GitCommit) XXX_Unmarshal(b []byte) error {
@@ -395,7 +470,7 @@ func (m *CommitAuthor) Reset()         { *m = CommitAuthor{} }
 func (m *CommitAuthor) String() string { return proto.CompactTextString(m) }
 func (*CommitAuthor) ProtoMessage()    {}
 func (*CommitAuthor) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{3}
+	return fileDescriptor_d8a4e87e678c5ced, []int{4}
 }
 
 func (m *CommitAuthor) XXX_Unmarshal(b []byte) error {
@@ -455,7 +530,7 @@ func (m *ExitStatus) Reset()         { *m = ExitStatus{} }
 func (m *ExitStatus) String() string { return proto.CompactTextString(m) }
 func (*ExitStatus) ProtoMessage()    {}
 func (*ExitStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{4}
+	return fileDescriptor_d8a4e87e678c5ced, []int{5}
 }
 
 func (m *ExitStatus) XXX_Unmarshal(b []byte) error {
@@ -496,7 +571,7 @@ func (m *Branch) Reset()         { *m = Branch{} }
 func (m *Branch) String() string { return proto.CompactTextString(m) }
 func (*Branch) ProtoMessage()    {}
 func (*Branch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{5}
+	return fileDescriptor_d8a4e87e678c5ced, []int{6}
 }
 
 func (m *Branch) XXX_Unmarshal(b []byte) error {
@@ -551,7 +626,7 @@ func (m *Tag) Reset()         { *m = Tag{} }
 func (m *Tag) String() string { return proto.CompactTextString(m) }
 func (*Tag) ProtoMessage()    {}
 func (*Tag) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{6}
+	return fileDescriptor_d8a4e87e678c5ced, []int{7}
 }
 
 func (m *Tag) XXX_Unmarshal(b []byte) error {
@@ -635,7 +710,7 @@ func (m *User) Reset()         { *m = User{} }
 func (m *User) String() string { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()    {}
 func (*User) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{7}
+	return fileDescriptor_d8a4e87e678c5ced, []int{8}
 }
 
 func (m *User) XXX_Unmarshal(b []byte) error {
@@ -695,7 +770,7 @@ func (m *ObjectPool) Reset()         { *m = ObjectPool{} }
 func (m *ObjectPool) String() string { return proto.CompactTextString(m) }
 func (*ObjectPool) ProtoMessage()    {}
 func (*ObjectPool) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d8a4e87e678c5ced, []int{8}
+	return fileDescriptor_d8a4e87e678c5ced, []int{9}
 }
 
 func (m *ObjectPool) XXX_Unmarshal(b []byte) error {
@@ -773,7 +848,9 @@ func init() {
 	proto.RegisterEnum("gitaly.SignatureType", SignatureType_name, SignatureType_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Operation", OperationMsg_Operation_name, OperationMsg_Operation_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Scope", OperationMsg_Scope_name, OperationMsg_Scope_value)
+	proto.RegisterEnum("gitaly.TransactionStep_TransactionStep", TransactionStep_TransactionStep_name, TransactionStep_TransactionStep_value)
 	proto.RegisterType((*OperationMsg)(nil), "gitaly.OperationMsg")
+	proto.RegisterType((*TransactionStep)(nil), "gitaly.TransactionStep")
 	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
 	proto.RegisterType((*GitCommit)(nil), "gitaly.GitCommit")
 	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
@@ -792,70 +869,74 @@ func init() {
 func init() { proto.RegisterFile("shared.proto", fileDescriptor_d8a4e87e678c5ced) }
 
 var fileDescriptor_d8a4e87e678c5ced = []byte{
-	// 1037 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
-	0x14, 0x6e, 0x1c, 0xe7, 0xef, 0x24, 0x2d, 0xde, 0xa1, 0x2b, 0x59, 0x45, 0xdd, 0x2d, 0x46, 0x42,
-	0xd5, 0xaa, 0xa4, 0x55, 0x57, 0x20, 0xb6, 0x20, 0xa1, 0xb4, 0x64, 0xab, 0x2e, 0x6d, 0x1c, 0x4d,
-	0x5c, 0xfe, 0x6e, 0xac, 0x49, 0x3c, 0x3b, 0x19, 0xe4, 0x64, 0x2c, 0x7b, 0x52, 0xd1, 0x5e, 0x22,
-	0xae, 0xb8, 0xe2, 0x25, 0xb8, 0xe5, 0x31, 0x10, 0xaf, 0xc1, 0xc2, 0x7b, 0x80, 0x66, 0xc6, 0x4e,
-	0xdd, 0x1f, 0x60, 0xf7, 0x6e, 0xce, 0xf1, 0x77, 0xbe, 0x39, 0xf3, 0xcd, 0x77, 0x26, 0x81, 0x4e,
-	0x36, 0x25, 0x29, 0x8d, 0xba, 0x49, 0x2a, 0xa4, 0x40, 0x75, 0xc6, 0x25, 0x89, 0x2f, 0x37, 0x1e,
-	0x33, 0x21, 0x58, 0x4c, 0x77, 0x75, 0x76, 0xbc, 0x78, 0xb9, 0x2b, 0xf9, 0x8c, 0x66, 0x92, 0xcc,
-	0x12, 0x03, 0xdc, 0xd8, 0xba, 0x0d, 0x88, 0x68, 0x36, 0x49, 0x79, 0x22, 0x45, 0x6a, 0x10, 0xde,
-	0xab, 0x0a, 0x74, 0xfc, 0x84, 0xa6, 0x44, 0x72, 0x31, 0x3f, 0xcb, 0x18, 0xea, 0x82, 0x25, 0x12,
-	0xb7, 0xb2, 0x55, 0xd9, 0x5e, 0xdb, 0x7f, 0xd4, 0x35, 0x1b, 0x75, 0xcb, 0x88, 0xeb, 0x00, 0x5b,
-	0x22, 0x41, 0x9f, 0x40, 0x3b, 0x9b, 0x88, 0x84, 0x86, 0x31, 0xbd, 0xa0, 0xb1, 0x6b, 0xe9, 0xc2,
-	0x8d, 0x7b, 0x0b, 0x47, 0x0a, 0x87, 0x41, 0xc3, 0x4f, 0x15, 0xda, 0x7b, 0x0a, 0xad, 0x25, 0x02,
-	0xb5, 0xa1, 0x71, 0x3e, 0xf8, 0x62, 0xe0, 0x7f, 0x35, 0x70, 0x56, 0x54, 0x70, 0x76, 0x1e, 0xf4,
-	0x02, 0x1f, 0x3b, 0x15, 0xd4, 0x81, 0x66, 0xef, 0xe8, 0xa8, 0x3f, 0x1a, 0xf9, 0xd8, 0xb1, 0xbc,
-	0x3d, 0xa8, 0x69, 0x26, 0xb4, 0x06, 0x80, 0xfb, 0x43, 0x7f, 0x74, 0x12, 0xf8, 0xf8, 0x1b, 0x67,
-	0x05, 0x01, 0xd4, 0x47, 0x7d, 0xfc, 0x65, 0x5f, 0x95, 0xb4, 0xa1, 0x31, 0x0a, 0x7c, 0xdc, 0x3b,
-	0xee, 0x3b, 0x96, 0xf7, 0xab, 0x05, 0x80, 0x69, 0x22, 0x32, 0x2e, 0x45, 0x7a, 0x89, 0xde, 0x85,
-	0x4e, 0x26, 0x45, 0x4a, 0x18, 0x0d, 0xe7, 0x64, 0x46, 0x75, 0xcf, 0x2d, 0xdc, 0xce, 0x73, 0x03,
-	0x32, 0xa3, 0xe8, 0x3d, 0x58, 0x4d, 0x69, 0x4c, 0x24, 0xbf, 0xa0, 0x61, 0x42, 0xe4, 0xd4, 0xad,
-	0x6a, 0x4c, 0xa7, 0x48, 0x0e, 0x89, 0x9c, 0xa2, 0x3d, 0x58, 0x67, 0x5c, 0x86, 0x62, 0xfc, 0x1d,
-	0x9d, 0xc8, 0x30, 0xe2, 0x29, 0x9d, 0x28, 0x7e, 0xd7, 0xd6, 0x58, 0xc4, 0xb8, 0xf4, 0xf5, 0xa7,
-	0xcf, 0x8b, 0x2f, 0xe8, 0x18, 0xb6, 0x54, 0x05, 0x89, 0x25, 0x4d, 0xe7, 0x44, 0xd2, 0xdb, 0xb5,
-	0x9c, 0x66, 0x6e, 0x6d, 0xab, 0xba, 0xdd, 0xc2, 0x9b, 0x8c, 0xcb, 0x5e, 0x01, 0xbb, 0x49, 0xc3,
-	0x69, 0xa6, 0xfa, 0x63, 0x71, 0x98, 0x2e, 0xcf, 0xe4, 0xd6, 0x4d, 0x7f, 0x2c, 0x2e, 0x9d, 0xf3,
-	0x7d, 0x78, 0x8b, 0xc5, 0x61, 0x92, 0x0a, 0xbd, 0x87, 0x3e, 0x46, 0x53, 0xc3, 0x56, 0x59, 0x3c,
-	0x34, 0x59, 0x75, 0x8e, 0x17, 0x76, 0xb3, 0xe2, 0x58, 0x2f, 0xec, 0x66, 0xc3, 0x69, 0x62, 0x5b,
-	0xc1, 0xbc, 0x5f, 0x2c, 0x68, 0x1d, 0x73, 0x79, 0x24, 0x66, 0x33, 0x2e, 0xd1, 0x1a, 0x58, 0x3c,
-	0xd2, 0x96, 0x68, 0x61, 0x8b, 0x47, 0xc8, 0x85, 0x46, 0xb6, 0xd0, 0x2d, 0x69, 0xe9, 0x3a, 0xb8,
-	0x08, 0x11, 0x02, 0x7b, 0x2c, 0xa2, 0x4b, 0xad, 0x56, 0x07, 0xeb, 0x35, 0xda, 0x81, 0x3a, 0x59,
-	0xc8, 0xa9, 0x48, 0xb5, 0x2e, 0xed, 0xfd, 0xf5, 0xc2, 0x1b, 0x86, 0xbd, 0xa7, 0xbf, 0xe1, 0x1c,
-	0x83, 0xf6, 0xa1, 0x35, 0xd1, 0x79, 0x49, 0x53, 0xb7, 0xf6, 0x1f, 0x05, 0xd7, 0x30, 0xb4, 0x09,
-	0x90, 0x90, 0x94, 0xce, 0x65, 0xc8, 0xa3, 0xcc, 0xad, 0x6b, 0xfd, 0x5a, 0x26, 0x73, 0x12, 0x65,
-	0xe8, 0x1d, 0x68, 0xa9, 0x46, 0xc2, 0x8c, 0x5f, 0x51, 0xb7, 0xb1, 0x55, 0xd9, 0xae, 0xe2, 0xa6,
-	0x4a, 0x8c, 0xf8, 0x15, 0x45, 0x9f, 0xc2, 0x5a, 0xc6, 0xd9, 0x9c, 0xc8, 0x45, 0x4a, 0x43, 0x79,
-	0x99, 0x50, 0x2d, 0xd1, 0xda, 0xfe, 0xc3, 0x62, 0xd3, 0x51, 0xf1, 0x35, 0xb8, 0x4c, 0x28, 0x5e,
-	0xcd, 0xca, 0xa1, 0xf7, 0x63, 0x05, 0x3a, 0xe5, 0xae, 0x94, 0x00, 0xda, 0x52, 0x15, 0x23, 0x80,
-	0x5a, 0xa3, 0x75, 0xa8, 0xd1, 0x19, 0xe1, 0x71, 0x2e, 0x96, 0x09, 0x50, 0x17, 0xec, 0x88, 0x48,
-	0xaa, 0xa5, 0x6a, 0xab, 0x81, 0xd1, 0x93, 0xda, 0x2d, 0x26, 0xb5, 0x1b, 0x14, 0xa3, 0x8c, 0x35,
-	0x0e, 0x6d, 0x40, 0x53, 0x4d, 0xf7, 0x95, 0x98, 0x53, 0x2d, 0x64, 0x07, 0x2f, 0x63, 0xcf, 0x03,
-	0xe8, 0x7f, 0xcf, 0xe5, 0x48, 0x12, 0xb9, 0xc8, 0xd4, 0x7e, 0x17, 0x24, 0x5e, 0x98, 0x26, 0x6a,
-	0xd8, 0x04, 0x5e, 0x00, 0xf5, 0xc3, 0x94, 0xcc, 0x27, 0xd3, 0x7b, 0x7b, 0xfc, 0x08, 0x56, 0x25,
-	0x49, 0x19, 0x95, 0xa1, 0x91, 0x55, 0xf7, 0xda, 0xde, 0x7f, 0x50, 0xa8, 0xb0, 0x34, 0x03, 0xee,
-	0x18, 0x9c, 0x89, 0xbc, 0x9f, 0x2c, 0xa8, 0x06, 0x84, 0xdd, 0xcb, 0x69, 0x6c, 0x63, 0x2d, 0x6d,
-	0x73, 0x67, 0x8f, 0xea, 0x6b, 0xed, 0xa1, 0xec, 0x36, 0xa3, 0x59, 0x46, 0x58, 0x71, 0xf0, 0x22,
-	0x54, 0x83, 0x9c, 0x2f, 0xcd, 0xe5, 0xd6, 0xf4, 0xe5, 0xb6, 0xf3, 0x9c, 0xbe, 0xdf, 0x1d, 0xa8,
-	0x4b, 0xc2, 0x18, 0x4d, 0xf5, 0x84, 0xfc, 0xab, 0xfb, 0x0c, 0xe6, 0x1e, 0x37, 0x34, 0xde, 0xc0,
-	0x0d, 0x2f, 0xc1, 0x3e, 0xcf, 0x68, 0x8a, 0xde, 0x86, 0x1a, 0x8b, 0xc3, 0xe5, 0xc8, 0xd8, 0x2c,
-	0x3e, 0x89, 0x96, 0x0a, 0x59, 0xf7, 0x39, 0xa3, 0x5a, 0x76, 0xc6, 0x63, 0x68, 0xb3, 0x38, 0x5c,
-	0x64, 0x6a, 0xf6, 0x67, 0x34, 0x7f, 0x4d, 0x80, 0xc5, 0xe7, 0x79, 0xc6, 0x7b, 0x0e, 0x60, 0x5e,
-	0x84, 0xa1, 0x10, 0x31, 0xfa, 0x18, 0xa0, 0xf4, 0x0e, 0x54, 0xf4, 0x29, 0x51, 0xd1, 0xef, 0xf5,
-	0x6b, 0x70, 0x68, 0xff, 0xfc, 0xdb, 0x4e, 0x05, 0x97, 0xb0, 0x4f, 0x0e, 0x0b, 0x1e, 0xd5, 0xfd,
-	0xcd, 0xe7, 0x17, 0xa0, 0x7e, 0xe4, 0x9f, 0x9d, 0x9d, 0x04, 0x4e, 0x05, 0x35, 0xc1, 0x3e, 0x3c,
-	0xf5, 0x0f, 0x1d, 0x4b, 0xad, 0x02, 0xdc, 0xef, 0x3b, 0x55, 0xd4, 0x80, 0x6a, 0xd0, 0x3b, 0x76,
-	0xec, 0x27, 0x3b, 0xb0, 0x7a, 0x43, 0x13, 0x85, 0x19, 0xf8, 0x83, 0xbe, 0xb3, 0xa2, 0x30, 0xc3,
-	0xe3, 0xa1, 0x21, 0xf8, 0xfa, 0xc3, 0xbd, 0x67, 0x8e, 0x75, 0xe0, 0x43, 0x43, 0x24, 0x5a, 0x58,
-	0xf4, 0xe8, 0x8e, 0xe3, 0xcf, 0xa8, 0x9c, 0x8a, 0xc8, 0x4f, 0xd4, 0x8f, 0x41, 0xe6, 0xfe, 0xfd,
-	0xc3, 0xad, 0xe9, 0x2f, 0xff, 0x94, 0xe0, 0xba, 0x48, 0xd4, 0x6e, 0x07, 0xcf, 0xa0, 0x91, 0x3f,
-	0xdb, 0x68, 0xf3, 0x0e, 0xe1, 0x73, 0x4e, 0xe3, 0x25, 0xdf, 0x1f, 0xbf, 0x2b, 0xbe, 0x26, 0x2e,
-	0xf0, 0x07, 0x9f, 0x95, 0x75, 0xfb, 0xbf, 0xea, 0x57, 0x79, 0x75, 0xa9, 0xe4, 0xe0, 0x14, 0x1e,
-	0xe4, 0x7e, 0x7e, 0x7d, 0x9e, 0x3f, 0x73, 0x1e, 0xc7, 0x54, 0x5e, 0x5f, 0xcf, 0x41, 0x00, 0x0f,
-	0x49, 0x14, 0x71, 0x05, 0x23, 0xf1, 0x1b, 0x30, 0xfe, 0x95, 0x33, 0xae, 0x5f, 0x57, 0x97, 0x2e,
-	0x7d, 0xef, 0x5b, 0x25, 0x5f, 0x4c, 0xc6, 0xdd, 0x89, 0x98, 0xed, 0x9a, 0xe5, 0x07, 0x22, 0x65,
-	0xbb, 0x46, 0x54, 0xf3, 0xc7, 0x60, 0x97, 0x89, 0x3c, 0x4e, 0xc6, 0xe3, 0xba, 0x4e, 0x3d, 0xfd,
-	0x27, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x84, 0x06, 0x14, 0x72, 0x08, 0x00, 0x00,
+	// 1096 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4d, 0x6f, 0xdb, 0x46,
+	0x13, 0x8e, 0x28, 0xea, 0x6b, 0x24, 0x39, 0xcc, 0xbe, 0x0e, 0x20, 0xf8, 0x45, 0x12, 0x97, 0x05,
+	0xda, 0x20, 0x70, 0x65, 0xc3, 0x41, 0x8b, 0x46, 0x29, 0x50, 0x48, 0xae, 0x62, 0x38, 0xb1, 0x45,
+	0x61, 0x45, 0xf7, 0xeb, 0x42, 0xac, 0xc4, 0xcd, 0x6a, 0x0b, 0x4a, 0x4b, 0x90, 0xab, 0xa0, 0xf6,
+	0xb1, 0xe8, 0xa9, 0xa7, 0x9e, 0x7b, 0xef, 0xb5, 0x3f, 0xa3, 0xe8, 0xdf, 0x68, 0xda, 0xff, 0xd1,
+	0x62, 0x77, 0x49, 0x99, 0xfe, 0x68, 0x9b, 0xdc, 0x76, 0x86, 0xcf, 0x3c, 0x33, 0xf3, 0xec, 0xec,
+	0x48, 0xd0, 0x4a, 0xe7, 0x24, 0xa1, 0x61, 0x37, 0x4e, 0x84, 0x14, 0xa8, 0xca, 0xb8, 0x24, 0xd1,
+	0xd9, 0xd6, 0x03, 0x26, 0x04, 0x8b, 0xe8, 0xae, 0xf6, 0x4e, 0x57, 0x2f, 0x77, 0x25, 0x5f, 0xd0,
+	0x54, 0x92, 0x45, 0x6c, 0x80, 0x5b, 0xdb, 0x57, 0x01, 0x21, 0x4d, 0x67, 0x09, 0x8f, 0xa5, 0x48,
+	0x0c, 0xc2, 0x7d, 0x5d, 0x82, 0x96, 0x17, 0xd3, 0x84, 0x48, 0x2e, 0x96, 0x27, 0x29, 0x43, 0x5d,
+	0xb0, 0x44, 0xdc, 0x29, 0x6d, 0x97, 0x1e, 0x6e, 0xec, 0xdf, 0xef, 0x9a, 0x44, 0xdd, 0x22, 0xe2,
+	0xc2, 0xc0, 0x96, 0x88, 0xd1, 0x53, 0x68, 0xa6, 0x33, 0x11, 0xd3, 0x20, 0xa2, 0xaf, 0x68, 0xd4,
+	0xb1, 0x74, 0xe0, 0xd6, 0x8d, 0x81, 0x13, 0x85, 0xc3, 0xa0, 0xe1, 0xc7, 0x0a, 0xed, 0x3e, 0x86,
+	0xc6, 0x1a, 0x81, 0x9a, 0x50, 0x3b, 0x1d, 0xbd, 0x18, 0x79, 0x5f, 0x8c, 0x9c, 0x5b, 0xca, 0x38,
+	0x39, 0xf5, 0xfb, 0xbe, 0x87, 0x9d, 0x12, 0x6a, 0x41, 0xbd, 0x7f, 0x70, 0x30, 0x9c, 0x4c, 0x3c,
+	0xec, 0x58, 0xee, 0x1e, 0x54, 0x34, 0x13, 0xda, 0x00, 0xc0, 0xc3, 0xb1, 0x37, 0x39, 0xf2, 0x3d,
+	0xfc, 0x95, 0x73, 0x0b, 0x01, 0x54, 0x27, 0x43, 0xfc, 0xf9, 0x50, 0x85, 0x34, 0xa1, 0x36, 0xf1,
+	0x3d, 0xdc, 0x3f, 0x1c, 0x3a, 0x96, 0xfb, 0x53, 0x09, 0x6e, 0xfb, 0x09, 0x59, 0xa6, 0x64, 0xa6,
+	0x32, 0x4d, 0x24, 0x8d, 0xd1, 0x06, 0x58, 0x3c, 0xd4, 0x7d, 0x36, 0xb0, 0xc5, 0x43, 0xf4, 0x14,
+	0xec, 0x54, 0xd2, 0x38, 0x6b, 0xe0, 0xfd, 0xbc, 0x81, 0x2b, 0x61, 0x57, 0x6d, 0xac, 0x83, 0xdc,
+	0xde, 0x75, 0xfe, 0x36, 0x34, 0xc6, 0x78, 0x78, 0xe0, 0x9d, 0x9c, 0x1c, 0xf9, 0xa6, 0xb6, 0xec,
+	0xac, 0xdb, 0xc1, 0xde, 0xf1, 0xf1, 0xa0, 0x7f, 0xf0, 0xc2, 0xb1, 0xdc, 0x5f, 0x2c, 0x00, 0x4c,
+	0x63, 0x91, 0x72, 0x29, 0x92, 0x33, 0xf4, 0x0e, 0xb4, 0x52, 0x29, 0x12, 0xc2, 0x68, 0xb0, 0x24,
+	0x0b, 0xaa, 0xeb, 0x69, 0xe0, 0x66, 0xe6, 0x1b, 0x91, 0x05, 0x45, 0xef, 0x42, 0x3b, 0xa1, 0x11,
+	0x91, 0xfc, 0x15, 0x0d, 0x62, 0x22, 0xe7, 0x9d, 0xb2, 0xc6, 0xb4, 0x72, 0xe7, 0x98, 0xc8, 0x39,
+	0xda, 0x83, 0x4d, 0xc6, 0x65, 0x20, 0xa6, 0xdf, 0xd0, 0x99, 0x0c, 0x42, 0x9e, 0xd0, 0x99, 0xe2,
+	0xef, 0xd8, 0x1a, 0x8b, 0x18, 0x97, 0x9e, 0xfe, 0xf4, 0x59, 0xfe, 0x05, 0x1d, 0xc2, 0xb6, 0x8a,
+	0x20, 0x91, 0xa4, 0xc9, 0x92, 0x48, 0x7a, 0x35, 0x96, 0xd3, 0xb4, 0x53, 0xd9, 0x2e, 0x3f, 0x6c,
+	0xe0, 0x7b, 0x8c, 0xcb, 0x7e, 0x0e, 0xbb, 0x4c, 0xc3, 0x69, 0xaa, 0xea, 0x63, 0x51, 0x90, 0xac,
+	0x7b, 0xea, 0x54, 0x4d, 0x7d, 0x2c, 0x2a, 0xf4, 0xf9, 0x1e, 0xdc, 0x66, 0x51, 0x10, 0x27, 0x42,
+	0xe7, 0xd0, 0x6d, 0xd4, 0x35, 0xac, 0xcd, 0xa2, 0xb1, 0xf1, 0xaa, 0x3e, 0x9e, 0xdb, 0xf5, 0x92,
+	0x63, 0x3d, 0xb7, 0xeb, 0x35, 0xa7, 0x8e, 0x6d, 0x05, 0x73, 0x7f, 0xb6, 0xa0, 0x71, 0xc8, 0xe5,
+	0x81, 0x58, 0x2c, 0xb8, 0xbc, 0x76, 0x8f, 0x1d, 0xa8, 0xa5, 0x2b, 0x5d, 0x92, 0x96, 0xae, 0x85,
+	0x73, 0x13, 0x21, 0xb0, 0xa7, 0x22, 0x3c, 0xd3, 0x6a, 0xb5, 0xb0, 0x3e, 0xa3, 0x1d, 0xa8, 0x92,
+	0x95, 0x9c, 0x8b, 0x44, 0xeb, 0xd2, 0xdc, 0xdf, 0xcc, 0xef, 0xdd, 0xb0, 0xf7, 0xf5, 0x37, 0x9c,
+	0x61, 0xd0, 0x3e, 0x34, 0x66, 0xda, 0x2f, 0x69, 0xd2, 0xa9, 0xfc, 0x4b, 0xc0, 0x05, 0x0c, 0xdd,
+	0x03, 0x88, 0x49, 0x42, 0x97, 0x32, 0xe0, 0x61, 0xda, 0xa9, 0x6a, 0xfd, 0x1a, 0xc6, 0x73, 0x14,
+	0xa6, 0xe8, 0xff, 0xd0, 0x50, 0x85, 0x04, 0x29, 0x3f, 0xa7, 0x9d, 0xda, 0x76, 0xe9, 0x61, 0x19,
+	0xd7, 0x95, 0x63, 0xc2, 0xcf, 0x29, 0xfa, 0x04, 0x36, 0x52, 0xce, 0x96, 0x44, 0xae, 0x12, 0x1a,
+	0xc8, 0xb3, 0x98, 0x6a, 0x89, 0x36, 0xf6, 0xef, 0xe6, 0x49, 0x27, 0xf9, 0x57, 0xff, 0x2c, 0xa6,
+	0xb8, 0x9d, 0x16, 0x4d, 0xf7, 0xfb, 0x12, 0xb4, 0x8a, 0x55, 0x29, 0x01, 0xf4, 0x48, 0x95, 0x8c,
+	0x00, 0xea, 0x8c, 0x36, 0xa1, 0x42, 0x17, 0x84, 0x47, 0x99, 0x58, 0xc6, 0x40, 0x5d, 0xb0, 0x43,
+	0x22, 0xa9, 0x96, 0xaa, 0xa9, 0x5e, 0xb3, 0x5e, 0x23, 0xdd, 0x7c, 0x8d, 0x74, 0xfd, 0x7c, 0xcf,
+	0x60, 0x8d, 0x43, 0x5b, 0x50, 0x57, 0xab, 0xe7, 0x5c, 0x2c, 0xa9, 0x16, 0xb2, 0x85, 0xd7, 0xb6,
+	0xeb, 0x02, 0x0c, 0xbf, 0xe5, 0x72, 0x22, 0x89, 0x5c, 0xa5, 0x2a, 0xdf, 0x2b, 0x12, 0xad, 0x4c,
+	0x11, 0x15, 0x6c, 0x0c, 0xd7, 0x87, 0xea, 0x20, 0x21, 0xcb, 0xd9, 0xfc, 0xc6, 0x1a, 0x3f, 0x82,
+	0xb6, 0x24, 0x09, 0xa3, 0x32, 0x30, 0xb2, 0xea, 0x5a, 0x9b, 0xfb, 0x77, 0x72, 0x15, 0xd6, 0xc3,
+	0x80, 0x5b, 0x06, 0x67, 0x2c, 0xf7, 0x07, 0x0b, 0xca, 0x3e, 0x61, 0x37, 0x72, 0x9a, 0xb1, 0xb1,
+	0xd6, 0x63, 0x73, 0x2d, 0x47, 0xf9, 0x8d, 0x72, 0xa8, 0x71, 0x5b, 0xd0, 0x34, 0x25, 0x2c, 0x6f,
+	0x3c, 0x37, 0xd5, 0x43, 0xce, 0x8e, 0xe6, 0x72, 0x2b, 0xfa, 0x72, 0x9b, 0x99, 0x4f, 0xdf, 0xef,
+	0x0e, 0x54, 0x25, 0x61, 0x8c, 0x26, 0xfa, 0x85, 0xfc, 0xe3, 0xf4, 0x19, 0xcc, 0x0d, 0xd3, 0x50,
+	0x7b, 0x8b, 0x69, 0x78, 0x09, 0xf6, 0x69, 0x4a, 0x13, 0xf4, 0x3f, 0xa8, 0xb0, 0x28, 0x58, 0x3f,
+	0x19, 0x9b, 0x45, 0x47, 0xe1, 0x5a, 0x21, 0xeb, 0xa6, 0xc9, 0x28, 0x17, 0x27, 0xe3, 0x01, 0x34,
+	0x59, 0x14, 0xac, 0x52, 0xf5, 0xf6, 0x17, 0x34, 0xdb, 0x26, 0xc0, 0xa2, 0xd3, 0xcc, 0xe3, 0x3e,
+	0x03, 0x30, 0x1b, 0x61, 0x2c, 0x44, 0x84, 0x3e, 0x06, 0x28, 0xec, 0x81, 0x92, 0xee, 0x12, 0xe5,
+	0xf5, 0x5e, 0x6c, 0x83, 0x81, 0xfd, 0xe3, 0xaf, 0x3b, 0x25, 0x5c, 0xc0, 0x3e, 0x1a, 0xe4, 0x3c,
+	0xaa, 0xfa, 0xcb, 0xbf, 0x0d, 0xc5, 0x5d, 0x5a, 0x07, 0x7b, 0x70, 0xec, 0x0d, 0x1c, 0x4b, 0x9d,
+	0x7c, 0x3c, 0x1c, 0x3a, 0x65, 0x54, 0x83, 0xb2, 0xdf, 0x3f, 0x74, 0xec, 0x47, 0x3b, 0xd0, 0xbe,
+	0xa4, 0x89, 0xc2, 0x8c, 0xbc, 0xd1, 0xd0, 0xb9, 0xa5, 0x30, 0xe3, 0xc3, 0xb1, 0x21, 0xf8, 0xf2,
+	0xc3, 0xbd, 0x27, 0x8e, 0xd5, 0xf3, 0xa0, 0x26, 0x62, 0x2d, 0x2c, 0xba, 0x7f, 0x6d, 0xe2, 0x4f,
+	0xa8, 0x9c, 0x8b, 0xd0, 0x8b, 0xd5, 0x7e, 0x4f, 0x3b, 0x7f, 0x7d, 0x77, 0xe5, 0xf5, 0x17, 0x7f,
+	0xe7, 0x70, 0x55, 0xc4, 0x2a, 0x5b, 0xef, 0x09, 0xd4, 0xb2, 0xb5, 0x8d, 0xee, 0x5d, 0x23, 0x7c,
+	0xc6, 0x69, 0xb4, 0xe6, 0xfb, 0xfd, 0x37, 0xc5, 0x57, 0xc7, 0x39, 0xbe, 0xf7, 0x69, 0x51, 0xb7,
+	0xff, 0x8a, 0x7e, 0x9d, 0x45, 0x17, 0x42, 0x7a, 0xc7, 0x70, 0x27, 0x9b, 0xe7, 0x37, 0xe7, 0xf9,
+	0x23, 0xe3, 0x71, 0x4c, 0xe4, 0xc5, 0xf5, 0xf4, 0x7c, 0xb8, 0x4b, 0xc2, 0x90, 0x2b, 0x18, 0x89,
+	0xde, 0x82, 0xf1, 0xcf, 0x8c, 0x71, 0xf3, 0x22, 0xba, 0x70, 0xe9, 0x7b, 0x5f, 0x2b, 0xf9, 0x22,
+	0x32, 0xed, 0xce, 0xc4, 0x62, 0xd7, 0x1c, 0x3f, 0x10, 0x09, 0xdb, 0x35, 0xa2, 0x9a, 0x7f, 0x2d,
+	0xbb, 0x4c, 0x64, 0x76, 0x3c, 0x9d, 0x56, 0xb5, 0xeb, 0xf1, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0xe9, 0xa7, 0x3b, 0x4d, 0x0f, 0x09, 0x00, 0x00,
 }
diff --git a/proto/repository-service.proto b/proto/repository-service.proto
index b502c4f5c1..67ce7605a1 100644
--- a/proto/repository-service.proto
+++ b/proto/repository-service.proto
@@ -336,12 +336,14 @@ message WriteRefRequest {
   // This used to be a boolean indicating whether or not to shell out or use
   // the rugged implementation
   reserved 6;
+  TransactionStep transaction_step = 7;
 }
 
 message WriteRefResponse {
   // This used to contain an error message. Since we're shelling out
   // all exceptions are wrapped in GRPC errors.
   reserved 1;
+  TransactionStep transaction_step = 2;
 }
 
 message FindMergeBaseRequest {
diff --git a/proto/shared.proto b/proto/shared.proto
index bb5886fd8e..29afd1eaa2 100644
--- a/proto/shared.proto
+++ b/proto/shared.proto
@@ -29,6 +29,19 @@ message OperationMsg {
   Scope scope_level = 2;
 }
 
+message TransactionStep {
+    enum TransactionStep {
+        PRECOMMIT = 0;
+        COMMIT = 1;
+        ROLLBACK = 2;
+    }
+
+    string id = 1;
+    TransactionStep step = 2;
+}
+
+
+
 enum ObjectType {
   UNKNOWN = 0;
   COMMIT = 1;
diff --git a/ruby/proto/gitaly/repository-service_pb.rb b/ruby/proto/gitaly/repository-service_pb.rb
index e3ed2339eb..00686bd903 100644
--- a/ruby/proto/gitaly/repository-service_pb.rb
+++ b/ruby/proto/gitaly/repository-service_pb.rb
@@ -106,8 +106,10 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :revision, :bytes, 3
     optional :old_revision, :bytes, 4
     optional :force, :bool, 5
+    optional :transaction_step, :message, 7, "gitaly.TransactionStep"
   end
   add_message "gitaly.WriteRefResponse" do
+    optional :transaction_step, :message, 2, "gitaly.TransactionStep"
   end
   add_message "gitaly.FindMergeBaseRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
diff --git a/ruby/proto/gitaly/shared_pb.rb b/ruby/proto/gitaly/shared_pb.rb
index 1b0a316629..ed42cba994 100644
--- a/ruby/proto/gitaly/shared_pb.rb
+++ b/ruby/proto/gitaly/shared_pb.rb
@@ -19,6 +19,15 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     value :SERVER, 1
     value :STORAGE, 2
   end
+  add_message "gitaly.TransactionStep" do
+    optional :id, :string, 1
+    optional :step, :enum, 2, "gitaly.TransactionStep.TransactionStep"
+  end
+  add_enum "gitaly.TransactionStep.TransactionStep" do
+    value :PRECOMMIT, 0
+    value :COMMIT, 1
+    value :ROLLBACK, 2
+  end
   add_message "gitaly.Repository" do
     optional :storage_name, :string, 2
     optional :relative_path, :string, 3
@@ -86,6 +95,8 @@ module Gitaly
   OperationMsg = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg").msgclass
   OperationMsg::Operation = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg.Operation").enummodule
   OperationMsg::Scope = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg.Scope").enummodule
+  TransactionStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.TransactionStep").msgclass
+  TransactionStep::TransactionStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.TransactionStep.TransactionStep").enummodule
   Repository = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Repository").msgclass
   GitCommit = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.GitCommit").msgclass
   CommitAuthor = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitAuthor").msgclass
-- 
GitLab


From f4824e3c191a5d529d4f266bfd349ca8def4a272 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Tue, 25 Feb 2020 16:42:43 -0800
Subject: [PATCH 3/8] with locking

---
 internal/git/repository/repository.go         |  72 +++-
 .../repositoryhandler/transactions.go         | 142 ++++++
 internal/praefect/coordinator.go              |  58 ++-
 internal/praefect/grpc-proxy/proxy/handler.go |  28 --
 internal/praefect/grpc-proxy/proxy/peeker.go  |   2 -
 internal/repotx/lock.go                       |  10 -
 internal/server/server.go                     |  15 +-
 internal/service/register.go                  |   5 +-
 internal/service/repository/server.go         |   4 +-
 internal/service/repository/write_ref.go      |  31 +-
 proto/go/gitalypb/repository-service.pb.go    | 407 +++++++++---------
 proto/go/gitalypb/shared.pb.go                | 214 +++++----
 proto/go/internal/linter/method.go            |  53 +--
 proto/repository-service.proto                |   4 +-
 proto/shared.proto                            |   7 +-
 ruby/proto/gitaly/repository-service_pb.rb    |   4 +-
 ruby/proto/gitaly/shared_pb.rb                |  11 +-
 17 files changed, 604 insertions(+), 463 deletions(-)
 create mode 100644 internal/middleware/repositoryhandler/transactions.go
 delete mode 100644 internal/repotx/lock.go

diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index 58b9d4ab99..c086c1b3e2 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/sirupsen/logrus"
 
-	"github.com/google/uuid"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 
 	"gitlab.com/gitlab-org/gitaly/internal/command"
@@ -37,14 +36,11 @@ type Transactions struct {
 	log                *logrus.Entry
 }
 
-func (t *Transactions) StartTransaction(repo *gitalypb.Repository, rollback command.Cmd) string {
+func (t *Transactions) NewTransaction(transactionID string, repo *gitalypb.Repository) {
 	tx := Transaction{
-		Repo:     repo,
-		Rollback: rollback,
+		Repo: repo,
 	}
 
-	transactionID := uuid.New().String()
-
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 	t.transactions[transactionID] = &tx
@@ -58,27 +54,60 @@ func (t *Transactions) StartTransaction(repo *gitalypb.Repository, rollback comm
 	t.repositories[repo.RelativePath].Lock()
 	t.repoMutex.Unlock()
 
-	t.log.WithField("relative_path", repo.RelativePath)
+	t.log.WithField("relative_path", repo.RelativePath).Info("transaction created")
+}
+
+func (t *Transactions) Start(transactionID string, rollback command.Cmd) {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
 
-	t.transactions[transactionID].Commit = t.repositories[repo.RelativePath].Unlock
+	_, ok := t.transactions[transactionID]
+	if !ok {
+		return
+	}
 
-	return transactionID
+	t.transactions[transactionID].inProgress = true
+	t.transactions[transactionID].Rollback = rollback
 }
 
 func (t *Transactions) Commit(transactionID string) error {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
+	_, ok := t.transactions[transactionID]
+	if !ok {
+		return errors.New("request_id not found")
+	}
+
+	t.transactions[transactionID].inProgress = false
+
+	t.log.WithField("transaction_id", transactionID).Info("commited")
+	return nil
+}
+
+func (t *Transactions) Unlock(transactionID string) error {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
 	tx, ok := t.transactions[transactionID]
 	if !ok {
 		return errors.New("request_id not found")
 	}
 
-	t.repoMutex.Lock()
-	tx.Commit()
-	t.repoMutex.Unlock()
+	if !tx.inProgress {
+		t.repoMutex.Lock()
+		defer t.repoMutex.Unlock()
+
+		repoLock, ok := t.repositories[tx.Repo.GetRelativePath()]
+		if !ok {
+			return nil
+		}
+		repoLock.Unlock()
+
+		delete(t.transactions, transactionID)
+		t.log.WithField("transaction_id", transactionID).Info("unlocked")
+	}
 
-	delete(t.transactions, transactionID)
 	return nil
 }
 
@@ -98,13 +127,24 @@ func (t *Transactions) Rollback(transactionID string) error {
 	return nil
 }
 
+func (t *Transactions) TransactionStarted(transactionID string) bool {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	_, ok := t.transactions[transactionID]
+	if !ok {
+		return false
+	}
+	return true
+}
+
 type Transaction struct {
 	//	serviceName string
 	//	methodName  string
 	//	transactionID   string
-	Repo     GitRepo
-	Rollback command.Cmd
-	Commit   func()
+	Repo       GitRepo
+	Rollback   command.Cmd
+	inProgress bool
 }
 
 type RepoLock interface {
diff --git a/internal/middleware/repositoryhandler/transactions.go b/internal/middleware/repositoryhandler/transactions.go
new file mode 100644
index 0000000000..45c802faba
--- /dev/null
+++ b/internal/middleware/repositoryhandler/transactions.go
@@ -0,0 +1,142 @@
+package repositoryhandler
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
+
+	"github.com/google/uuid"
+	"google.golang.org/grpc/metadata"
+
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
+
+	"google.golang.org/grpc"
+)
+
+type RepositoryRequest interface {
+	GetRepository() *gitalypb.Repository
+}
+
+func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions, registry *protoregistry.Registry) grpc.UnaryServerInterceptor {
+	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+		mi, err := registry.LookupMethod(info.FullMethod)
+		if err != nil {
+			return nil, err
+		}
+
+		if mi.Scope == protoregistry.ScopeRepository && mi.Operation == protoregistry.OpMutator {
+			var transactionID string
+
+			md, ok := metadata.FromIncomingContext(ctx)
+			if ok && len(md.Get("transaction_id")) > 0 {
+				transactionID = md.Get("transaction_id")[0]
+			} else {
+				transactionID = uuid.New().String()
+
+			}
+
+			if !transactions.TransactionStarted(transactionID) {
+				repoReq, ok := req.(RepositoryRequest)
+				if !ok {
+					return nil, errors.New("not a repository request")
+				}
+
+				transactions.NewTransaction(transactionID, repoReq.GetRepository())
+			}
+
+			defer transactions.Unlock(transactionID)
+
+			ctx = metadata.NewIncomingContext(ctx, metadata.New(map[string]string{"transaction_id": transactionID}))
+
+			grpc.SetTrailer(ctx, metadata.New(map[string]string{"transaction_id": transactionID}))
+		}
+
+		res, err := handler(ctx, req)
+
+		return res, err
+	}
+}
+
+func NewTransactionServerStream(ss grpc.ServerStream, methodInfo protoregistry.MethodInfo, transactions *repository.Transactions, transactionID string) TransactionServerStream {
+	return TransactionServerStream{
+		transactionID: transactionID,
+		ss:            ss,
+		mi:            methodInfo,
+		transactions:  transactions,
+	}
+}
+
+type TransactionServerStream struct {
+	transactionID string
+	ss            grpc.ServerStream
+	mi            protoregistry.MethodInfo
+	transactions  *repository.Transactions
+}
+
+func (t TransactionServerStream) SetHeader(m metadata.MD) error {
+	return t.ss.SetHeader(m)
+}
+
+func (t TransactionServerStream) SendHeader(m metadata.MD) error {
+	return t.ss.SendHeader(m)
+}
+
+func (t TransactionServerStream) SetTrailer(m metadata.MD) {
+	t.ss.SetTrailer(m)
+}
+
+func (t TransactionServerStream) Context() context.Context {
+	return t.ss.Context()
+}
+
+func (t TransactionServerStream) SendMsg(m interface{}) error {
+	return t.ss.SendMsg(m)
+}
+
+func (t TransactionServerStream) RecvMsg(m interface{}) error {
+	if !t.transactions.TransactionStarted(t.transactionID) {
+		fmt.Printf("Receiving Message: type=%s\n", reflect.TypeOf(m).String())
+		repoReq, ok := m.(RepositoryRequest)
+		if ok {
+			t.transactions.NewTransaction(t.transactionID, repoReq.GetRepository())
+		}
+	}
+
+	t.ss.SetTrailer(metadata.Pairs("transaction_id", t.transactionID))
+
+	return t.ss.RecvMsg(m)
+}
+
+// StreamInterceptor returns a Stream Interceptor
+func RepositoryTransactionServerInterceptor(transactions *repository.Transactions, registry *protoregistry.Registry) grpc.StreamServerInterceptor {
+	return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		ctx := stream.Context()
+
+		mi, err := registry.LookupMethod(info.FullMethod)
+		if err != nil {
+			return err
+		}
+
+		if mi.Scope == protoregistry.ScopeRepository && mi.Operation == protoregistry.OpMutator {
+			var transactionID string
+
+			md, ok := metadata.FromIncomingContext(ctx)
+			if ok && len(md.Get("transaction_id")) > 0 {
+				transactionID = md.Get("transaction_id")[0]
+			} else {
+				transactionID = uuid.New().String()
+			}
+
+			defer transactions.Unlock(transactionID)
+
+			return handler(srv, NewTransactionServerStream(stream, mi, transactions, transactionID))
+		}
+
+		return handler(srv, stream)
+	}
+}
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 6b674e4382..fa7a24abac 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -8,6 +8,8 @@ import (
 	"sync"
 	"syscall"
 
+	"google.golang.org/grpc/metadata"
+
 	"google.golang.org/grpc"
 
 	"github.com/golang/protobuf/proto"
@@ -148,27 +150,12 @@ func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string,
 }
 
 func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
-	s.log.Error("I'm here!!!!")
-
-	peeker := proxy.NewPeeker(serverStream)
+	var writeRefReq gitalypb.WriteRefRequest
 
-	mi, err := s.registry.LookupMethod("/gitaly.RepositoryService/WriteRef")
-	if err != nil {
+	if err := serverStream.RecvMsg(&writeRefReq); err != nil {
 		return err
 	}
 
-	frame, err := peeker.Peek()
-
-	m, err := mi.UnmarshalRequestProto(frame)
-	if err != nil {
-		return err
-	}
-
-	writeRefReq, ok := m.(*gitalypb.WriteRefRequest)
-	if !ok {
-		return errors.New("sholud have been write ref request!")
-	}
-
 	shard, err := s.nodeMgr.GetShard(writeRefReq.GetRepository().GetStorageName())
 	if err != nil {
 		return err
@@ -190,35 +177,42 @@ func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 	var errs []error
 	transactionIDs := make(map[string]nodes.Node)
 
+	// PreCommit
 	for _, node := range append(secondaries, primary) {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
 		targetRepo := &gitalypb.Repository{
 			StorageName:  node.GetStorage(),
 			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
 		}
-		resp, err := client.WriteRef(ctx, &gitalypb.WriteRefRequest{
+		var trailer metadata.MD
+
+		if _, err := client.WriteRef(ctx, &gitalypb.WriteRefRequest{
 			Repository:  targetRepo,
 			Ref:         writeRefReq.Ref,
 			Revision:    writeRefReq.Revision,
 			OldRevision: writeRefReq.OldRevision,
 			Force:       writeRefReq.Force,
-			TransactionStep: &gitalypb.TransactionStep{
-				Id:   "",
-				Step: gitalypb.TransactionStep_PRECOMMIT,
-			}})
-		if err != nil {
+			Transaction: &gitalypb.Transaction{
+				Step: gitalypb.Transaction_PRECOMMIT,
+			}}, grpc.Trailer(&trailer)); err != nil {
 			errs = append(errs, err)
 		}
-		transactionIDs[resp.TransactionStep.Id] = node
+
+		if len(trailer.Get("transaction_id")) == 0 {
+			return errors.New("transaction id not found")
+		}
+
+		transactionID := trailer.Get("transaction_id")[0]
+		transactionIDs[transactionID] = node
 	}
 
+	// Commit
 	if len(errs) == 0 {
 		for transactionID, node := range transactionIDs {
 			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-			if _, err = client.WriteRef(ctx, &gitalypb.WriteRefRequest{
-				TransactionStep: &gitalypb.TransactionStep{
-					Id:   transactionID,
-					Step: gitalypb.TransactionStep_COMMIT,
+			if _, err = client.WriteRef(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefRequest{
+				Transaction: &gitalypb.Transaction{
+					Step: gitalypb.Transaction_COMMIT,
 				}}); err != nil {
 				return err
 			}
@@ -227,12 +221,12 @@ func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		return nil
 	}
 
+	// Rollback
 	for transactionID, node := range transactionIDs {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-		if _, err = client.WriteRef(ctx, &gitalypb.WriteRefRequest{
-			TransactionStep: &gitalypb.TransactionStep{
-				Id:   transactionID,
-				Step: gitalypb.TransactionStep_ROLLBACK,
+		if _, err = client.WriteRef(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefRequest{
+			Transaction: &gitalypb.Transaction{
+				Step: gitalypb.Transaction_ROLLBACK,
 			}}); err != nil {
 			return err
 		}
diff --git a/internal/praefect/grpc-proxy/proxy/handler.go b/internal/praefect/grpc-proxy/proxy/handler.go
index 2e960c3ee1..3c3676d34d 100644
--- a/internal/praefect/grpc-proxy/proxy/handler.go
+++ b/internal/praefect/grpc-proxy/proxy/handler.go
@@ -27,27 +27,6 @@ var (
 // The behaviour is the same as if you were registering a handler method, e.g. from a codegenerated pb.go file.
 //
 // This can *only* be used if the `server` also uses grpcproxy.CodecForServer() ServerOption.
-/*
-func RegisterService(server *grpc.Server, director StreamDirector, serviceName string, methodNames ...string) {
-	streamer := &handler{director: director}
-	fakeDesc := &grpc.ServiceDesc{
-		ServiceName: serviceName,
-		HandlerType: (*interface{})(nil),
-	}
-	for _, m := range methodNames {
-		streamDesc := grpc.StreamDesc{
-			StreamName:    m,
-			Handler:       streamer.handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		}
-		fakeDesc.Streams = append(fakeDesc.Streams, streamDesc)
-	}
-	server.RegisterService(fakeDesc, streamer)
-}
-
-*/
-
 func RegisterService(server *grpc.Server, streamer grpc.StreamHandler, serviceName string, methodNames ...string) {
 	fakeDesc := &grpc.ServiceDesc{
 		ServiceName: serviceName,
@@ -89,13 +68,6 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error
 		return status.Errorf(codes.Internal, "lowLevelServerStream not exists in context")
 	}
 
-	/*
-		if fullMethodName == "/gitaly.RepositoryService/WriteRef" {
-			return s.mutatorHandler(srv, serverStream)
-		}
-
-	*/
-
 	peeker := newPeeker(serverStream)
 
 	// We require that the director's returned context inherits from the serverStream.Context().
diff --git a/internal/praefect/grpc-proxy/proxy/peeker.go b/internal/praefect/grpc-proxy/proxy/peeker.go
index df7fa4cb4c..1d1e02df56 100644
--- a/internal/praefect/grpc-proxy/proxy/peeker.go
+++ b/internal/praefect/grpc-proxy/proxy/peeker.go
@@ -31,8 +31,6 @@ type peeker struct {
 	consumedStream *partialStream
 }
 
-var NewPeeker = newPeeker
-
 func newPeeker(stream grpc.ServerStream) *peeker {
 	return &peeker{
 		srcStream:      stream,
diff --git a/internal/repotx/lock.go b/internal/repotx/lock.go
deleted file mode 100644
index 6ded8ce28a..0000000000
--- a/internal/repotx/lock.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package repotx
-
-import "gitlab.com/gitlab-org/gitaly/internal/git/repository"
-
-type Transaction struct {
-	serviceName string
-	methodName  string
-	repo        repository.GitRepo
-	repository.RepoLock
-}
diff --git a/internal/server/server.go b/internal/server/server.go
index 2507492488..32749eb9a2 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -5,6 +5,12 @@ import (
 	"crypto/tls"
 	"os"
 
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
+
+	"gitlab.com/gitlab-org/gitaly/internal/middleware/repositoryhandler"
+
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
+
 	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpc_logrus "github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus"
 	grpc_ctxtags "github.com/grpc-ecosystem/go-grpc-middleware/tags"
@@ -76,7 +82,12 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 
 	lh := limithandler.New(concurrencyKeyFn)
 
+	transactions := repository.NewTransactions()
+	registry := protoregistry.New()
+	registry.RegisterFiles(protoregistry.GitalyProtoFileDescriptors...)
+
 	opts := []grpc.ServerOption{
+		grpc.CustomCodec(proxy.Codec()),
 		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
 			grpc_ctxtags.StreamServerInterceptor(ctxTagOpts...),
 			grpccorrelation.StreamServerCorrelationInterceptor(), // Must be above the metadata handler
@@ -92,6 +103,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 			// Panic handler should remain last so that application panics will be
 			// converted to errors and logged
 			panichandler.StreamPanicHandler,
+			repositoryhandler.RepositoryTransactionServerInterceptor(transactions, registry),
 		)),
 		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
 			grpc_ctxtags.UnaryServerInterceptor(ctxTagOpts...),
@@ -108,6 +120,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 			// Panic handler should remain last so that application panics will be
 			// converted to errors and logged
 			panichandler.UnaryPanicHandler,
+			repositoryhandler.RepositoryTransactionUnaryInterceptor(transactions, registry),
 		)),
 	}
 
@@ -123,7 +136,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 
 	server := grpc.NewServer(opts...)
 
-	service.RegisterAll(server, rubyServer)
+	service.RegisterAll(server, rubyServer, transactions)
 	reflection.Register(server)
 
 	grpc_prometheus.Register(server)
diff --git a/internal/service/register.go b/internal/service/register.go
index 119b01fa1a..2db53735fd 100644
--- a/internal/service/register.go
+++ b/internal/service/register.go
@@ -1,6 +1,7 @@
 package service
 
 import (
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/internal/service/blob"
 	"gitlab.com/gitlab-org/gitaly/internal/service/cleanup"
@@ -26,7 +27,7 @@ import (
 
 // RegisterAll will register all the known grpc services with
 // the specified grpc service instance
-func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server) {
+func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server, transactions *repo.Transactions) {
 	gitalypb.RegisterBlobServiceServer(grpcServer, blob.NewServer(rubyServer))
 	gitalypb.RegisterCleanupServiceServer(grpcServer, cleanup.NewServer())
 	gitalypb.RegisterCommitServiceServer(grpcServer, commit.NewServer())
@@ -34,7 +35,7 @@ func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server) {
 	gitalypb.RegisterNamespaceServiceServer(grpcServer, namespace.NewServer())
 	gitalypb.RegisterOperationServiceServer(grpcServer, operations.NewServer(rubyServer))
 	gitalypb.RegisterRefServiceServer(grpcServer, ref.NewServer())
-	gitalypb.RegisterRepositoryServiceServer(grpcServer, repository.NewServer(rubyServer))
+	gitalypb.RegisterRepositoryServiceServer(grpcServer, repository.NewServer(transactions, rubyServer))
 	gitalypb.RegisterSSHServiceServer(grpcServer, ssh.NewServer())
 	gitalypb.RegisterSmartHTTPServiceServer(grpcServer, smarthttp.NewServer())
 	gitalypb.RegisterWikiServiceServer(grpcServer, wiki.NewServer(rubyServer))
diff --git a/internal/service/repository/server.go b/internal/service/repository/server.go
index ba28188aa3..9dc817d676 100644
--- a/internal/service/repository/server.go
+++ b/internal/service/repository/server.go
@@ -20,8 +20,8 @@ type server struct {
 }
 
 // NewServer creates a new instance of a gRPC repo server
-func NewServer(rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
-	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn), transactions: repository.NewTransactions()}
+func NewServer(transactions *repository.Transactions, rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
+	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn), transactions: transactions}
 }
 
 func (*server) FetchHTTPRemote(context.Context, *gitalypb.FetchHTTPRemoteRequest) (*gitalypb.FetchHTTPRemoteResponse, error) {
diff --git a/internal/service/repository/write_ref.go b/internal/service/repository/write_ref.go
index afff0bfa00..bac47a5cb7 100644
--- a/internal/service/repository/write_ref.go
+++ b/internal/service/repository/write_ref.go
@@ -3,8 +3,11 @@ package repository
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 
+	"google.golang.org/grpc/metadata"
+
 	"gitlab.com/gitlab-org/gitaly/internal/command"
 
 	"gitlab.com/gitlab-org/gitaly/internal/git"
@@ -24,8 +27,18 @@ func nonTransactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefRequest
 func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
 	var resp gitalypb.WriteRefResponse
 
-	switch req.TransactionStep.Step {
-	case gitalypb.TransactionStep_PRECOMMIT:
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return nil, helper.ErrInternal(errors.New("couldn't get metadata"))
+	}
+	if len(md.Get("transaction_id")) == 0 {
+		return nil, helper.ErrInternal(errors.New("expected request_id"))
+	}
+
+	transactionID := md.Get("transaction_id")[0]
+
+	switch req.Transaction.Step {
+	case gitalypb.Transaction_PRECOMMIT:
 		if err := writeRef(ctx, req); err != nil {
 			return nil, helper.ErrInternal(err)
 		}
@@ -34,14 +47,14 @@ func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteR
 		if err != nil {
 			return nil, err
 		}
-		transactionID := s.transactions.StartTransaction(req.GetRepository(), rollback)
-		resp.TransactionStep.Id = transactionID
-	case gitalypb.TransactionStep_COMMIT:
-		if err := s.transactions.Commit(req.TransactionStep.Id); err != nil {
+		s.transactions.Start(transactionID, rollback)
+
+	case gitalypb.Transaction_COMMIT:
+		if err := s.transactions.Commit(transactionID); err != nil {
 			return nil, err
 		}
-	case gitalypb.TransactionStep_ROLLBACK:
-		if err := s.transactions.Rollback(req.TransactionStep.Id); err != nil {
+	case gitalypb.Transaction_ROLLBACK:
+		if err := s.transactions.Rollback(transactionID); err != nil {
 			return nil, err
 		}
 	}
@@ -54,7 +67,7 @@ func (s *server) WriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*
 		return nil, helper.ErrInvalidArgument(err)
 	}
 
-	if req.TransactionStep == nil {
+	if req.Transaction == nil {
 		return nonTransactionalWriteRef(ctx, req)
 	}
 
diff --git a/proto/go/gitalypb/repository-service.pb.go b/proto/go/gitalypb/repository-service.pb.go
index 59983cc6db..a86203ee5e 100644
--- a/proto/go/gitalypb/repository-service.pb.go
+++ b/proto/go/gitalypb/repository-service.pb.go
@@ -1199,15 +1199,15 @@ func (m *FsckResponse) GetError() []byte {
 }
 
 type WriteRefRequest struct {
-	Repository           *Repository      `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	Ref                  []byte           `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
-	Revision             []byte           `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
-	OldRevision          []byte           `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
-	Force                bool             `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
-	TransactionStep      *TransactionStep `protobuf:"bytes,7,opt,name=transaction_step,json=transactionStep,proto3" json:"transaction_step,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	Repository           *Repository  `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Ref                  []byte       `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
+	Revision             []byte       `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	OldRevision          []byte       `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
+	Force                bool         `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
+	Transaction          *Transaction `protobuf:"bytes,7,opt,name=transaction,proto3" json:"transaction,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
 }
 
 func (m *WriteRefRequest) Reset()         { *m = WriteRefRequest{} }
@@ -1270,18 +1270,18 @@ func (m *WriteRefRequest) GetForce() bool {
 	return false
 }
 
-func (m *WriteRefRequest) GetTransactionStep() *TransactionStep {
+func (m *WriteRefRequest) GetTransaction() *Transaction {
 	if m != nil {
-		return m.TransactionStep
+		return m.Transaction
 	}
 	return nil
 }
 
 type WriteRefResponse struct {
-	TransactionStep      *TransactionStep `protobuf:"bytes,2,opt,name=transaction_step,json=transactionStep,proto3" json:"transaction_step,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	Transaction          *Transaction `protobuf:"bytes,2,opt,name=transaction,proto3" json:"transaction,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
 }
 
 func (m *WriteRefResponse) Reset()         { *m = WriteRefResponse{} }
@@ -1309,9 +1309,9 @@ func (m *WriteRefResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WriteRefResponse proto.InternalMessageInfo
 
-func (m *WriteRefResponse) GetTransactionStep() *TransactionStep {
+func (m *WriteRefResponse) GetTransaction() *Transaction {
 	if m != nil {
-		return m.TransactionStep
+		return m.Transaction
 	}
 	return nil
 }
@@ -3841,193 +3841,192 @@ func init() {
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor_e9b1768cf174c79b) }
 
 var fileDescriptor_e9b1768cf174c79b = []byte{
-	// 2962 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7,
-	0xf5, 0x37, 0x75, 0x23, 0x79, 0x44, 0xdb, 0xd4, 0x48, 0xb6, 0xa8, 0xb5, 0x65, 0xd9, 0x6b, 0xc7,
-	0x71, 0x12, 0x47, 0x76, 0xe4, 0x3f, 0xf0, 0x4f, 0x5b, 0x14, 0x85, 0xa8, 0x7b, 0x6c, 0x4b, 0xca,
-	0x4a, 0x69, 0x10, 0xa3, 0xc1, 0x66, 0xb9, 0x1c, 0x89, 0x5b, 0x2d, 0x77, 0xe8, 0xd9, 0xa1, 0x14,
-	0x05, 0xed, 0x43, 0x0b, 0xe4, 0x35, 0x40, 0x81, 0xa2, 0xe9, 0x63, 0x9f, 0xfa, 0xd0, 0xef, 0x50,
-	0x14, 0x7d, 0xe9, 0x77, 0xc8, 0x57, 0x29, 0xfa, 0x50, 0xcc, 0x85, 0x3b, 0x7b, 0x65, 0x1c, 0x90,
-	0x48, 0xdf, 0x76, 0xce, 0x9c, 0x39, 0xe7, 0xcc, 0x99, 0x33, 0x97, 0xf3, 0x3b, 0x0b, 0x0d, 0x8a,
-	0x7b, 0x24, 0xf4, 0x18, 0xa1, 0x97, 0xef, 0x87, 0x98, 0x9e, 0x7b, 0x2e, 0x5e, 0xed, 0x51, 0xc2,
-	0x08, 0x9a, 0x39, 0xf5, 0x98, 0xe3, 0x5f, 0x1a, 0xb5, 0xb0, 0xe3, 0x50, 0xdc, 0x96, 0x54, 0xf3,
-	0x08, 0x16, 0xad, 0x68, 0xc4, 0xd6, 0x97, 0x5e, 0xc8, 0x42, 0x0b, 0xbf, 0xee, 0xe3, 0x90, 0xa1,
-	0x0f, 0x01, 0xb4, 0xb0, 0x46, 0xe9, 0x6e, 0xe9, 0xd1, 0xec, 0x1a, 0x5a, 0x95, 0x52, 0x56, 0xf5,
-	0xa0, 0xe6, 0xd4, 0x9f, 0xff, 0xf5, 0xb8, 0x64, 0xc5, 0x78, 0xcd, 0x35, 0x68, 0x64, 0x85, 0x86,
-	0x3d, 0x12, 0x84, 0x18, 0xdd, 0x84, 0x19, 0x2c, 0x28, 0x42, 0x62, 0xc5, 0x52, 0x2d, 0xf3, 0x58,
-	0x8c, 0x71, 0xdc, 0xb3, 0xbd, 0xc0, 0xa5, 0xb8, 0x8b, 0x03, 0xe6, 0xf8, 0xa3, 0x5b, 0x72, 0x0b,
-	0x96, 0x72, 0xa4, 0x4a, 0x53, 0x4c, 0x0a, 0x73, 0xb2, 0x73, 0xbb, 0xef, 0x8f, 0xae, 0x0b, 0xdd,
-	0x87, 0xab, 0x2e, 0xc5, 0x0e, 0xc3, 0x76, 0xcb, 0x63, 0x5d, 0xa7, 0xd7, 0x98, 0x10, 0x13, 0xac,
-	0x49, 0x62, 0x53, 0xd0, 0xcc, 0x05, 0x40, 0x71, 0x9d, 0xca, 0x92, 0x73, 0xb8, 0xb1, 0xe3, 0xd0,
-	0x96, 0x73, 0x8a, 0x37, 0x88, 0xef, 0x63, 0x97, 0xfd, 0x48, 0xd6, 0x34, 0xe0, 0x66, 0x5a, 0xaf,
-	0xb2, 0xe8, 0x23, 0xb8, 0xb6, 0xe1, 0x63, 0x27, 0xe8, 0xf7, 0x46, 0x5f, 0x84, 0x39, 0xb8, 0x1e,
-	0xc9, 0x52, 0xe2, 0x3f, 0x86, 0x1b, 0x7a, 0xc8, 0x91, 0xf7, 0x15, 0x1e, 0x5d, 0xcb, 0x63, 0xb8,
-	0x99, 0x16, 0xa9, 0x42, 0x0e, 0xc1, 0x54, 0xe8, 0x7d, 0x85, 0x85, 0xb4, 0x49, 0x4b, 0x7c, 0x9b,
-	0xaf, 0x61, 0x69, 0xbd, 0xd7, 0xf3, 0x2f, 0x77, 0x3c, 0xe6, 0x30, 0x46, 0xbd, 0x56, 0x9f, 0xe1,
-	0xd1, 0x23, 0x1f, 0x19, 0x50, 0xa1, 0xf8, 0xdc, 0x0b, 0x3d, 0x12, 0x08, 0x87, 0xd7, 0xac, 0xa8,
-	0x6d, 0xde, 0x06, 0x23, 0x4f, 0xa5, 0xf2, 0xc8, 0x3f, 0x26, 0x00, 0x6d, 0x63, 0xe6, 0x76, 0x2c,
-	0xdc, 0x25, 0x6c, 0x74, 0x7f, 0xf0, 0x8d, 0x46, 0x85, 0x28, 0x61, 0x48, 0xd5, 0x52, 0x2d, 0xb4,
-	0x00, 0xd3, 0x27, 0x84, 0xba, 0xb8, 0x31, 0x29, 0x02, 0x42, 0x36, 0xd0, 0x22, 0x94, 0x03, 0x62,
-	0x33, 0xe7, 0x34, 0x6c, 0x4c, 0xc9, 0x7d, 0x19, 0x90, 0x63, 0xe7, 0x34, 0x44, 0x0d, 0x28, 0x33,
-	0xaf, 0x8b, 0x49, 0x9f, 0x35, 0xa6, 0xef, 0x96, 0x1e, 0x4d, 0x5b, 0x83, 0x26, 0x1f, 0x12, 0x86,
-	0x1d, 0xfb, 0x0c, 0x5f, 0x36, 0x66, 0xa4, 0x86, 0x30, 0xec, 0x3c, 0xc7, 0x97, 0x68, 0x05, 0x66,
-	0xcf, 0x02, 0x72, 0x11, 0xd8, 0x1d, 0xc2, 0xf7, 0x79, 0x59, 0x74, 0x82, 0x20, 0xed, 0x72, 0x0a,
-	0x5a, 0x82, 0x4a, 0x40, 0xec, 0x1e, 0xed, 0x07, 0xb8, 0x51, 0x15, 0xda, 0xca, 0x01, 0x39, 0xe4,
-	0x4d, 0xf4, 0x0c, 0xae, 0x4a, 0x3b, 0xed, 0x9e, 0x43, 0x9d, 0x6e, 0xd8, 0x00, 0x31, 0xe5, 0x6b,
-	0x7a, 0xca, 0xc2, 0x3b, 0x35, 0xc9, 0x74, 0x28, 0x78, 0x3e, 0x9a, 0xaa, 0x54, 0xea, 0x55, 0xf3,
-	0x06, 0xcc, 0x27, 0x1c, 0xa8, 0x1c, 0x7b, 0x04, 0x8b, 0x1b, 0x22, 0xe6, 0xb5, 0xb7, 0x46, 0x0f,
-	0x36, 0x03, 0x1a, 0x59, 0xa1, 0x4a, 0xe1, 0xd7, 0x13, 0x30, 0xb7, 0x83, 0xd9, 0x3a, 0x75, 0x3b,
-	0xde, 0xf9, 0x18, 0x16, 0xf2, 0x16, 0x54, 0x5d, 0xd2, 0xed, 0x7a, 0xcc, 0xf6, 0xda, 0x6a, 0x2d,
-	0x2b, 0x92, 0xb0, 0xd7, 0xe6, 0xab, 0xdc, 0xa3, 0xf8, 0xc4, 0xfb, 0x52, 0x2c, 0x67, 0xd5, 0x52,
-	0x2d, 0xf4, 0x21, 0xcc, 0x9c, 0x10, 0xda, 0x75, 0x98, 0x58, 0xce, 0x6b, 0x6b, 0x77, 0x07, 0xaa,
-	0x32, 0x96, 0xad, 0x6e, 0x0b, 0x3e, 0x4b, 0xf1, 0xf3, 0xdd, 0xd2, 0x73, 0x58, 0x47, 0xac, 0x76,
-	0xcd, 0x12, 0xdf, 0xe6, 0x33, 0x98, 0x91, 0x5c, 0xa8, 0x0c, 0x93, 0xaf, 0xf6, 0x0e, 0xeb, 0x57,
-	0xf8, 0xc7, 0xf1, 0xba, 0x55, 0x2f, 0x21, 0x80, 0x99, 0xe3, 0x75, 0xcb, 0xde, 0x79, 0x55, 0x9f,
-	0x40, 0xb3, 0x50, 0xe6, 0xdf, 0xcd, 0x57, 0x6b, 0xf5, 0x49, 0xf3, 0x11, 0xa0, 0xb8, 0x32, 0xbd,
-	0x19, 0xdb, 0x0e, 0x73, 0x84, 0x07, 0x6a, 0x96, 0xf8, 0xe6, 0x4b, 0xb4, 0xeb, 0x84, 0x2f, 0x88,
-	0xeb, 0xf8, 0x4d, 0xea, 0x04, 0x6e, 0x67, 0x0c, 0x5b, 0xd1, 0x7c, 0x0a, 0x8d, 0xac, 0x50, 0x65,
-	0xc4, 0x02, 0x4c, 0x9f, 0x3b, 0x7e, 0x1f, 0xab, 0x3b, 0x48, 0x36, 0xcc, 0xef, 0x4a, 0xd0, 0x10,
-	0x11, 0x74, 0x44, 0xfa, 0xd4, 0xc5, 0x72, 0xd4, 0xe8, 0xeb, 0xf7, 0x0b, 0x98, 0x0b, 0x85, 0x40,
-	0x3b, 0x26, 0x60, 0xa2, 0x48, 0x80, 0x55, 0x97, 0xcc, 0x56, 0xe2, 0x28, 0x57, 0x02, 0x5a, 0xc2,
-	0x24, 0xb1, 0xd4, 0x35, 0xab, 0x16, 0xc6, 0xcc, 0x44, 0xcb, 0x00, 0xcc, 0xa1, 0xa7, 0x98, 0xd9,
-	0x14, 0x9f, 0x88, 0x45, 0xaf, 0x59, 0x55, 0x49, 0xb1, 0xf0, 0x89, 0xf9, 0x0c, 0x96, 0x72, 0xa6,
-	0xa6, 0xef, 0x64, 0x8a, 0xc3, 0xbe, 0xcf, 0x06, 0x77, 0xb2, 0x6c, 0x99, 0x3b, 0x30, 0xbb, 0x1d,
-	0xba, 0x67, 0xa3, 0xaf, 0xc5, 0x03, 0xa8, 0x49, 0x41, 0xda, 0xff, 0x98, 0x52, 0x42, 0x55, 0x14,
-	0xc8, 0x86, 0xf9, 0x9f, 0x12, 0x5c, 0xff, 0x94, 0x7a, 0x7c, 0x53, 0x9d, 0x8c, 0xee, 0xf6, 0x3a,
-	0x4c, 0x72, 0x4f, 0xc8, 0x53, 0x98, 0x7f, 0x26, 0x0e, 0xe7, 0xc9, 0xe4, 0xe1, 0x8c, 0xee, 0x41,
-	0x8d, 0xf8, 0x6d, 0x3b, 0xea, 0x97, 0x0e, 0x9c, 0x25, 0x7e, 0xdb, 0x1a, 0xb0, 0x44, 0x07, 0xe7,
-	0x74, 0xfc, 0xe0, 0x6c, 0x42, 0x9d, 0x51, 0x27, 0x08, 0x1d, 0x97, 0x79, 0x24, 0xb0, 0x43, 0x86,
-	0x7b, 0xe2, 0xc4, 0x9b, 0x5d, 0x5b, 0x1c, 0x98, 0x79, 0xac, 0xfb, 0x8f, 0x18, 0xee, 0x59, 0xd7,
-	0x59, 0x92, 0xf0, 0xd1, 0x54, 0x65, 0xa6, 0x5e, 0x36, 0x7f, 0x05, 0x75, 0x3d, 0x7b, 0xe5, 0xa8,
-	0x3c, 0xe9, 0x13, 0x3f, 0x58, 0x7a, 0xa9, 0x3e, 0x61, 0x06, 0xb0, 0xb0, 0xed, 0x05, 0xed, 0x97,
-	0x98, 0x9e, 0xe2, 0xa6, 0x13, 0x8e, 0xe1, 0x5c, 0xba, 0x0d, 0xd5, 0x81, 0xbb, 0xc2, 0xc6, 0xc4,
-	0xdd, 0x49, 0x1e, 0x70, 0x11, 0xc1, 0x7c, 0x0f, 0x6e, 0xa4, 0xf4, 0xe9, 0x03, 0xa0, 0xe5, 0x84,
-	0x72, 0xeb, 0x55, 0x2d, 0xf1, 0x6d, 0x7e, 0x53, 0x82, 0x39, 0x79, 0x9e, 0x6e, 0x13, 0x7a, 0xf6,
-	0xbf, 0xdf, 0x72, 0xfc, 0x99, 0x16, 0xb7, 0x27, 0x7a, 0x30, 0x2e, 0xed, 0x85, 0x16, 0xe6, 0x26,
-	0xef, 0x05, 0x87, 0x94, 0x9c, 0x52, 0x1c, 0x86, 0x63, 0x39, 0xe0, 0xa9, 0x10, 0x1a, 0x3b, 0xe0,
-	0x25, 0x61, 0xaf, 0x6d, 0xfe, 0x1c, 0x8c, 0x3c, 0x9d, 0xca, 0x99, 0x2b, 0x30, 0xeb, 0x05, 0x76,
-	0x4f, 0x91, 0xd5, 0xf6, 0x05, 0x2f, 0x62, 0x94, 0x26, 0x1f, 0xbd, 0xee, 0x3b, 0x61, 0x67, 0xcc,
-	0x26, 0x87, 0x42, 0x68, 0xcc, 0x64, 0x49, 0x18, 0x98, 0x9c, 0xd5, 0xf9, 0xa6, 0x26, 0xfb, 0x70,
-	0x27, 0x7d, 0xb7, 0x6e, 0x53, 0xd2, 0xfd, 0xc4, 0x7a, 0x31, 0x96, 0x43, 0xa1, 0x4f, 0x7d, 0x65,
-	0x31, 0xff, 0x34, 0xef, 0xc1, 0x4a, 0xa1, 0x36, 0xb5, 0xec, 0x07, 0x30, 0x2f, 0x59, 0x9a, 0xfd,
-	0xa0, 0xed, 0x8f, 0xe1, 0xa9, 0xfa, 0x2e, 0x2c, 0x24, 0x05, 0x0e, 0xb9, 0x1b, 0xbf, 0x99, 0x80,
-	0xfa, 0x11, 0x66, 0x1b, 0x24, 0x38, 0xf1, 0x4e, 0x47, 0x77, 0xc0, 0x87, 0x50, 0xc6, 0x01, 0xa3,
-	0x1e, 0x96, 0x5b, 0x76, 0x76, 0xed, 0xce, 0x60, 0x58, 0x5a, 0xc9, 0xea, 0x56, 0xc0, 0xe8, 0xa5,
-	0x35, 0x60, 0x37, 0xbe, 0x2e, 0xc1, 0xb4, 0x20, 0x71, 0x27, 0xf2, 0x47, 0x9f, 0xdc, 0xc0, 0xfc,
-	0x13, 0x2d, 0x43, 0x55, 0x5c, 0xa1, 0x76, 0xc8, 0xa8, 0x74, 0xee, 0xee, 0x15, 0xab, 0x22, 0x48,
-	0x47, 0x8c, 0xa2, 0x7b, 0x30, 0x2b, 0xbb, 0xbd, 0x80, 0x3d, 0x5b, 0x13, 0x67, 0xef, 0xf4, 0xee,
-	0x15, 0x0b, 0x04, 0x71, 0x8f, 0xd3, 0xd0, 0x0a, 0xc8, 0x96, 0xdd, 0x22, 0xc4, 0x97, 0x4f, 0xd0,
-	0xdd, 0x2b, 0x96, 0x94, 0xda, 0x24, 0xc4, 0x6f, 0x96, 0xd5, 0x95, 0x6d, 0xce, 0xc3, 0x5c, 0xcc,
-	0x54, 0xb5, 0x44, 0x2e, 0xcc, 0x6f, 0x62, 0x1f, 0x33, 0x3c, 0x2e, 0x3f, 0x21, 0x98, 0x3a, 0xc3,
-	0x97, 0xd2, 0x49, 0x55, 0x4b, 0x7c, 0x9b, 0x37, 0x61, 0x21, 0xa9, 0x44, 0x29, 0xf7, 0x78, 0x92,
-	0x19, 0x32, 0x42, 0xf1, 0x46, 0x3f, 0x64, 0xa4, 0xbb, 0x4b, 0xc8, 0x59, 0x38, 0x16, 0x13, 0x44,
-	0x34, 0x4c, 0xc4, 0xa2, 0xe1, 0x36, 0x18, 0x79, 0xaa, 0x94, 0x21, 0xc7, 0xd0, 0x68, 0x3a, 0xee,
-	0x59, 0xbf, 0x37, 0x4e, 0x3b, 0xcc, 0x27, 0xb0, 0x94, 0x23, 0x75, 0x48, 0xc8, 0xbe, 0x86, 0x7b,
-	0x79, 0x5b, 0x6a, 0x4c, 0xbb, 0x27, 0xd7, 0x2f, 0x0f, 0xc0, 0x1c, 0xa6, 0x52, 0xf9, 0x67, 0x1f,
-	0x10, 0xbf, 0x93, 0x5e, 0x78, 0x2e, 0x0e, 0xc6, 0x70, 0x03, 0x9a, 0x1b, 0x30, 0x9f, 0x90, 0xa7,
-	0x7c, 0xf2, 0x18, 0x90, 0x2f, 0x49, 0x76, 0xd8, 0x21, 0x94, 0xd9, 0x81, 0xd3, 0x1d, 0xdc, 0x77,
-	0x75, 0xd5, 0x73, 0xc4, 0x3b, 0xf6, 0x9d, 0xae, 0x58, 0xb4, 0x1d, 0xcc, 0xf6, 0x82, 0x13, 0xb2,
-	0x3e, 0xbe, 0x44, 0xd4, 0xfc, 0x19, 0x2c, 0xe5, 0x48, 0x55, 0x06, 0xde, 0x01, 0xd0, 0x19, 0xa8,
-	0x5a, 0xba, 0x18, 0x85, 0x9b, 0xb4, 0xe1, 0xf8, 0x6e, 0xdf, 0x77, 0x18, 0xde, 0xe8, 0x60, 0xf7,
-	0x2c, 0xec, 0x77, 0x47, 0x37, 0xe9, 0xff, 0x61, 0x29, 0x47, 0xaa, 0x32, 0xc9, 0x80, 0x8a, 0xab,
-	0x68, 0xca, 0x53, 0x51, 0x9b, 0x2f, 0xdb, 0x0e, 0x66, 0x47, 0x81, 0xd3, 0x0b, 0x3b, 0x64, 0x74,
-	0x68, 0xc4, 0x7c, 0x07, 0xe6, 0x13, 0xf2, 0x86, 0x84, 0xf2, 0xb7, 0x25, 0xb8, 0x9f, 0x17, 0x58,
-	0x63, 0x33, 0x86, 0xe7, 0xc2, 0x1d, 0xc6, 0x7a, 0xb6, 0xbe, 0x96, 0xca, 0xbc, 0xfd, 0x09, 0xf5,
-	0xf9, 0x25, 0x2b, 0xba, 0x9c, 0x3e, 0xeb, 0xa8, 0xf4, 0x4e, 0xf0, 0xae, 0xf7, 0x59, 0xc7, 0x7c,
-	0x08, 0x0f, 0x86, 0x1b, 0xa6, 0x62, 0xfe, 0x4f, 0x25, 0x58, 0xd8, 0xc1, 0xcc, 0x72, 0x2e, 0x36,
-	0x3a, 0x4e, 0x70, 0x3a, 0x0e, 0x90, 0xe3, 0x3e, 0x5c, 0x3d, 0xa1, 0xa4, 0x6b, 0x27, 0x90, 0x8e,
-	0xaa, 0x55, 0xe3, 0xc4, 0xe8, 0xb5, 0xbc, 0x02, 0xb3, 0x8c, 0xd8, 0x89, 0xf7, 0x76, 0xd5, 0x02,
-	0x46, 0x06, 0x0c, 0xe6, 0xdf, 0xa7, 0xe0, 0x46, 0xca, 0x30, 0xb5, 0x10, 0xbb, 0x30, 0x4b, 0x9d,
-	0x0b, 0xdb, 0x95, 0xe4, 0x46, 0x49, 0xdc, 0x53, 0x6f, 0xc7, 0x12, 0xd8, 0xec, 0x98, 0xd5, 0x88,
-	0x64, 0x01, 0x8d, 0x7a, 0x8d, 0xef, 0x26, 0xa1, 0x1a, 0xf5, 0xa0, 0x45, 0x28, 0xb7, 0x7c, 0xd2,
-	0xe2, 0x4f, 0x16, 0x19, 0x62, 0x33, 0xbc, 0xb9, 0xd7, 0x8e, 0x00, 0xa2, 0x09, 0x0d, 0x10, 0xa1,
-	0x65, 0xa8, 0x04, 0xf8, 0xc2, 0x16, 0xa9, 0xb0, 0x30, 0xbe, 0x39, 0xd1, 0x28, 0x59, 0xe5, 0x00,
-	0x5f, 0x1c, 0x3a, 0x8c, 0xa7, 0x5b, 0x15, 0x9e, 0x2f, 0x88, 0xee, 0x29, 0xdd, 0x4d, 0xfc, 0xb6,
-	0xe8, 0x3e, 0x80, 0x2a, 0xe9, 0x61, 0xea, 0xf0, 0x47, 0xb8, 0xc8, 0x17, 0xae, 0xad, 0x7d, 0xf0,
-	0x86, 0x13, 0x58, 0x3d, 0x18, 0x0c, 0xb4, 0xb4, 0x0c, 0xee, 0x73, 0xee, 0x13, 0x2d, 0x54, 0x42,
-	0x2e, 0x35, 0xea, 0x5c, 0x44, 0xfc, 0x3c, 0x96, 0xb8, 0x51, 0x5d, 0xd2, 0xc6, 0x22, 0x07, 0x99,
-	0x16, 0x06, 0xbd, 0x24, 0x6d, 0x2c, 0x20, 0x17, 0x7c, 0x21, 0xbb, 0x2a, 0xb2, 0x2b, 0xc0, 0x17,
-	0xa2, 0xeb, 0x01, 0x5c, 0x1b, 0xcc, 0xd4, 0x6e, 0x5d, 0xf2, 0x13, 0xa1, 0x2a, 0xf3, 0x4b, 0x35,
-	0xd7, 0x26, 0xa7, 0x71, 0xae, 0xc1, 0x84, 0x15, 0x17, 0x48, 0x2e, 0x35, 0x65, 0xc1, 0x65, 0x7a,
-	0x50, 0xd5, 0xe6, 0xcc, 0x42, 0xf9, 0x93, 0xfd, 0xe7, 0xfb, 0x07, 0x9f, 0xee, 0xd7, 0xaf, 0xa0,
-	0x2a, 0x4c, 0xaf, 0x6f, 0x6e, 0x6e, 0x6d, 0x4a, 0xc4, 0x60, 0xe3, 0xe0, 0x70, 0x6f, 0x6b, 0x53,
-	0x22, 0x06, 0x9b, 0x5b, 0x2f, 0xb6, 0x8e, 0xb7, 0x36, 0xeb, 0x93, 0xa8, 0x06, 0x95, 0x97, 0x07,
-	0x9b, 0x7b, 0xdb, 0xbc, 0x6b, 0x8a, 0x77, 0x59, 0x5b, 0xfb, 0xeb, 0x2f, 0xb7, 0x36, 0xeb, 0xd3,
-	0xa8, 0x0e, 0xb5, 0xe3, 0xcf, 0x0e, 0xb7, 0xec, 0x8d, 0xdd, 0xf5, 0xfd, 0x9d, 0xad, 0xcd, 0xfa,
-	0x8c, 0xf9, 0x1b, 0x68, 0x1c, 0x61, 0x87, 0xba, 0x9d, 0x6d, 0xcf, 0xc7, 0x61, 0xf3, 0x92, 0x1f,
-	0xa6, 0xa3, 0xc7, 0xf6, 0x02, 0x4c, 0xbf, 0xee, 0x63, 0x95, 0x2d, 0x54, 0x2d, 0xd9, 0x18, 0xe4,
-	0x92, 0x93, 0x51, 0x2e, 0x69, 0x7e, 0x00, 0x4b, 0x39, 0xda, 0x75, 0x7a, 0x7b, 0xc2, 0xc9, 0x22,
-	0x74, 0x6b, 0x96, 0x6c, 0x98, 0x7f, 0x2b, 0xc1, 0xad, 0xc4, 0x98, 0x0d, 0x12, 0x30, 0x1c, 0xb0,
-	0x1f, 0xcd, 0x68, 0xf4, 0x0e, 0xd4, 0xdd, 0x4e, 0x3f, 0x38, 0xc3, 0x3c, 0xd1, 0x95, 0xb6, 0x2a,
-	0xb4, 0xef, 0xba, 0xa2, 0x47, 0xc7, 0xc6, 0x25, 0xdc, 0xce, 0xb7, 0x55, 0x4d, 0xb1, 0x01, 0xe5,
-	0xae, 0xc3, 0xdc, 0x4e, 0x34, 0xc9, 0x41, 0x13, 0x2d, 0x03, 0x88, 0x4f, 0x3b, 0x76, 0x49, 0x57,
-	0x05, 0x65, 0xd3, 0x61, 0x0e, 0xba, 0x0b, 0x35, 0x1c, 0xb4, 0x6d, 0x72, 0x62, 0x0b, 0x9a, 0x42,
-	0x21, 0x01, 0x07, 0xed, 0x83, 0x93, 0x97, 0x9c, 0x62, 0xfe, 0xa1, 0x04, 0x33, 0x12, 0xc3, 0x1b,
-	0x3c, 0xd7, 0x4b, 0xd1, 0x73, 0x9d, 0x6f, 0x55, 0x71, 0x9b, 0xca, 0x99, 0x8a, 0x6f, 0xf4, 0x53,
-	0x58, 0x8a, 0xce, 0x49, 0x42, 0xbd, 0xaf, 0x44, 0xf4, 0xd9, 0x1d, 0xec, 0xb4, 0x31, 0x55, 0x07,
-	0xcf, 0xe2, 0xe0, 0xdc, 0x8c, 0xfa, 0x77, 0x45, 0x37, 0x7a, 0x0b, 0xae, 0x75, 0x3d, 0x4a, 0x09,
-	0xb5, 0x29, 0x3e, 0xe9, 0x3a, 0xbd, 0xb0, 0x31, 0x25, 0x5e, 0x7c, 0x57, 0x25, 0xd5, 0x92, 0x44,
-	0xf3, 0x8f, 0x25, 0xb8, 0x29, 0xf0, 0x93, 0xdd, 0xe3, 0xe3, 0xc3, 0x71, 0x21, 0xb4, 0x0f, 0x13,
-	0x08, 0x6d, 0x16, 0xe4, 0x1c, 0x20, 0xb6, 0x31, 0x08, 0x76, 0x32, 0x01, 0xc1, 0x9a, 0x4b, 0xb0,
-	0x98, 0xb1, 0x4a, 0x2d, 0xe0, 0x67, 0xb0, 0xbc, 0x83, 0xd9, 0x41, 0xeb, 0xd7, 0xd8, 0x65, 0x9b,
-	0x1e, 0xc5, 0xee, 0xf8, 0x90, 0xf6, 0xff, 0x83, 0x3b, 0x45, 0xa2, 0x87, 0x20, 0xee, 0x7f, 0x29,
-	0xc1, 0xc2, 0x86, 0x4f, 0x02, 0xcc, 0xaf, 0xa9, 0x43, 0x42, 0xfc, 0x71, 0x38, 0x70, 0xaa, 0xc7,
-	0xd3, 0x85, 0x54, 0x66, 0x2f, 0x2d, 0x13, 0x2a, 0x44, 0x7f, 0xcc, 0xd1, 0x93, 0xc3, 0x1c, 0x6d,
-	0x2e, 0xc2, 0x8d, 0x94, 0x85, 0xca, 0x99, 0xff, 0x2c, 0xc1, 0xed, 0x44, 0xcf, 0x5e, 0xc0, 0x30,
-	0x0d, 0x9c, 0x1f, 0x71, 0x0e, 0xb9, 0x90, 0xc6, 0xe4, 0x0f, 0x80, 0x34, 0x56, 0x60, 0xb9, 0x60,
-	0x0a, 0x1a, 0x28, 0xe7, 0xfe, 0x38, 0x1f, 0x37, 0x50, 0x9e, 0x15, 0xaa, 0x14, 0x7e, 0xc9, 0x15,
-	0x06, 0xe2, 0xe0, 0x1c, 0x9b, 0x42, 0x71, 0x51, 0x62, 0xdf, 0x61, 0xde, 0x39, 0x96, 0xb7, 0xb3,
-	0x7a, 0x9c, 0x0c, 0x88, 0xfc, 0xae, 0x92, 0x56, 0xa5, 0x35, 0x2b, 0xab, 0x7e, 0x5f, 0xe2, 0x39,
-	0x56, 0xcf, 0xf7, 0xdc, 0xf1, 0xd6, 0x0c, 0xd0, 0xbb, 0x30, 0x23, 0x17, 0x65, 0x08, 0x12, 0xa5,
-	0x38, 0xcc, 0x65, 0xb8, 0x95, 0x6b, 0x83, 0xb4, 0x71, 0xed, 0xaf, 0xcb, 0xa2, 0x74, 0x39, 0x28,
-	0x76, 0xc9, 0x3a, 0x2f, 0xfa, 0x1c, 0xea, 0xe9, 0xb2, 0x2b, 0x5a, 0xc9, 0x2a, 0x49, 0x54, 0x79,
-	0x8d, 0xbb, 0xc5, 0x0c, 0xca, 0x21, 0x33, 0xff, 0xfe, 0xf6, 0xd1, 0x44, 0x65, 0x02, 0x7d, 0x31,
-	0x28, 0x97, 0xc6, 0x6a, 0xa9, 0x28, 0x3e, 0x3c, 0xb7, 0x78, 0x6b, 0xdc, 0x1b, 0xc2, 0x91, 0xd0,
-	0x50, 0x42, 0xcf, 0x01, 0x74, 0x71, 0x14, 0x2d, 0x25, 0x07, 0xc6, 0x8a, 0xb4, 0x86, 0x91, 0xd7,
-	0x95, 0x12, 0xf6, 0x29, 0x5c, 0x4b, 0xd6, 0x36, 0xd1, 0x72, 0xf4, 0x02, 0xcb, 0xab, 0xb5, 0x1a,
-	0x77, 0x8a, 0xba, 0xb3, 0x82, 0x93, 0x85, 0x46, 0x2d, 0x38, 0xb7, 0xa6, 0xa9, 0x05, 0xe7, 0xd7,
-	0x27, 0x23, 0xc1, 0x2e, 0xa0, 0x6c, 0x81, 0x10, 0x45, 0xfe, 0x2b, 0xac, 0x57, 0x1a, 0xe6, 0x30,
-	0x96, 0x94, 0x92, 0x7d, 0x98, 0x8d, 0x55, 0xc9, 0x50, 0xe4, 0xc9, 0x6c, 0xed, 0xd1, 0xb8, 0x95,
-	0xdb, 0x97, 0x92, 0xf7, 0x39, 0xd4, 0xd3, 0x79, 0x88, 0x0e, 0xba, 0x82, 0xc2, 0x9b, 0x0e, 0xba,
-	0xc2, 0x22, 0xda, 0x40, 0xfc, 0x4b, 0x00, 0x5d, 0x44, 0xd2, 0x21, 0x91, 0xa9, 0x62, 0xe9, 0x90,
-	0xc8, 0xd6, 0x9c, 0x06, 0xc2, 0x9e, 0x0a, 0x6b, 0xd3, 0x45, 0x21, 0x6d, 0x6d, 0x41, 0x0d, 0x4a,
-	0x5b, 0x5b, 0x54, 0x4f, 0x8a, 0x6f, 0x91, 0x4c, 0x95, 0x45, 0x6f, 0x91, 0xa2, 0xda, 0x92, 0xde,
-	0x22, 0x85, 0x25, 0x9a, 0xc8, 0x1f, 0x3f, 0x81, 0xa9, 0xed, 0xd0, 0x3d, 0x43, 0xf3, 0xd1, 0x10,
-	0x5d, 0xa0, 0x31, 0x16, 0x92, 0xc4, 0xd4, 0xd0, 0x2d, 0xa8, 0x0c, 0xea, 0x0b, 0x28, 0xaa, 0x1e,
-	0xa4, 0xea, 0x2d, 0x46, 0x23, 0xdb, 0x91, 0x12, 0x73, 0x0c, 0x57, 0x13, 0xc0, 0x3e, 0xba, 0x1d,
-	0x69, 0xcd, 0xa9, 0x2f, 0x18, 0xcb, 0x05, 0xbd, 0x29, 0xcf, 0x3d, 0x07, 0xd0, 0x80, 0xbb, 0x5e,
-	0xe7, 0x4c, 0x51, 0x40, 0xaf, 0x73, 0x0e, 0x3e, 0x1f, 0xdb, 0x48, 0x59, 0xcc, 0x5c, 0x6f, 0xa4,
-	0x42, 0x0c, 0x5f, 0x6f, 0xa4, 0x62, 0xc8, 0x3d, 0xb2, 0x58, 0x28, 0x49, 0xa3, 0xdc, 0x71, 0x25,
-	0x05, 0xa8, 0x7b, 0x5c, 0x49, 0x11, 0x48, 0x1e, 0x29, 0xa1, 0xd9, 0xe2, 0xb5, 0x42, 0xa7, 0xd1,
-	0xc3, 0xa2, 0x3d, 0x94, 0x04, 0xcb, 0x8d, 0xb7, 0xbf, 0x97, 0x2f, 0xe5, 0xbd, 0x23, 0xa8, 0xc5,
-	0xd1, 0x69, 0x74, 0x2b, 0x29, 0x20, 0x01, 0xe3, 0x19, 0xb7, 0xf3, 0x3b, 0x93, 0xd3, 0x78, 0x5a,
-	0x42, 0xbf, 0x05, 0xa3, 0x18, 0xa0, 0x43, 0xef, 0x0c, 0xb3, 0x31, 0xa9, 0xf0, 0xdd, 0x37, 0x61,
-	0x4d, 0xce, 0xe8, 0x51, 0x09, 0xed, 0x42, 0x35, 0x02, 0x8d, 0x51, 0xa3, 0x08, 0xf2, 0x36, 0x96,
-	0x72, 0x7a, 0x52, 0xde, 0xf9, 0x18, 0x6a, 0x71, 0x10, 0x58, 0x7b, 0x27, 0x07, 0x7f, 0xd6, 0xde,
-	0xc9, 0xc5, 0x8d, 0xe3, 0x47, 0xb2, 0x86, 0x11, 0x63, 0x47, 0x72, 0x06, 0xab, 0x8c, 0x1d, 0xc9,
-	0x59, 0xdc, 0x31, 0x0a, 0x9a, 0x96, 0xf8, 0xff, 0x20, 0x89, 0xfd, 0xa1, 0xf8, 0x0f, 0x00, 0xb9,
-	0x60, 0xa3, 0x3e, 0x85, 0x0a, 0x81, 0xc3, 0xd8, 0x7a, 0x7e, 0x01, 0x73, 0x19, 0x30, 0x4f, 0xeb,
-	0x28, 0x42, 0x0f, 0xb5, 0x8e, 0x42, 0x24, 0x30, 0x9a, 0x45, 0x13, 0xca, 0xea, 0xaf, 0x21, 0x74,
-	0x33, 0x1a, 0x95, 0xf8, 0x25, 0xc9, 0x58, 0xcc, 0xd0, 0x53, 0x9e, 0x3d, 0x84, 0xd9, 0x18, 0xd2,
-	0x87, 0xe2, 0x77, 0x44, 0x0a, 0xc1, 0xd3, 0x9e, 0xcd, 0x81, 0x06, 0x63, 0xf3, 0xfe, 0x1d, 0xcf,
-	0x04, 0x86, 0xe0, 0x6e, 0xe8, 0xbd, 0x61, 0xf1, 0x99, 0x56, 0xfa, 0xf8, 0xcd, 0x98, 0x53, 0xb3,
-	0xfa, 0x25, 0x5c, 0x4d, 0x60, 0x48, 0xfa, 0x04, 0xce, 0x03, 0xfa, 0xf4, 0x09, 0x9c, 0x0b, 0x3c,
-	0xc5, 0xe6, 0x76, 0x06, 0x0b, 0x79, 0x39, 0x3f, 0xba, 0xaf, 0x77, 0x45, 0x21, 0x7a, 0x61, 0x3c,
-	0x18, 0xce, 0x94, 0x51, 0xd6, 0x82, 0xb9, 0x0c, 0x80, 0xa2, 0x03, 0xa8, 0x08, 0xd9, 0xd1, 0x01,
-	0x54, 0x88, 0xbe, 0xc4, 0x74, 0x60, 0x40, 0xd9, 0x6a, 0x09, 0x8a, 0x3d, 0x48, 0x0b, 0x8a, 0x36,
-	0xfa, 0x88, 0x1e, 0x52, 0x6c, 0xd1, 0x87, 0x4b, 0x0b, 0xe6, 0x32, 0x05, 0x12, 0x3d, 0x95, 0xa2,
-	0x8a, 0x8c, 0x9e, 0x4a, 0x61, 0x75, 0x25, 0x36, 0x95, 0x57, 0x70, 0x3d, 0x95, 0xe9, 0xa3, 0x3b,
-	0x89, 0x57, 0x43, 0x06, 0x98, 0x30, 0x56, 0x0a, 0xfb, 0x53, 0xf1, 0x44, 0xe0, 0x66, 0x7e, 0x3e,
-	0x8f, 0xde, 0x8a, 0x85, 0x4e, 0x31, 0x94, 0x60, 0x3c, 0xfc, 0x3e, 0xb6, 0xd4, 0xd6, 0x3e, 0x86,
-	0xab, 0x89, 0x54, 0x54, 0x07, 0x70, 0x1e, 0x40, 0xa0, 0x03, 0x38, 0x3f, 0x39, 0x1f, 0x4c, 0xc3,
-	0x4f, 0x65, 0xef, 0x83, 0x04, 0x17, 0x3d, 0xc8, 0x1d, 0x9f, 0x4a, 0xe1, 0x8d, 0xb7, 0xbe, 0x87,
-	0x2b, 0xfb, 0xee, 0x4d, 0x27, 0xb6, 0xf1, 0x64, 0x2b, 0x37, 0x8f, 0x8e, 0x27, 0x5b, 0x05, 0x39,
-	0x71, 0x42, 0x7c, 0x32, 0x43, 0x8d, 0x8b, 0xcf, 0xcd, 0x9a, 0xe3, 0xe2, 0x0b, 0x92, 0xdb, 0x81,
-	0xf8, 0x13, 0x98, 0xcf, 0xc9, 0x2f, 0x51, 0x2c, 0xee, 0x8b, 0x12, 0x60, 0xe3, 0xfe, 0x50, 0x9e,
-	0xa4, 0x9e, 0xe6, 0xd3, 0x57, 0x9c, 0xdb, 0x77, 0x5a, 0xab, 0x2e, 0xe9, 0x3e, 0x91, 0x9f, 0xef,
-	0x13, 0x7a, 0xfa, 0x44, 0xca, 0x78, 0x22, 0x7e, 0x42, 0x7e, 0x72, 0x4a, 0x54, 0xbb, 0xd7, 0x6a,
-	0xcd, 0x08, 0xd2, 0xb3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x92, 0xb6, 0xfd, 0x86, 0xc9, 0x2c,
-	0x00, 0x00,
+	// 2949 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdd, 0x6f, 0x1b, 0xc7,
+	0x11, 0x37, 0xa9, 0x0f, 0x92, 0x43, 0xda, 0xa6, 0x56, 0xb2, 0x45, 0x9d, 0x2d, 0xcb, 0x3e, 0x3b,
+	0x8e, 0x93, 0x38, 0xb2, 0x63, 0xb7, 0x68, 0xda, 0xa2, 0x28, 0x44, 0x7d, 0xc7, 0xb6, 0xa4, 0x9c,
+	0x94, 0x06, 0x31, 0x10, 0x5c, 0x8e, 0xc7, 0xa5, 0x78, 0xd5, 0xf1, 0x96, 0xde, 0x5b, 0x5a, 0x51,
+	0xd0, 0x3e, 0xb4, 0x40, 0x5e, 0x03, 0x14, 0x28, 0x9a, 0x3e, 0xf6, 0xa9, 0x0f, 0xfd, 0x1f, 0x8a,
+	0xa2, 0x2f, 0xfd, 0x1f, 0xf2, 0x57, 0xf4, 0xbd, 0x4f, 0xc5, 0x7e, 0xdc, 0xf7, 0x1d, 0xe3, 0x82,
+	0x44, 0xfa, 0x76, 0x3b, 0x3b, 0x3b, 0x33, 0x3b, 0x3b, 0xfb, 0x31, 0xbf, 0x39, 0x68, 0x51, 0x3c,
+	0x24, 0xbe, 0xc3, 0x08, 0xbd, 0x78, 0xdf, 0xc7, 0xf4, 0xb5, 0x63, 0xe3, 0xf5, 0x21, 0x25, 0x8c,
+	0xa0, 0xf9, 0x53, 0x87, 0x59, 0xee, 0x85, 0xd6, 0xf0, 0xfb, 0x16, 0xc5, 0x5d, 0x49, 0xd5, 0x8f,
+	0x61, 0xd9, 0x08, 0x47, 0x6c, 0x7f, 0xe9, 0xf8, 0xcc, 0x37, 0xf0, 0xab, 0x11, 0xf6, 0x19, 0xfa,
+	0x10, 0x20, 0x12, 0xd6, 0x2a, 0xdd, 0x2e, 0x3d, 0xa8, 0x3f, 0x41, 0xeb, 0x52, 0xca, 0x7a, 0x34,
+	0xa8, 0x3d, 0xfb, 0xe7, 0x7f, 0x3d, 0x2c, 0x19, 0x31, 0x5e, 0xfd, 0x09, 0xb4, 0xb2, 0x42, 0xfd,
+	0x21, 0xf1, 0x7c, 0x8c, 0xae, 0xc3, 0x3c, 0x16, 0x14, 0x21, 0xb1, 0x6a, 0xa8, 0x96, 0x7e, 0x22,
+	0xc6, 0x58, 0xf6, 0xd9, 0xbe, 0x67, 0x53, 0x3c, 0xc0, 0x1e, 0xb3, 0xdc, 0xc9, 0x2d, 0xb9, 0x01,
+	0x2b, 0x39, 0x52, 0xa5, 0x29, 0x3a, 0x85, 0x05, 0xd9, 0xb9, 0x33, 0x72, 0x27, 0xd7, 0x85, 0xee,
+	0xc2, 0x65, 0x9b, 0x62, 0x8b, 0x61, 0xb3, 0xe3, 0xb0, 0x81, 0x35, 0x6c, 0x95, 0xc5, 0x04, 0x1b,
+	0x92, 0xd8, 0x16, 0x34, 0x7d, 0x09, 0x50, 0x5c, 0xa7, 0xb2, 0xe4, 0x35, 0x5c, 0xdb, 0xb5, 0x68,
+	0xc7, 0x3a, 0xc5, 0x9b, 0xc4, 0x75, 0xb1, 0xcd, 0x7e, 0x20, 0x6b, 0x5a, 0x70, 0x3d, 0xad, 0x57,
+	0x59, 0xf4, 0x11, 0x5c, 0xd9, 0x74, 0xb1, 0xe5, 0x8d, 0x86, 0x93, 0x2f, 0xc2, 0x02, 0x5c, 0x0d,
+	0x65, 0x29, 0xf1, 0x1f, 0xc3, 0xb5, 0x68, 0xc8, 0xb1, 0xf3, 0x15, 0x9e, 0x5c, 0xcb, 0x43, 0xb8,
+	0x9e, 0x16, 0xa9, 0x42, 0x0e, 0xc1, 0xac, 0xef, 0x7c, 0x85, 0x85, 0xb4, 0x19, 0x43, 0x7c, 0xeb,
+	0xaf, 0x60, 0x65, 0x63, 0x38, 0x74, 0x2f, 0x76, 0x1d, 0x66, 0x31, 0x46, 0x9d, 0xce, 0x88, 0xe1,
+	0xc9, 0x23, 0x1f, 0x69, 0x50, 0xa5, 0xf8, 0xb5, 0xe3, 0x3b, 0xc4, 0x13, 0x0e, 0x6f, 0x18, 0x61,
+	0x5b, 0xbf, 0x09, 0x5a, 0x9e, 0x4a, 0xe5, 0x91, 0x7f, 0x94, 0x01, 0xed, 0x60, 0x66, 0xf7, 0x0d,
+	0x3c, 0x20, 0x6c, 0x72, 0x7f, 0xf0, 0x8d, 0x46, 0x85, 0x28, 0x61, 0x48, 0xcd, 0x50, 0x2d, 0xb4,
+	0x04, 0x73, 0x3d, 0x42, 0x6d, 0xdc, 0x9a, 0x11, 0x01, 0x21, 0x1b, 0x68, 0x19, 0x2a, 0x1e, 0x31,
+	0x99, 0x75, 0xea, 0xb7, 0x66, 0xe5, 0xbe, 0xf4, 0xc8, 0x89, 0x75, 0xea, 0xa3, 0x16, 0x54, 0x98,
+	0x33, 0xc0, 0x64, 0xc4, 0x5a, 0x73, 0xb7, 0x4b, 0x0f, 0xe6, 0x8c, 0xa0, 0xc9, 0x87, 0xf8, 0x7e,
+	0xdf, 0x3c, 0xc3, 0x17, 0xad, 0x79, 0xa9, 0xc1, 0xf7, 0xfb, 0xcf, 0xf0, 0x05, 0x5a, 0x83, 0xfa,
+	0x99, 0x47, 0xce, 0x3d, 0xb3, 0x4f, 0xf8, 0x3e, 0xaf, 0x88, 0x4e, 0x10, 0xa4, 0x3d, 0x4e, 0x41,
+	0x2b, 0x50, 0xf5, 0x88, 0x39, 0xa4, 0x23, 0x0f, 0xb7, 0x6a, 0x42, 0x5b, 0xc5, 0x23, 0x47, 0xbc,
+	0x89, 0x9e, 0xc2, 0x65, 0x69, 0xa7, 0x39, 0xb4, 0xa8, 0x35, 0xf0, 0x5b, 0x20, 0xa6, 0x7c, 0x25,
+	0x9a, 0xb2, 0xf0, 0x4e, 0x43, 0x32, 0x1d, 0x09, 0x9e, 0x8f, 0x66, 0xab, 0xd5, 0x66, 0x4d, 0xbf,
+	0x06, 0x8b, 0x09, 0x07, 0x2a, 0xc7, 0x1e, 0xc3, 0xf2, 0xa6, 0x88, 0xf9, 0xc8, 0x5b, 0x93, 0x07,
+	0x9b, 0x06, 0xad, 0xac, 0x50, 0xa5, 0xf0, 0xeb, 0x32, 0x2c, 0xec, 0x62, 0xb6, 0x41, 0xed, 0xbe,
+	0xf3, 0x7a, 0x0a, 0x0b, 0x79, 0x03, 0x6a, 0x36, 0x19, 0x0c, 0x1c, 0x66, 0x3a, 0x5d, 0xb5, 0x96,
+	0x55, 0x49, 0xd8, 0xef, 0xf2, 0x55, 0x1e, 0x52, 0xdc, 0x73, 0xbe, 0x14, 0xcb, 0x59, 0x33, 0x54,
+	0x0b, 0x7d, 0x08, 0xf3, 0x3d, 0x42, 0x07, 0x16, 0x13, 0xcb, 0x79, 0xe5, 0xc9, 0xed, 0x40, 0x55,
+	0xc6, 0xb2, 0xf5, 0x1d, 0xc1, 0x67, 0x28, 0x7e, 0xbe, 0x5b, 0x86, 0x16, 0xeb, 0x8b, 0xd5, 0x6e,
+	0x18, 0xe2, 0x5b, 0x7f, 0x0a, 0xf3, 0x92, 0x0b, 0x55, 0x60, 0xe6, 0xe5, 0xfe, 0x51, 0xf3, 0x12,
+	0xff, 0x38, 0xd9, 0x30, 0x9a, 0x25, 0x04, 0x30, 0x7f, 0xb2, 0x61, 0x98, 0xbb, 0x2f, 0x9b, 0x65,
+	0x54, 0x87, 0x0a, 0xff, 0x6e, 0xbf, 0x7c, 0xd2, 0x9c, 0xd1, 0x1f, 0x00, 0x8a, 0x2b, 0x8b, 0x36,
+	0x63, 0xd7, 0x62, 0x96, 0xf0, 0x40, 0xc3, 0x10, 0xdf, 0x7c, 0x89, 0xf6, 0x2c, 0xff, 0x39, 0xb1,
+	0x2d, 0xb7, 0x4d, 0x2d, 0xcf, 0xee, 0x4f, 0x61, 0x2b, 0xea, 0x8f, 0xa1, 0x95, 0x15, 0xaa, 0x8c,
+	0x58, 0x82, 0xb9, 0xd7, 0x96, 0x3b, 0xc2, 0xea, 0x0e, 0x92, 0x0d, 0xfd, 0xbb, 0x12, 0xb4, 0x44,
+	0x04, 0x1d, 0x93, 0x11, 0xb5, 0xb1, 0x1c, 0x35, 0xf9, 0xfa, 0xfd, 0x12, 0x16, 0x7c, 0x21, 0xd0,
+	0x8c, 0x09, 0x28, 0x17, 0x09, 0x30, 0x9a, 0x92, 0xd9, 0x48, 0x1c, 0xe5, 0x4a, 0x40, 0x47, 0x98,
+	0x24, 0x96, 0xba, 0x61, 0x34, 0xfc, 0x98, 0x99, 0x68, 0x15, 0x80, 0x59, 0xf4, 0x14, 0x33, 0x93,
+	0xe2, 0x9e, 0x58, 0xf4, 0x86, 0x51, 0x93, 0x14, 0x03, 0xf7, 0xf4, 0xa7, 0xb0, 0x92, 0x33, 0xb5,
+	0xe8, 0x4e, 0xa6, 0xd8, 0x1f, 0xb9, 0x2c, 0xb8, 0x93, 0x65, 0x4b, 0xdf, 0x85, 0xfa, 0x8e, 0x6f,
+	0x9f, 0x4d, 0xbe, 0x16, 0xf7, 0xa0, 0x21, 0x05, 0x45, 0xfe, 0xc7, 0x94, 0x12, 0xaa, 0xa2, 0x40,
+	0x36, 0xf4, 0x7f, 0x97, 0xe0, 0xea, 0xa7, 0xd4, 0xe1, 0x9b, 0xaa, 0x37, 0xb9, 0xdb, 0x9b, 0x30,
+	0xc3, 0x3d, 0x21, 0x4f, 0x61, 0xfe, 0x99, 0x38, 0x9c, 0x67, 0x92, 0x87, 0x33, 0xba, 0x03, 0x0d,
+	0xe2, 0x76, 0xcd, 0xb0, 0x5f, 0x3a, 0xb0, 0x4e, 0xdc, 0xae, 0x11, 0xb0, 0x84, 0x07, 0xe7, 0x5c,
+	0xfc, 0xe0, 0xfc, 0x31, 0xd4, 0x19, 0xb5, 0x3c, 0xdf, 0xb2, 0x19, 0x1f, 0x57, 0x11, 0x16, 0x2e,
+	0x06, 0x16, 0x9e, 0x44, 0x5d, 0x46, 0x9c, 0xef, 0xa3, 0xd9, 0xea, 0x7c, 0xb3, 0xa2, 0x1f, 0x42,
+	0x33, 0x9a, 0xb0, 0xf2, 0x4d, 0x4a, 0x60, 0xf9, 0x8d, 0x05, 0x96, 0x9a, 0x65, 0xdd, 0x83, 0xa5,
+	0x1d, 0xc7, 0xeb, 0xbe, 0xc0, 0xf4, 0x14, 0xb7, 0x2d, 0x7f, 0x0a, 0xa7, 0xcf, 0x4d, 0xa8, 0x05,
+	0x4e, 0xf1, 0x5b, 0xe5, 0xdb, 0x33, 0x3c, 0xac, 0x42, 0x82, 0xfe, 0x1e, 0x5c, 0x4b, 0xe9, 0x8b,
+	0xb6, 0x79, 0xc7, 0xf2, 0xe5, 0x06, 0xab, 0x19, 0xe2, 0x5b, 0xff, 0xa6, 0x04, 0x0b, 0xf2, 0xd4,
+	0xdc, 0x21, 0xf4, 0xec, 0xff, 0xbf, 0xb1, 0xf8, 0x63, 0x2c, 0x6e, 0x4f, 0xf8, 0x2c, 0x5c, 0xd9,
+	0xf7, 0x0d, 0xcc, 0x4d, 0xde, 0xf7, 0x8e, 0x28, 0x39, 0xa5, 0xd8, 0xf7, 0xa7, 0x72, 0x8c, 0x53,
+	0x21, 0x34, 0x76, 0x8c, 0x4b, 0xc2, 0x7e, 0x57, 0xff, 0x05, 0x68, 0x79, 0x3a, 0x95, 0x33, 0xd7,
+	0xa0, 0xee, 0x78, 0xe6, 0x50, 0x91, 0xd5, 0x26, 0x05, 0x27, 0x64, 0x94, 0x26, 0x1f, 0xbf, 0x1a,
+	0x59, 0x7e, 0x7f, 0xca, 0x26, 0xfb, 0x42, 0x68, 0xcc, 0x64, 0x49, 0x08, 0x4c, 0xce, 0xea, 0x7c,
+	0x53, 0x93, 0x5d, 0xb8, 0x95, 0xbe, 0x41, 0x77, 0x28, 0x19, 0x7c, 0x62, 0x3c, 0x9f, 0xca, 0xd6,
+	0x1f, 0x51, 0x57, 0x59, 0xcc, 0x3f, 0xf5, 0x3b, 0xb0, 0x56, 0xa8, 0x4d, 0x2d, 0xfb, 0x21, 0x2c,
+	0x4a, 0x96, 0xf6, 0xc8, 0xeb, 0xba, 0x53, 0x78, 0x90, 0xbe, 0x0b, 0x4b, 0x49, 0x81, 0x63, 0x6e,
+	0xc0, 0x6f, 0xca, 0xd0, 0x3c, 0xc6, 0x6c, 0x93, 0x78, 0x3d, 0xe7, 0x74, 0x72, 0x07, 0x7c, 0x08,
+	0x15, 0xec, 0x31, 0xea, 0x60, 0xb9, 0x65, 0xeb, 0x4f, 0x6e, 0x05, 0xc3, 0xd2, 0x4a, 0xd6, 0xb7,
+	0x3d, 0x46, 0x2f, 0x8c, 0x80, 0x5d, 0xfb, 0xba, 0x04, 0x73, 0x82, 0xc4, 0x9d, 0xc8, 0x9f, 0x76,
+	0x72, 0x03, 0xf3, 0x4f, 0xb4, 0x0a, 0x35, 0x71, 0x51, 0x9a, 0x3e, 0xa3, 0xd2, 0xb9, 0x7b, 0x97,
+	0x8c, 0xaa, 0x20, 0x1d, 0x33, 0x8a, 0xee, 0x40, 0x5d, 0x76, 0x3b, 0x1e, 0x7b, 0xfa, 0x44, 0x9c,
+	0xb0, 0x73, 0x7b, 0x97, 0x0c, 0x10, 0xc4, 0x7d, 0x4e, 0x43, 0x6b, 0x20, 0x5b, 0x66, 0x87, 0x10,
+	0x57, 0x3e, 0x34, 0xf7, 0x2e, 0x19, 0x52, 0x6a, 0x9b, 0x10, 0xb7, 0x5d, 0x51, 0x17, 0xb3, 0xbe,
+	0x08, 0x0b, 0x31, 0x53, 0xd5, 0x12, 0xd9, 0xb0, 0xb8, 0x85, 0x5d, 0xcc, 0xf0, 0xb4, 0xfc, 0x84,
+	0x60, 0xf6, 0x0c, 0x5f, 0x48, 0x27, 0xd5, 0x0c, 0xf1, 0xad, 0x5f, 0x87, 0xa5, 0xa4, 0x12, 0xa5,
+	0xdc, 0xe1, 0xa9, 0xa4, 0xcf, 0x08, 0xc5, 0x9b, 0x23, 0x9f, 0x91, 0xc1, 0x1e, 0x21, 0x67, 0xfe,
+	0x54, 0x4c, 0x10, 0xd1, 0x50, 0x8e, 0x45, 0xc3, 0x4d, 0xd0, 0xf2, 0x54, 0x29, 0x43, 0x4e, 0xa0,
+	0xd5, 0xb6, 0xec, 0xb3, 0xd1, 0x70, 0x9a, 0x76, 0xe8, 0x8f, 0x60, 0x25, 0x47, 0xea, 0x98, 0x90,
+	0x7d, 0x05, 0x77, 0xf2, 0xb6, 0xd4, 0x94, 0x76, 0x4f, 0xae, 0x5f, 0xee, 0x81, 0x3e, 0x4e, 0xa5,
+	0xf2, 0xcf, 0x01, 0x20, 0x7e, 0x27, 0x3d, 0x77, 0x6c, 0xec, 0x4d, 0xe1, 0x06, 0xd4, 0x37, 0x61,
+	0x31, 0x21, 0x4f, 0xf9, 0xe4, 0x21, 0x20, 0x57, 0x92, 0x4c, 0xbf, 0x4f, 0x28, 0x33, 0x3d, 0x6b,
+	0x10, 0xdc, 0x77, 0x4d, 0xd5, 0x73, 0xcc, 0x3b, 0x0e, 0xac, 0x81, 0x58, 0xb4, 0x5d, 0xcc, 0xf6,
+	0xbd, 0x1e, 0xd9, 0x98, 0x5e, 0xba, 0xa9, 0xff, 0x1c, 0x56, 0x72, 0xa4, 0x2a, 0x03, 0x6f, 0x01,
+	0x44, 0x79, 0xa6, 0x5a, 0xba, 0x18, 0x85, 0x9b, 0xb4, 0x69, 0xb9, 0xf6, 0xc8, 0xb5, 0x18, 0xde,
+	0xec, 0x63, 0xfb, 0xcc, 0x1f, 0x0d, 0x26, 0x37, 0xe9, 0x27, 0xb0, 0x92, 0x23, 0x55, 0x99, 0xa4,
+	0x41, 0xd5, 0x56, 0x34, 0xe5, 0xa9, 0xb0, 0xcd, 0x97, 0x6d, 0x17, 0xb3, 0x63, 0xcf, 0x1a, 0xfa,
+	0x7d, 0x32, 0x39, 0x00, 0xa2, 0xbf, 0x03, 0x8b, 0x09, 0x79, 0x63, 0x42, 0xf9, 0xdb, 0x12, 0xdc,
+	0xcd, 0x0b, 0xac, 0xa9, 0x19, 0xc3, 0x33, 0xde, 0x3e, 0x63, 0x43, 0x33, 0xba, 0x96, 0x2a, 0xbc,
+	0xfd, 0x09, 0x75, 0xf9, 0x25, 0x2b, 0xba, 0xac, 0x11, 0xeb, 0xab, 0x24, 0x4e, 0xf0, 0x6e, 0x8c,
+	0x58, 0x5f, 0xbf, 0x0f, 0xf7, 0xc6, 0x1b, 0xa6, 0x62, 0xfe, 0x4f, 0x25, 0x58, 0xda, 0xc5, 0xcc,
+	0xb0, 0xce, 0x37, 0xfb, 0x96, 0x77, 0x3a, 0x0d, 0x28, 0xe3, 0x2e, 0x5c, 0xee, 0x51, 0x32, 0x30,
+	0x13, 0x78, 0x46, 0xcd, 0x68, 0x70, 0x62, 0xf8, 0x26, 0x5e, 0x83, 0x3a, 0x23, 0x66, 0xe2, 0x55,
+	0x5d, 0x33, 0x80, 0x91, 0x80, 0x41, 0xff, 0xfb, 0x2c, 0x5c, 0x4b, 0x19, 0xa6, 0x16, 0x62, 0x0f,
+	0xea, 0xd4, 0x3a, 0x37, 0x6d, 0x49, 0x6e, 0x95, 0xc4, 0x3d, 0xf5, 0x76, 0x2c, 0x4d, 0xcd, 0x8e,
+	0x59, 0x0f, 0x49, 0x06, 0xd0, 0xb0, 0x57, 0xfb, 0x6e, 0x06, 0x6a, 0x61, 0x0f, 0x5a, 0x86, 0x4a,
+	0xc7, 0x25, 0x1d, 0xfe, 0x64, 0x91, 0x21, 0x36, 0xcf, 0x9b, 0xfb, 0xdd, 0x10, 0x06, 0x2a, 0x47,
+	0x30, 0x10, 0x5a, 0x85, 0xaa, 0x87, 0xcf, 0x4d, 0x91, 0xf0, 0x0a, 0xe3, 0xdb, 0xe5, 0x56, 0xc9,
+	0xa8, 0x78, 0xf8, 0xfc, 0xc8, 0x62, 0x3c, 0xa9, 0xaa, 0xf2, 0xac, 0x40, 0x74, 0xcf, 0x46, 0xdd,
+	0xc4, 0xed, 0x8a, 0xee, 0x43, 0xa8, 0x91, 0x21, 0xa6, 0x96, 0x78, 0xa8, 0xcf, 0x89, 0x3c, 0xfb,
+	0x83, 0x37, 0x9c, 0xc0, 0xfa, 0x61, 0x30, 0xd0, 0x88, 0x64, 0x70, 0x9f, 0x73, 0x9f, 0x44, 0x42,
+	0x25, 0xb0, 0xd2, 0xa0, 0xd6, 0x79, 0xc8, 0xcf, 0x63, 0x89, 0x1b, 0x35, 0x20, 0x5d, 0x2c, 0xd2,
+	0x8d, 0x39, 0x61, 0xd0, 0x0b, 0xd2, 0xc5, 0x02, 0x58, 0xc1, 0xe7, 0xb2, 0xab, 0x2a, 0xbb, 0x3c,
+	0x7c, 0x2e, 0xba, 0xee, 0xc1, 0x95, 0x60, 0xa6, 0x66, 0xe7, 0x82, 0x9f, 0x08, 0x35, 0x99, 0x45,
+	0xaa, 0xb9, 0xb6, 0x39, 0x8d, 0x73, 0x05, 0x13, 0x56, 0x5c, 0x20, 0xb9, 0xd4, 0x94, 0x05, 0x97,
+	0xee, 0x40, 0x2d, 0x32, 0xa7, 0x0e, 0x95, 0x4f, 0x0e, 0x9e, 0x1d, 0x1c, 0x7e, 0x7a, 0xd0, 0xbc,
+	0x84, 0x6a, 0x30, 0xb7, 0xb1, 0xb5, 0xb5, 0xbd, 0x25, 0x71, 0x81, 0xcd, 0xc3, 0xa3, 0xfd, 0xed,
+	0x2d, 0x89, 0x0b, 0x6c, 0x6d, 0x3f, 0xdf, 0x3e, 0xd9, 0xde, 0x6a, 0xce, 0xa0, 0x06, 0x54, 0x5f,
+	0x1c, 0x6e, 0xed, 0xef, 0xf0, 0xae, 0x59, 0xde, 0x65, 0x6c, 0x1f, 0x6c, 0xbc, 0xd8, 0xde, 0x6a,
+	0xce, 0xa1, 0x26, 0x34, 0x4e, 0x3e, 0x3b, 0xda, 0x36, 0x37, 0xf7, 0x36, 0x0e, 0x76, 0xb7, 0xb7,
+	0x9a, 0xf3, 0xfa, 0x6f, 0xa0, 0x75, 0x8c, 0x2d, 0x6a, 0xf7, 0x77, 0x1c, 0x17, 0xfb, 0xed, 0x0b,
+	0x7e, 0x98, 0x4e, 0x1e, 0xdb, 0x4b, 0x30, 0xf7, 0x6a, 0x84, 0x55, 0xb6, 0x50, 0x33, 0x64, 0x23,
+	0xc8, 0x18, 0x67, 0xc2, 0x8c, 0x51, 0xff, 0x00, 0x56, 0x72, 0xb4, 0x47, 0x49, 0x6c, 0x8f, 0x93,
+	0x45, 0xe8, 0x36, 0x0c, 0xd9, 0xd0, 0xff, 0x56, 0x82, 0x1b, 0x89, 0x31, 0x9b, 0xc4, 0x63, 0xd8,
+	0x63, 0x3f, 0x98, 0xd1, 0xe8, 0x1d, 0x68, 0xda, 0xfd, 0x91, 0x77, 0x86, 0x79, 0x3a, 0x2b, 0x6d,
+	0x55, 0x98, 0xde, 0x55, 0x45, 0x0f, 0x8f, 0x8d, 0x0b, 0xb8, 0x99, 0x6f, 0xab, 0x9a, 0x62, 0x0b,
+	0x2a, 0x03, 0x8b, 0xd9, 0xfd, 0x70, 0x92, 0x41, 0x13, 0xad, 0x02, 0x88, 0x4f, 0x33, 0x76, 0x49,
+	0xd7, 0x04, 0x65, 0xcb, 0x62, 0x16, 0xba, 0x0d, 0x0d, 0xec, 0x75, 0x4d, 0xd2, 0x33, 0x05, 0x4d,
+	0x61, 0x8d, 0x80, 0xbd, 0xee, 0x61, 0xef, 0x05, 0xa7, 0xe8, 0x7f, 0x28, 0xc1, 0xbc, 0x44, 0xea,
+	0x82, 0xe7, 0x7a, 0x29, 0x7c, 0xae, 0xf3, 0xad, 0x2a, 0x6e, 0x53, 0x39, 0x53, 0xf1, 0x8d, 0x7e,
+	0x06, 0x2b, 0xe1, 0x39, 0x49, 0xa8, 0xf3, 0x95, 0x88, 0x3e, 0xb3, 0x8f, 0xad, 0x2e, 0xa6, 0xea,
+	0xe0, 0x59, 0x0e, 0xce, 0xcd, 0xb0, 0x7f, 0x4f, 0x74, 0xa3, 0xb7, 0xe0, 0xca, 0xc0, 0xa1, 0x94,
+	0x50, 0x93, 0xe2, 0xde, 0xc0, 0x1a, 0xfa, 0xad, 0x59, 0xf1, 0xe2, 0xbb, 0x2c, 0xa9, 0x86, 0x24,
+	0xea, 0x7f, 0x2c, 0xc1, 0x75, 0x81, 0x92, 0xec, 0x9d, 0x9c, 0x1c, 0x4d, 0x0b, 0x87, 0xbd, 0x9f,
+	0xc0, 0x61, 0xb3, 0x50, 0x66, 0x80, 0xcb, 0xc6, 0x80, 0xd6, 0x99, 0x04, 0xd0, 0xaa, 0xaf, 0xc0,
+	0x72, 0xc6, 0x2a, 0xb5, 0x80, 0x9f, 0xc1, 0xea, 0x2e, 0x66, 0x87, 0x9d, 0x5f, 0x63, 0x9b, 0x6d,
+	0x39, 0x14, 0xdb, 0xd3, 0xc3, 0xd3, 0x7f, 0x04, 0xb7, 0x8a, 0x44, 0x8f, 0xc1, 0xd5, 0xff, 0x52,
+	0x82, 0xa5, 0x4d, 0x97, 0x78, 0x98, 0x5f, 0x53, 0x47, 0x84, 0xb8, 0xd3, 0x70, 0xe0, 0xec, 0x90,
+	0xa7, 0x0b, 0xa9, 0xcc, 0x5e, 0x5a, 0x26, 0x54, 0x88, 0xfe, 0x98, 0xa3, 0x67, 0xc6, 0x39, 0x5a,
+	0x5f, 0x86, 0x6b, 0x29, 0x0b, 0x95, 0x33, 0xff, 0x59, 0x82, 0x9b, 0x89, 0x9e, 0x7d, 0x8f, 0x61,
+	0xea, 0x59, 0x3f, 0xe0, 0x1c, 0x72, 0x21, 0x8d, 0x99, 0xff, 0x01, 0xd2, 0x58, 0x83, 0xd5, 0x82,
+	0x29, 0x44, 0x70, 0x38, 0xf7, 0xc7, 0xeb, 0x69, 0xc3, 0xe1, 0x59, 0xa1, 0x4a, 0xe1, 0x97, 0x5c,
+	0xa1, 0x27, 0x0e, 0xce, 0xa9, 0x29, 0x14, 0x17, 0x25, 0x76, 0x2d, 0xe6, 0xbc, 0xc6, 0xf2, 0x76,
+	0x56, 0x8f, 0x93, 0x80, 0xc8, 0xef, 0x2a, 0x69, 0x55, 0x5a, 0xb3, 0xb2, 0xea, 0xf7, 0x25, 0x9e,
+	0x63, 0x0d, 0x5d, 0xc7, 0x9e, 0x6e, 0x65, 0x00, 0xbd, 0x0b, 0xf3, 0x72, 0x51, 0xc6, 0x20, 0x51,
+	0x8a, 0x43, 0x5f, 0x85, 0x1b, 0xb9, 0x36, 0x48, 0x1b, 0x9f, 0xfc, 0x75, 0x55, 0x14, 0x28, 0x83,
+	0x92, 0x96, 0xac, 0xe6, 0xa2, 0xcf, 0xa1, 0x99, 0x2e, 0xae, 0xa2, 0xb5, 0xac, 0x92, 0x44, 0x2d,
+	0x57, 0xbb, 0x5d, 0xcc, 0xa0, 0x1c, 0x32, 0xff, 0x9f, 0x6f, 0x1f, 0x94, 0xab, 0x65, 0xf4, 0x45,
+	0x50, 0x14, 0x8d, 0x55, 0x4c, 0x51, 0x7c, 0x78, 0x6e, 0x89, 0x56, 0xbb, 0x33, 0x86, 0x23, 0xa1,
+	0xa1, 0x84, 0x9e, 0x01, 0x44, 0x25, 0x50, 0xb4, 0x92, 0x1c, 0x18, 0x2b, 0xc5, 0x6a, 0x5a, 0x5e,
+	0x57, 0x4a, 0xd8, 0xa7, 0x70, 0x25, 0x59, 0xc1, 0x44, 0xab, 0xe1, 0x0b, 0x2c, 0xaf, 0xa2, 0xaa,
+	0xdd, 0x2a, 0xea, 0xce, 0x0a, 0x4e, 0x96, 0x13, 0x23, 0xc1, 0xb9, 0x95, 0xcb, 0x48, 0x70, 0x7e,
+	0x15, 0x32, 0x14, 0x6c, 0x03, 0xca, 0x96, 0x01, 0x51, 0xe8, 0xbf, 0xc2, 0xaa, 0xa4, 0xa6, 0x8f,
+	0x63, 0x49, 0x29, 0x39, 0x80, 0x7a, 0xac, 0x16, 0x86, 0x42, 0x4f, 0x66, 0x2b, 0x8c, 0xda, 0x8d,
+	0xdc, 0xbe, 0x94, 0xbc, 0xcf, 0xa1, 0x99, 0xce, 0x43, 0xa2, 0xa0, 0x2b, 0x28, 0xaf, 0x45, 0x41,
+	0x57, 0x58, 0x2a, 0x0b, 0xc4, 0xbf, 0x00, 0x88, 0x4a, 0x45, 0x51, 0x48, 0x64, 0x6a, 0x55, 0x51,
+	0x48, 0x64, 0x2b, 0x4b, 0x81, 0xb0, 0xc7, 0xc2, 0xda, 0x74, 0xe9, 0x27, 0xb2, 0xb6, 0xa0, 0xd2,
+	0x14, 0x59, 0x5b, 0x54, 0x35, 0x8a, 0x6f, 0x91, 0x4c, 0x2d, 0x25, 0xda, 0x22, 0x45, 0x15, 0xa4,
+	0x68, 0x8b, 0x14, 0x16, 0x62, 0x42, 0x7f, 0xfc, 0x14, 0x66, 0x77, 0x7c, 0xfb, 0x0c, 0x85, 0xb0,
+	0x7f, 0xac, 0x0c, 0xa3, 0x2d, 0x25, 0x89, 0xa9, 0xa1, 0xdb, 0x50, 0x0d, 0x4a, 0x0a, 0x68, 0x39,
+	0xe0, 0x4c, 0x55, 0x55, 0xb4, 0x56, 0xb6, 0x23, 0x25, 0xe6, 0x04, 0x2e, 0x27, 0x80, 0x7d, 0x74,
+	0x33, 0xd4, 0x9a, 0x53, 0x5f, 0xd0, 0x56, 0x0b, 0x7a, 0x53, 0x9e, 0x7b, 0x06, 0x10, 0x01, 0xee,
+	0xd1, 0x3a, 0x67, 0x8a, 0x02, 0xd1, 0x3a, 0xe7, 0xe0, 0xf3, 0xb1, 0x8d, 0x94, 0xc5, 0xcc, 0xa3,
+	0x8d, 0x54, 0x88, 0xe1, 0x47, 0x1b, 0xa9, 0x18, 0x72, 0x0f, 0x2d, 0x16, 0x4a, 0xd2, 0x28, 0x77,
+	0x5c, 0x49, 0x01, 0xea, 0x1e, 0x57, 0x52, 0x04, 0x92, 0x87, 0x4a, 0x68, 0xb6, 0x44, 0xad, 0xd0,
+	0x69, 0x74, 0xbf, 0x68, 0x0f, 0x25, 0xc1, 0x72, 0xed, 0xed, 0xef, 0xe5, 0x4b, 0x79, 0xef, 0x18,
+	0x1a, 0x71, 0x74, 0x1a, 0xdd, 0x48, 0x0a, 0x48, 0xc0, 0x78, 0xda, 0xcd, 0xfc, 0xce, 0xe4, 0x34,
+	0x1e, 0x97, 0xd0, 0x6f, 0x41, 0x2b, 0x06, 0xe8, 0xd0, 0x3b, 0xe3, 0x6c, 0x4c, 0x2a, 0x7c, 0xf7,
+	0x4d, 0x58, 0x93, 0x33, 0x7a, 0x50, 0x42, 0x7b, 0x50, 0x0b, 0x41, 0x63, 0xd4, 0x2a, 0x82, 0xbc,
+	0xb5, 0x95, 0x9c, 0x9e, 0x94, 0x77, 0x3e, 0x86, 0x46, 0x1c, 0x04, 0x8e, 0xbc, 0x93, 0x83, 0x3f,
+	0x47, 0xde, 0xc9, 0xc5, 0x8d, 0xe3, 0x47, 0x72, 0x04, 0x23, 0xc6, 0x8e, 0xe4, 0x0c, 0x56, 0x19,
+	0x3b, 0x92, 0xb3, 0xb8, 0x63, 0x18, 0x34, 0x1d, 0xf1, 0x97, 0x41, 0x12, 0xfb, 0x43, 0xf1, 0x32,
+	0x7f, 0x2e, 0xd8, 0x18, 0x9d, 0x42, 0x85, 0xc0, 0x61, 0x6c, 0x3d, 0xbf, 0x80, 0x85, 0x0c, 0x98,
+	0x17, 0xe9, 0x28, 0x42, 0x0f, 0x23, 0x1d, 0x85, 0x48, 0x60, 0x38, 0x8b, 0x36, 0x54, 0xd4, 0xbf,
+	0x41, 0xe8, 0x7a, 0x38, 0x2a, 0xf1, 0xe3, 0x91, 0xb6, 0x9c, 0xa1, 0xa7, 0x3c, 0x7b, 0x04, 0xf5,
+	0x18, 0xd2, 0x87, 0xe2, 0x77, 0x44, 0x0a, 0xc1, 0x8b, 0x3c, 0x9b, 0x03, 0x0d, 0xc6, 0xe6, 0xfd,
+	0x3b, 0x9e, 0x09, 0x8c, 0xc1, 0xdd, 0xd0, 0x7b, 0xe3, 0xe2, 0x33, 0xad, 0xf4, 0xe1, 0x9b, 0x31,
+	0xa7, 0x66, 0xf5, 0x2b, 0xb8, 0x9c, 0xc0, 0x90, 0xa2, 0x13, 0x38, 0x0f, 0xe8, 0x8b, 0x4e, 0xe0,
+	0x5c, 0xe0, 0x29, 0x36, 0xb7, 0x33, 0x58, 0xca, 0xcb, 0xf9, 0xd1, 0xdd, 0x68, 0x57, 0x14, 0xa2,
+	0x17, 0xda, 0xbd, 0xf1, 0x4c, 0x19, 0x65, 0x1d, 0x58, 0xc8, 0x00, 0x28, 0x51, 0x00, 0x15, 0x21,
+	0x3b, 0x51, 0x00, 0x15, 0xa2, 0x2f, 0x31, 0x1d, 0x18, 0x50, 0xb6, 0x5a, 0x82, 0x62, 0x0f, 0xd2,
+	0x82, 0xa2, 0x4d, 0x74, 0x44, 0x8f, 0x29, 0xb6, 0x44, 0x87, 0x4b, 0x07, 0x16, 0x32, 0x05, 0x92,
+	0x68, 0x2a, 0x45, 0x15, 0x99, 0x68, 0x2a, 0x85, 0xd5, 0x95, 0xd8, 0x54, 0x5e, 0xc2, 0xd5, 0x54,
+	0xa6, 0x8f, 0x6e, 0x25, 0x5e, 0x0d, 0x19, 0x60, 0x42, 0x5b, 0x2b, 0xec, 0x4f, 0xc5, 0x13, 0x81,
+	0xeb, 0xf9, 0xf9, 0x3c, 0x7a, 0x2b, 0x16, 0x3a, 0xc5, 0x50, 0x82, 0x76, 0xff, 0xfb, 0xd8, 0x52,
+	0x5b, 0xfb, 0x04, 0x2e, 0x27, 0x52, 0xd1, 0x28, 0x80, 0xf3, 0x00, 0x82, 0x28, 0x80, 0xf3, 0x93,
+	0xf3, 0x60, 0x1a, 0x6e, 0x2a, 0x7b, 0x0f, 0x12, 0x5c, 0x74, 0x2f, 0x77, 0x7c, 0x2a, 0x85, 0xd7,
+	0xde, 0xfa, 0x1e, 0xae, 0xec, 0xbb, 0x37, 0x9d, 0xd8, 0xc6, 0x93, 0xad, 0xdc, 0x3c, 0x3a, 0x9e,
+	0x6c, 0x15, 0xe4, 0xc4, 0x09, 0xf1, 0xc9, 0x0c, 0x35, 0x2e, 0x3e, 0x37, 0x6b, 0x8e, 0x8b, 0x2f,
+	0x48, 0x6e, 0x03, 0xf1, 0x3d, 0x58, 0xcc, 0xc9, 0x2f, 0x51, 0x2c, 0xee, 0x8b, 0x12, 0x60, 0xed,
+	0xee, 0x58, 0x9e, 0xa4, 0x9e, 0xf6, 0xe3, 0x97, 0x9c, 0xdb, 0xb5, 0x3a, 0xeb, 0x36, 0x19, 0x3c,
+	0x92, 0x9f, 0xef, 0x13, 0x7a, 0xfa, 0x48, 0xca, 0x78, 0x24, 0x7e, 0x35, 0x7e, 0x74, 0x4a, 0x54,
+	0x7b, 0xd8, 0xe9, 0xcc, 0x0b, 0xd2, 0xd3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x6a, 0xc3, 0xa4,
+	0x50, 0xaf, 0x2c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/go/gitalypb/shared.pb.go b/proto/go/gitalypb/shared.pb.go
index cd5daac5d3..e053478f01 100644
--- a/proto/go/gitalypb/shared.pb.go
+++ b/proto/go/gitalypb/shared.pb.go
@@ -140,31 +140,31 @@ func (OperationMsg_Scope) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_d8a4e87e678c5ced, []int{0, 1}
 }
 
-type TransactionStep_TransactionStep int32
+type Transaction_TransactionStep int32
 
 const (
-	TransactionStep_PRECOMMIT TransactionStep_TransactionStep = 0
-	TransactionStep_COMMIT    TransactionStep_TransactionStep = 1
-	TransactionStep_ROLLBACK  TransactionStep_TransactionStep = 2
+	Transaction_PRECOMMIT Transaction_TransactionStep = 0
+	Transaction_COMMIT    Transaction_TransactionStep = 1
+	Transaction_ROLLBACK  Transaction_TransactionStep = 2
 )
 
-var TransactionStep_TransactionStep_name = map[int32]string{
+var Transaction_TransactionStep_name = map[int32]string{
 	0: "PRECOMMIT",
 	1: "COMMIT",
 	2: "ROLLBACK",
 }
 
-var TransactionStep_TransactionStep_value = map[string]int32{
+var Transaction_TransactionStep_value = map[string]int32{
 	"PRECOMMIT": 0,
 	"COMMIT":    1,
 	"ROLLBACK":  2,
 }
 
-func (x TransactionStep_TransactionStep) String() string {
-	return proto.EnumName(TransactionStep_TransactionStep_name, int32(x))
+func (x Transaction_TransactionStep) String() string {
+	return proto.EnumName(Transaction_TransactionStep_name, int32(x))
 }
 
-func (TransactionStep_TransactionStep) EnumDescriptor() ([]byte, []int) {
+func (Transaction_TransactionStep) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_d8a4e87e678c5ced, []int{1, 0}
 }
 
@@ -219,51 +219,43 @@ func (m *OperationMsg) GetScopeLevel() OperationMsg_Scope {
 	return OperationMsg_REPOSITORY
 }
 
-type TransactionStep struct {
-	Id                   string                          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
-	Step                 TransactionStep_TransactionStep `protobuf:"varint,2,opt,name=step,proto3,enum=gitaly.TransactionStep_TransactionStep" json:"step,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
-	XXX_unrecognized     []byte                          `json:"-"`
-	XXX_sizecache        int32                           `json:"-"`
+type Transaction struct {
+	Step                 Transaction_TransactionStep `protobuf:"varint,1,opt,name=step,proto3,enum=gitaly.Transaction_TransactionStep" json:"step,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
+	XXX_unrecognized     []byte                      `json:"-"`
+	XXX_sizecache        int32                       `json:"-"`
 }
 
-func (m *TransactionStep) Reset()         { *m = TransactionStep{} }
-func (m *TransactionStep) String() string { return proto.CompactTextString(m) }
-func (*TransactionStep) ProtoMessage()    {}
-func (*TransactionStep) Descriptor() ([]byte, []int) {
+func (m *Transaction) Reset()         { *m = Transaction{} }
+func (m *Transaction) String() string { return proto.CompactTextString(m) }
+func (*Transaction) ProtoMessage()    {}
+func (*Transaction) Descriptor() ([]byte, []int) {
 	return fileDescriptor_d8a4e87e678c5ced, []int{1}
 }
 
-func (m *TransactionStep) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TransactionStep.Unmarshal(m, b)
+func (m *Transaction) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Transaction.Unmarshal(m, b)
 }
-func (m *TransactionStep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TransactionStep.Marshal(b, m, deterministic)
+func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
 }
-func (m *TransactionStep) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TransactionStep.Merge(m, src)
+func (m *Transaction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Transaction.Merge(m, src)
 }
-func (m *TransactionStep) XXX_Size() int {
-	return xxx_messageInfo_TransactionStep.Size(m)
+func (m *Transaction) XXX_Size() int {
+	return xxx_messageInfo_Transaction.Size(m)
 }
-func (m *TransactionStep) XXX_DiscardUnknown() {
-	xxx_messageInfo_TransactionStep.DiscardUnknown(m)
+func (m *Transaction) XXX_DiscardUnknown() {
+	xxx_messageInfo_Transaction.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_TransactionStep proto.InternalMessageInfo
+var xxx_messageInfo_Transaction proto.InternalMessageInfo
 
-func (m *TransactionStep) GetId() string {
-	if m != nil {
-		return m.Id
-	}
-	return ""
-}
-
-func (m *TransactionStep) GetStep() TransactionStep_TransactionStep {
+func (m *Transaction) GetStep() Transaction_TransactionStep {
 	if m != nil {
 		return m.Step
 	}
-	return TransactionStep_PRECOMMIT
+	return Transaction_PRECOMMIT
 }
 
 type Repository struct {
@@ -848,9 +840,9 @@ func init() {
 	proto.RegisterEnum("gitaly.SignatureType", SignatureType_name, SignatureType_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Operation", OperationMsg_Operation_name, OperationMsg_Operation_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Scope", OperationMsg_Scope_name, OperationMsg_Scope_value)
-	proto.RegisterEnum("gitaly.TransactionStep_TransactionStep", TransactionStep_TransactionStep_name, TransactionStep_TransactionStep_value)
+	proto.RegisterEnum("gitaly.Transaction_TransactionStep", Transaction_TransactionStep_name, Transaction_TransactionStep_value)
 	proto.RegisterType((*OperationMsg)(nil), "gitaly.OperationMsg")
-	proto.RegisterType((*TransactionStep)(nil), "gitaly.TransactionStep")
+	proto.RegisterType((*Transaction)(nil), "gitaly.Transaction")
 	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
 	proto.RegisterType((*GitCommit)(nil), "gitaly.GitCommit")
 	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
@@ -869,74 +861,74 @@ func init() {
 func init() { proto.RegisterFile("shared.proto", fileDescriptor_d8a4e87e678c5ced) }
 
 var fileDescriptor_d8a4e87e678c5ced = []byte{
-	// 1096 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4d, 0x6f, 0xdb, 0x46,
-	0x13, 0x8e, 0x28, 0xea, 0x6b, 0x24, 0x39, 0xcc, 0xbe, 0x0e, 0x20, 0xf8, 0x45, 0x12, 0x97, 0x05,
-	0xda, 0x20, 0x70, 0x65, 0xc3, 0x41, 0x8b, 0x46, 0x29, 0x50, 0x48, 0xae, 0x62, 0x38, 0xb1, 0x45,
-	0x61, 0x45, 0xf7, 0xeb, 0x42, 0xac, 0xc4, 0xcd, 0x6a, 0x0b, 0x4a, 0x4b, 0x90, 0xab, 0xa0, 0xf6,
-	0xb1, 0xe8, 0xa9, 0xa7, 0x9e, 0x7b, 0xef, 0xb5, 0x3f, 0xa3, 0xe8, 0xdf, 0x68, 0xda, 0xff, 0xd1,
-	0x62, 0x77, 0x49, 0x99, 0xfe, 0x68, 0x9b, 0xdc, 0x76, 0x86, 0xcf, 0x3c, 0x33, 0xf3, 0xec, 0xec,
-	0x48, 0xd0, 0x4a, 0xe7, 0x24, 0xa1, 0x61, 0x37, 0x4e, 0x84, 0x14, 0xa8, 0xca, 0xb8, 0x24, 0xd1,
-	0xd9, 0xd6, 0x03, 0x26, 0x04, 0x8b, 0xe8, 0xae, 0xf6, 0x4e, 0x57, 0x2f, 0x77, 0x25, 0x5f, 0xd0,
-	0x54, 0x92, 0x45, 0x6c, 0x80, 0x5b, 0xdb, 0x57, 0x01, 0x21, 0x4d, 0x67, 0x09, 0x8f, 0xa5, 0x48,
-	0x0c, 0xc2, 0x7d, 0x5d, 0x82, 0x96, 0x17, 0xd3, 0x84, 0x48, 0x2e, 0x96, 0x27, 0x29, 0x43, 0x5d,
-	0xb0, 0x44, 0xdc, 0x29, 0x6d, 0x97, 0x1e, 0x6e, 0xec, 0xdf, 0xef, 0x9a, 0x44, 0xdd, 0x22, 0xe2,
-	0xc2, 0xc0, 0x96, 0x88, 0xd1, 0x53, 0x68, 0xa6, 0x33, 0x11, 0xd3, 0x20, 0xa2, 0xaf, 0x68, 0xd4,
-	0xb1, 0x74, 0xe0, 0xd6, 0x8d, 0x81, 0x13, 0x85, 0xc3, 0xa0, 0xe1, 0xc7, 0x0a, 0xed, 0x3e, 0x86,
-	0xc6, 0x1a, 0x81, 0x9a, 0x50, 0x3b, 0x1d, 0xbd, 0x18, 0x79, 0x5f, 0x8c, 0x9c, 0x5b, 0xca, 0x38,
-	0x39, 0xf5, 0xfb, 0xbe, 0x87, 0x9d, 0x12, 0x6a, 0x41, 0xbd, 0x7f, 0x70, 0x30, 0x9c, 0x4c, 0x3c,
-	0xec, 0x58, 0xee, 0x1e, 0x54, 0x34, 0x13, 0xda, 0x00, 0xc0, 0xc3, 0xb1, 0x37, 0x39, 0xf2, 0x3d,
-	0xfc, 0x95, 0x73, 0x0b, 0x01, 0x54, 0x27, 0x43, 0xfc, 0xf9, 0x50, 0x85, 0x34, 0xa1, 0x36, 0xf1,
-	0x3d, 0xdc, 0x3f, 0x1c, 0x3a, 0x96, 0xfb, 0x53, 0x09, 0x6e, 0xfb, 0x09, 0x59, 0xa6, 0x64, 0xa6,
-	0x32, 0x4d, 0x24, 0x8d, 0xd1, 0x06, 0x58, 0x3c, 0xd4, 0x7d, 0x36, 0xb0, 0xc5, 0x43, 0xf4, 0x14,
-	0xec, 0x54, 0xd2, 0x38, 0x6b, 0xe0, 0xfd, 0xbc, 0x81, 0x2b, 0x61, 0x57, 0x6d, 0xac, 0x83, 0xdc,
-	0xde, 0x75, 0xfe, 0x36, 0x34, 0xc6, 0x78, 0x78, 0xe0, 0x9d, 0x9c, 0x1c, 0xf9, 0xa6, 0xb6, 0xec,
-	0xac, 0xdb, 0xc1, 0xde, 0xf1, 0xf1, 0xa0, 0x7f, 0xf0, 0xc2, 0xb1, 0xdc, 0x5f, 0x2c, 0x00, 0x4c,
-	0x63, 0x91, 0x72, 0x29, 0x92, 0x33, 0xf4, 0x0e, 0xb4, 0x52, 0x29, 0x12, 0xc2, 0x68, 0xb0, 0x24,
-	0x0b, 0xaa, 0xeb, 0x69, 0xe0, 0x66, 0xe6, 0x1b, 0x91, 0x05, 0x45, 0xef, 0x42, 0x3b, 0xa1, 0x11,
-	0x91, 0xfc, 0x15, 0x0d, 0x62, 0x22, 0xe7, 0x9d, 0xb2, 0xc6, 0xb4, 0x72, 0xe7, 0x98, 0xc8, 0x39,
-	0xda, 0x83, 0x4d, 0xc6, 0x65, 0x20, 0xa6, 0xdf, 0xd0, 0x99, 0x0c, 0x42, 0x9e, 0xd0, 0x99, 0xe2,
-	0xef, 0xd8, 0x1a, 0x8b, 0x18, 0x97, 0x9e, 0xfe, 0xf4, 0x59, 0xfe, 0x05, 0x1d, 0xc2, 0xb6, 0x8a,
-	0x20, 0x91, 0xa4, 0xc9, 0x92, 0x48, 0x7a, 0x35, 0x96, 0xd3, 0xb4, 0x53, 0xd9, 0x2e, 0x3f, 0x6c,
-	0xe0, 0x7b, 0x8c, 0xcb, 0x7e, 0x0e, 0xbb, 0x4c, 0xc3, 0x69, 0xaa, 0xea, 0x63, 0x51, 0x90, 0xac,
-	0x7b, 0xea, 0x54, 0x4d, 0x7d, 0x2c, 0x2a, 0xf4, 0xf9, 0x1e, 0xdc, 0x66, 0x51, 0x10, 0x27, 0x42,
-	0xe7, 0xd0, 0x6d, 0xd4, 0x35, 0xac, 0xcd, 0xa2, 0xb1, 0xf1, 0xaa, 0x3e, 0x9e, 0xdb, 0xf5, 0x92,
-	0x63, 0x3d, 0xb7, 0xeb, 0x35, 0xa7, 0x8e, 0x6d, 0x05, 0x73, 0x7f, 0xb6, 0xa0, 0x71, 0xc8, 0xe5,
-	0x81, 0x58, 0x2c, 0xb8, 0xbc, 0x76, 0x8f, 0x1d, 0xa8, 0xa5, 0x2b, 0x5d, 0x92, 0x96, 0xae, 0x85,
-	0x73, 0x13, 0x21, 0xb0, 0xa7, 0x22, 0x3c, 0xd3, 0x6a, 0xb5, 0xb0, 0x3e, 0xa3, 0x1d, 0xa8, 0x92,
-	0x95, 0x9c, 0x8b, 0x44, 0xeb, 0xd2, 0xdc, 0xdf, 0xcc, 0xef, 0xdd, 0xb0, 0xf7, 0xf5, 0x37, 0x9c,
-	0x61, 0xd0, 0x3e, 0x34, 0x66, 0xda, 0x2f, 0x69, 0xd2, 0xa9, 0xfc, 0x4b, 0xc0, 0x05, 0x0c, 0xdd,
-	0x03, 0x88, 0x49, 0x42, 0x97, 0x32, 0xe0, 0x61, 0xda, 0xa9, 0x6a, 0xfd, 0x1a, 0xc6, 0x73, 0x14,
-	0xa6, 0xe8, 0xff, 0xd0, 0x50, 0x85, 0x04, 0x29, 0x3f, 0xa7, 0x9d, 0xda, 0x76, 0xe9, 0x61, 0x19,
-	0xd7, 0x95, 0x63, 0xc2, 0xcf, 0x29, 0xfa, 0x04, 0x36, 0x52, 0xce, 0x96, 0x44, 0xae, 0x12, 0x1a,
-	0xc8, 0xb3, 0x98, 0x6a, 0x89, 0x36, 0xf6, 0xef, 0xe6, 0x49, 0x27, 0xf9, 0x57, 0xff, 0x2c, 0xa6,
-	0xb8, 0x9d, 0x16, 0x4d, 0xf7, 0xfb, 0x12, 0xb4, 0x8a, 0x55, 0x29, 0x01, 0xf4, 0x48, 0x95, 0x8c,
-	0x00, 0xea, 0x8c, 0x36, 0xa1, 0x42, 0x17, 0x84, 0x47, 0x99, 0x58, 0xc6, 0x40, 0x5d, 0xb0, 0x43,
-	0x22, 0xa9, 0x96, 0xaa, 0xa9, 0x5e, 0xb3, 0x5e, 0x23, 0xdd, 0x7c, 0x8d, 0x74, 0xfd, 0x7c, 0xcf,
-	0x60, 0x8d, 0x43, 0x5b, 0x50, 0x57, 0xab, 0xe7, 0x5c, 0x2c, 0xa9, 0x16, 0xb2, 0x85, 0xd7, 0xb6,
-	0xeb, 0x02, 0x0c, 0xbf, 0xe5, 0x72, 0x22, 0x89, 0x5c, 0xa5, 0x2a, 0xdf, 0x2b, 0x12, 0xad, 0x4c,
-	0x11, 0x15, 0x6c, 0x0c, 0xd7, 0x87, 0xea, 0x20, 0x21, 0xcb, 0xd9, 0xfc, 0xc6, 0x1a, 0x3f, 0x82,
-	0xb6, 0x24, 0x09, 0xa3, 0x32, 0x30, 0xb2, 0xea, 0x5a, 0x9b, 0xfb, 0x77, 0x72, 0x15, 0xd6, 0xc3,
-	0x80, 0x5b, 0x06, 0x67, 0x2c, 0xf7, 0x07, 0x0b, 0xca, 0x3e, 0x61, 0x37, 0x72, 0x9a, 0xb1, 0xb1,
-	0xd6, 0x63, 0x73, 0x2d, 0x47, 0xf9, 0x8d, 0x72, 0xa8, 0x71, 0x5b, 0xd0, 0x34, 0x25, 0x2c, 0x6f,
-	0x3c, 0x37, 0xd5, 0x43, 0xce, 0x8e, 0xe6, 0x72, 0x2b, 0xfa, 0x72, 0x9b, 0x99, 0x4f, 0xdf, 0xef,
-	0x0e, 0x54, 0x25, 0x61, 0x8c, 0x26, 0xfa, 0x85, 0xfc, 0xe3, 0xf4, 0x19, 0xcc, 0x0d, 0xd3, 0x50,
-	0x7b, 0x8b, 0x69, 0x78, 0x09, 0xf6, 0x69, 0x4a, 0x13, 0xf4, 0x3f, 0xa8, 0xb0, 0x28, 0x58, 0x3f,
-	0x19, 0x9b, 0x45, 0x47, 0xe1, 0x5a, 0x21, 0xeb, 0xa6, 0xc9, 0x28, 0x17, 0x27, 0xe3, 0x01, 0x34,
-	0x59, 0x14, 0xac, 0x52, 0xf5, 0xf6, 0x17, 0x34, 0xdb, 0x26, 0xc0, 0xa2, 0xd3, 0xcc, 0xe3, 0x3e,
-	0x03, 0x30, 0x1b, 0x61, 0x2c, 0x44, 0x84, 0x3e, 0x06, 0x28, 0xec, 0x81, 0x92, 0xee, 0x12, 0xe5,
-	0xf5, 0x5e, 0x6c, 0x83, 0x81, 0xfd, 0xe3, 0xaf, 0x3b, 0x25, 0x5c, 0xc0, 0x3e, 0x1a, 0xe4, 0x3c,
-	0xaa, 0xfa, 0xcb, 0xbf, 0x0d, 0xc5, 0x5d, 0x5a, 0x07, 0x7b, 0x70, 0xec, 0x0d, 0x1c, 0x4b, 0x9d,
-	0x7c, 0x3c, 0x1c, 0x3a, 0x65, 0x54, 0x83, 0xb2, 0xdf, 0x3f, 0x74, 0xec, 0x47, 0x3b, 0xd0, 0xbe,
-	0xa4, 0x89, 0xc2, 0x8c, 0xbc, 0xd1, 0xd0, 0xb9, 0xa5, 0x30, 0xe3, 0xc3, 0xb1, 0x21, 0xf8, 0xf2,
-	0xc3, 0xbd, 0x27, 0x8e, 0xd5, 0xf3, 0xa0, 0x26, 0x62, 0x2d, 0x2c, 0xba, 0x7f, 0x6d, 0xe2, 0x4f,
-	0xa8, 0x9c, 0x8b, 0xd0, 0x8b, 0xd5, 0x7e, 0x4f, 0x3b, 0x7f, 0x7d, 0x77, 0xe5, 0xf5, 0x17, 0x7f,
-	0xe7, 0x70, 0x55, 0xc4, 0x2a, 0x5b, 0xef, 0x09, 0xd4, 0xb2, 0xb5, 0x8d, 0xee, 0x5d, 0x23, 0x7c,
-	0xc6, 0x69, 0xb4, 0xe6, 0xfb, 0xfd, 0x37, 0xc5, 0x57, 0xc7, 0x39, 0xbe, 0xf7, 0x69, 0x51, 0xb7,
-	0xff, 0x8a, 0x7e, 0x9d, 0x45, 0x17, 0x42, 0x7a, 0xc7, 0x70, 0x27, 0x9b, 0xe7, 0x37, 0xe7, 0xf9,
-	0x23, 0xe3, 0x71, 0x4c, 0xe4, 0xc5, 0xf5, 0xf4, 0x7c, 0xb8, 0x4b, 0xc2, 0x90, 0x2b, 0x18, 0x89,
-	0xde, 0x82, 0xf1, 0xcf, 0x8c, 0x71, 0xf3, 0x22, 0xba, 0x70, 0xe9, 0x7b, 0x5f, 0x2b, 0xf9, 0x22,
-	0x32, 0xed, 0xce, 0xc4, 0x62, 0xd7, 0x1c, 0x3f, 0x10, 0x09, 0xdb, 0x35, 0xa2, 0x9a, 0x7f, 0x2d,
-	0xbb, 0x4c, 0x64, 0x76, 0x3c, 0x9d, 0x56, 0xb5, 0xeb, 0xf1, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff,
-	0xe9, 0xa7, 0x3b, 0x4d, 0x0f, 0x09, 0x00, 0x00,
+	// 1093 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5d, 0x6f, 0xdb, 0x36,
+	0x17, 0xae, 0x65, 0xf9, 0xeb, 0xd8, 0x4e, 0x55, 0xbe, 0x29, 0x60, 0xe4, 0x45, 0xdb, 0x4c, 0x05,
+	0x86, 0xa2, 0xc8, 0x9c, 0x20, 0xc5, 0x3e, 0xea, 0x0d, 0x18, 0xec, 0xcc, 0x0d, 0xd2, 0x26, 0x96,
+	0x41, 0x2b, 0xfb, 0xba, 0x11, 0x68, 0x8b, 0xa5, 0x39, 0xc8, 0xa6, 0x20, 0xd1, 0xc5, 0x92, 0xcb,
+	0x62, 0x57, 0xbb, 0xda, 0x9f, 0xd8, 0xed, 0x7e, 0xc6, 0xb0, 0xbf, 0xb1, 0x6e, 0xff, 0x63, 0x03,
+	0x49, 0xc9, 0x51, 0x3e, 0xb6, 0xb5, 0x77, 0x3c, 0x87, 0xcf, 0x79, 0xce, 0xe1, 0xc3, 0xc3, 0x23,
+	0x41, 0x2b, 0x9d, 0x93, 0x84, 0x86, 0xdd, 0x38, 0x11, 0x52, 0xa0, 0x2a, 0xe3, 0x92, 0x44, 0x67,
+	0x5b, 0x0f, 0x98, 0x10, 0x2c, 0xa2, 0xbb, 0xda, 0x3b, 0x5d, 0xbd, 0xdc, 0x95, 0x7c, 0x41, 0x53,
+	0x49, 0x16, 0xb1, 0x01, 0x6e, 0x6d, 0x5f, 0x05, 0x84, 0x34, 0x9d, 0x25, 0x3c, 0x96, 0x22, 0x31,
+	0x08, 0xf7, 0x4d, 0x09, 0x5a, 0x5e, 0x4c, 0x13, 0x22, 0xb9, 0x58, 0x9e, 0xa4, 0x0c, 0x75, 0xc1,
+	0x12, 0x71, 0xa7, 0xb4, 0x5d, 0x7a, 0xb4, 0xb1, 0x7f, 0xbf, 0x6b, 0x12, 0x75, 0x8b, 0x88, 0x0b,
+	0x03, 0x5b, 0x22, 0x46, 0x9f, 0x42, 0x33, 0x9d, 0x89, 0x98, 0x06, 0x11, 0x7d, 0x45, 0xa3, 0x8e,
+	0xa5, 0x03, 0xb7, 0x6e, 0x0c, 0x9c, 0x28, 0x1c, 0x06, 0x0d, 0x3f, 0x56, 0x68, 0xf7, 0x09, 0x34,
+	0xd6, 0x08, 0xd4, 0x84, 0xda, 0xe9, 0xe8, 0xc5, 0xc8, 0xfb, 0x6a, 0xe4, 0xdc, 0x52, 0xc6, 0xc9,
+	0xa9, 0xdf, 0xf7, 0x3d, 0xec, 0x94, 0x50, 0x0b, 0xea, 0xfd, 0x83, 0x83, 0xe1, 0x64, 0xe2, 0x61,
+	0xc7, 0x72, 0xf7, 0xa0, 0xa2, 0x99, 0xd0, 0x06, 0x00, 0x1e, 0x8e, 0xbd, 0xc9, 0x91, 0xef, 0xe1,
+	0x6f, 0x9c, 0x5b, 0x08, 0xa0, 0x3a, 0x19, 0xe2, 0x2f, 0x87, 0x2a, 0xa4, 0x09, 0xb5, 0x89, 0xef,
+	0xe1, 0xfe, 0xe1, 0xd0, 0xb1, 0xdc, 0xd7, 0x25, 0x68, 0xfa, 0x09, 0x59, 0xa6, 0x64, 0xa6, 0x33,
+	0x7d, 0x0c, 0x76, 0x2a, 0x69, 0x7e, 0xca, 0x87, 0x79, 0xb1, 0x05, 0x48, 0x71, 0x3d, 0x91, 0x34,
+	0xc6, 0x3a, 0xc0, 0xed, 0xc1, 0xed, 0x2b, 0x1b, 0xa8, 0x0d, 0x8d, 0x31, 0x1e, 0x1e, 0x78, 0x27,
+	0x27, 0x47, 0xbe, 0xa9, 0x21, 0x5b, 0xeb, 0xb2, 0xb1, 0x77, 0x7c, 0x3c, 0xe8, 0x1f, 0xbc, 0x70,
+	0x2c, 0xf7, 0x17, 0x0b, 0x00, 0xd3, 0x58, 0xa4, 0x5c, 0x8a, 0xe4, 0x0c, 0xbd, 0x07, 0xad, 0x54,
+	0x8a, 0x84, 0x30, 0x1a, 0x2c, 0xc9, 0x82, 0x6a, 0xe1, 0x1a, 0xb8, 0x99, 0xf9, 0x46, 0x64, 0x41,
+	0xd1, 0x43, 0x68, 0x27, 0x34, 0x22, 0x92, 0xbf, 0xa2, 0x41, 0x4c, 0xe4, 0xbc, 0x53, 0xd6, 0x98,
+	0x56, 0xee, 0x1c, 0x13, 0x39, 0x47, 0x7b, 0xb0, 0xc9, 0xb8, 0x0c, 0xc4, 0xf4, 0x3b, 0x3a, 0x93,
+	0x41, 0xc8, 0x13, 0x3a, 0x53, 0xfc, 0x1d, 0x5b, 0x63, 0x11, 0xe3, 0xd2, 0xd3, 0x5b, 0x5f, 0xe4,
+	0x3b, 0xe8, 0x10, 0xb6, 0x55, 0x04, 0x89, 0x24, 0x4d, 0x96, 0x44, 0xd2, 0xab, 0xb1, 0x9c, 0xa6,
+	0x9d, 0xca, 0x76, 0xf9, 0x51, 0x03, 0xdf, 0x63, 0x5c, 0xf6, 0x73, 0xd8, 0x65, 0x1a, 0x4e, 0x53,
+	0x55, 0x1f, 0x8b, 0x82, 0x64, 0x7d, 0xa6, 0x4e, 0xd5, 0xd4, 0xc7, 0xa2, 0xc2, 0x39, 0xdf, 0x87,
+	0xdb, 0x2c, 0x0a, 0xe2, 0x44, 0xe8, 0x1c, 0xfa, 0x18, 0x75, 0x0d, 0x6b, 0xb3, 0x68, 0x6c, 0xbc,
+	0xea, 0x1c, 0xcf, 0xed, 0x7a, 0xc9, 0xb1, 0x9e, 0xdb, 0xf5, 0x9a, 0x53, 0xc7, 0xb6, 0x82, 0xb9,
+	0x3f, 0x5b, 0xd0, 0x38, 0xe4, 0xf2, 0x40, 0x2c, 0x16, 0x5c, 0xa2, 0x0d, 0xb0, 0x78, 0xa8, 0x6f,
+	0xac, 0x81, 0x2d, 0x1e, 0xa2, 0x0e, 0xd4, 0xd2, 0x95, 0x2e, 0x49, 0x4b, 0xd7, 0xc2, 0xb9, 0x89,
+	0x10, 0xd8, 0x53, 0x11, 0x9e, 0x69, 0xb5, 0x5a, 0x58, 0xaf, 0xd1, 0x0e, 0x54, 0xc9, 0x4a, 0xce,
+	0x45, 0xa2, 0x75, 0x69, 0xee, 0x6f, 0xe6, 0x77, 0x6e, 0xd8, 0xfb, 0x7a, 0x0f, 0x67, 0x18, 0xb4,
+	0x0f, 0x8d, 0x99, 0xf6, 0x4b, 0x9a, 0x74, 0x2a, 0xff, 0x12, 0x70, 0x01, 0x43, 0xf7, 0x00, 0x62,
+	0x92, 0xd0, 0xa5, 0x0c, 0x78, 0x98, 0x76, 0xaa, 0x5a, 0xbf, 0x86, 0xf1, 0x1c, 0x85, 0x29, 0xfa,
+	0x3f, 0x34, 0x54, 0x21, 0x41, 0xca, 0xcf, 0x69, 0xa7, 0xb6, 0x5d, 0x7a, 0x54, 0xc6, 0x75, 0xe5,
+	0x98, 0xf0, 0x73, 0x8a, 0x3e, 0x83, 0x8d, 0x94, 0xb3, 0x25, 0x91, 0xab, 0x84, 0x06, 0xf2, 0x2c,
+	0xa6, 0x5a, 0xa2, 0x8d, 0xfd, 0xbb, 0x79, 0xd2, 0x49, 0xbe, 0xeb, 0x9f, 0xc5, 0x14, 0xb7, 0xd3,
+	0xa2, 0xe9, 0xfe, 0x50, 0x82, 0x56, 0xb1, 0x2a, 0x25, 0x80, 0x6e, 0xa9, 0x92, 0x11, 0x40, 0xad,
+	0xd1, 0x26, 0x54, 0xe8, 0x82, 0xf0, 0x28, 0x13, 0xcb, 0x18, 0xa8, 0x0b, 0x76, 0x48, 0x24, 0xd5,
+	0x52, 0x35, 0xd5, 0xab, 0xd5, 0xe3, 0xa2, 0x9b, 0x8f, 0x8b, 0xae, 0x9f, 0xcf, 0x13, 0xac, 0x71,
+	0x68, 0x0b, 0xea, 0x6a, 0xc4, 0x9c, 0x8b, 0x25, 0xd5, 0x42, 0xb6, 0xf0, 0xda, 0x76, 0x5d, 0x80,
+	0xe1, 0xf7, 0x5c, 0x4e, 0x24, 0x91, 0xab, 0x54, 0xe5, 0x7b, 0x45, 0xa2, 0x95, 0x29, 0xa2, 0x82,
+	0x8d, 0xe1, 0xfa, 0x50, 0x1d, 0x24, 0x64, 0x39, 0x9b, 0xdf, 0x58, 0xe3, 0x47, 0xd0, 0x96, 0x24,
+	0x61, 0x54, 0x06, 0x46, 0x56, 0x5d, 0x6b, 0x73, 0xff, 0x4e, 0xae, 0xc2, 0xba, 0x19, 0x70, 0xcb,
+	0xe0, 0x8c, 0xe5, 0xfe, 0x68, 0x41, 0xd9, 0x27, 0xec, 0x46, 0x4e, 0xd3, 0x36, 0xd6, 0xba, 0x6d,
+	0xae, 0xe5, 0x28, 0xbf, 0x55, 0x0e, 0xd5, 0x6e, 0x0b, 0x9a, 0xa6, 0x84, 0xe5, 0x07, 0xcf, 0x4d,
+	0xf5, 0x90, 0xb3, 0xa5, 0xb9, 0xdc, 0x8a, 0xbe, 0xdc, 0x66, 0xe6, 0xd3, 0xf7, 0xbb, 0x03, 0x55,
+	0x49, 0x18, 0xa3, 0x89, 0x7e, 0x21, 0xff, 0xd8, 0x7d, 0x06, 0x73, 0x43, 0x37, 0xd4, 0xde, 0xa1,
+	0x1b, 0x5e, 0x82, 0x7d, 0x9a, 0xd2, 0x04, 0xfd, 0x0f, 0x2a, 0x2c, 0x0a, 0xd6, 0x4f, 0xc6, 0x66,
+	0xd1, 0x51, 0xb8, 0x56, 0xc8, 0xba, 0xa9, 0x33, 0xca, 0xc5, 0xce, 0x78, 0x00, 0x4d, 0x16, 0x05,
+	0xab, 0x54, 0xbd, 0xfd, 0x05, 0xcd, 0xa6, 0x09, 0xb0, 0xe8, 0x34, 0xf3, 0xb8, 0xcf, 0x00, 0xcc,
+	0x44, 0x18, 0x0b, 0x11, 0xa1, 0x4f, 0x00, 0x0a, 0x73, 0xa0, 0xa4, 0x4f, 0x89, 0xf2, 0x7a, 0x2f,
+	0xa6, 0xc1, 0xc0, 0xfe, 0xe9, 0xd7, 0x9d, 0x12, 0x2e, 0x60, 0x1f, 0x0f, 0x72, 0x1e, 0x55, 0xfd,
+	0xe5, 0x6f, 0x40, 0x71, 0x96, 0xd6, 0xc1, 0x1e, 0x1c, 0x7b, 0x03, 0xc7, 0x52, 0x2b, 0x1f, 0x0f,
+	0x87, 0x4e, 0x19, 0xd5, 0xa0, 0xec, 0xf7, 0x0f, 0x1d, 0xfb, 0xf1, 0x0e, 0xb4, 0x2f, 0x69, 0xa2,
+	0x30, 0x23, 0x6f, 0x34, 0x74, 0x6e, 0x29, 0xcc, 0xf8, 0x70, 0x6c, 0x08, 0xbe, 0xfe, 0x70, 0xef,
+	0xa9, 0x63, 0xf5, 0x3c, 0xa8, 0x89, 0x58, 0x0b, 0x8b, 0xee, 0x5f, 0xeb, 0xf8, 0x13, 0x2a, 0xe7,
+	0x22, 0xf4, 0x62, 0x35, 0xdf, 0xd3, 0xce, 0x5f, 0xaf, 0xaf, 0xbc, 0xfe, 0xe2, 0xf7, 0x0c, 0x57,
+	0x45, 0xac, 0xb2, 0xf5, 0x9e, 0x42, 0x2d, 0x1b, 0xdb, 0xe8, 0xde, 0x35, 0xc2, 0x67, 0x9c, 0x46,
+	0x6b, 0xbe, 0xdf, 0x7f, 0x53, 0x7c, 0x75, 0x9c, 0xe3, 0x7b, 0x9f, 0x17, 0x75, 0xfb, 0xaf, 0xe8,
+	0x37, 0x59, 0x74, 0x21, 0xa4, 0x77, 0x0c, 0x77, 0xb2, 0x7e, 0x7e, 0x7b, 0x9e, 0x3f, 0x32, 0x1e,
+	0xc7, 0x44, 0x5e, 0x5c, 0x4f, 0xcf, 0x87, 0xbb, 0x24, 0x0c, 0xb9, 0x82, 0x91, 0xe8, 0x1d, 0x18,
+	0xff, 0xcc, 0x18, 0x37, 0x2f, 0xa2, 0x0b, 0x97, 0xbe, 0xf7, 0xad, 0x92, 0x2f, 0x22, 0xd3, 0xee,
+	0x4c, 0x2c, 0x76, 0xcd, 0xf2, 0x03, 0x91, 0xb0, 0x5d, 0x23, 0xaa, 0xf9, 0x3b, 0xd9, 0x65, 0x22,
+	0xb3, 0xe3, 0xe9, 0xb4, 0xaa, 0x5d, 0x4f, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xee, 0xd3, 0x49,
+	0x70, 0xf7, 0x08, 0x00, 0x00,
 }
diff --git a/proto/go/internal/linter/method.go b/proto/go/internal/linter/method.go
index 4fce1d8ff1..a93d4cd85e 100644
--- a/proto/go/internal/linter/method.go
+++ b/proto/go/internal/linter/method.go
@@ -105,42 +105,33 @@ func (ml methodLinter) ensureValidStorage(expected int) error {
 }
 
 func (ml methodLinter) ensureValidTargetRepository(expected int) error {
-	/*
-		topLevelMsgs, err := ml.getTopLevelMsgs()
-		if err != nil {
-			return err
-		}
-
-		reqMsgName, err := lastName(ml.methodDesc.GetInputType())
-		if err != nil {
-			return err
-		}
-
-		msgT := topLevelMsgs[reqMsgName]
-
-		m := matcher{
-			match:        internal.GetTargetRepositoryExtension,
-			subMatch:     internal.GetRepositoryExtension,
-			expectedType: ".gitaly.Repository",
-			topLevelMsgs: topLevelMsgs,
-		}
+	topLevelMsgs, err := ml.getTopLevelMsgs()
+	if err != nil {
+		return err
+	}
 
-	*/
+	reqMsgName, err := lastName(ml.methodDesc.GetInputType())
+	if err != nil {
+		return err
+	}
 
-	/*
-		storageFields, err := m.findMatchingFields(reqMsgName, msgT)
-		if err != nil {
-			return err
-		}
+	msgT := topLevelMsgs[reqMsgName]
 
-	*/
+	m := matcher{
+		match:        internal.GetTargetRepositoryExtension,
+		subMatch:     internal.GetRepositoryExtension,
+		expectedType: ".gitaly.Repository",
+		topLevelMsgs: topLevelMsgs,
+	}
 
-	/*
-		if len(storageFields) != expected {
-			return fmt.Errorf("unexpected count of target_repository fields %d, expected %d, found target_repository label at: %v", len(storageFields), expected, storageFields)
-		}
+	storageFields, err := m.findMatchingFields(reqMsgName, msgT)
+	if err != nil {
+		return err
+	}
 
-	*/
+	if len(storageFields) != expected {
+		return fmt.Errorf("unexpected count of target_repository fields %d, expected %d, found target_repository label at: %v", len(storageFields), expected, storageFields)
+	}
 
 	return nil
 }
diff --git a/proto/repository-service.proto b/proto/repository-service.proto
index 67ce7605a1..4462eea49a 100644
--- a/proto/repository-service.proto
+++ b/proto/repository-service.proto
@@ -336,14 +336,14 @@ message WriteRefRequest {
   // This used to be a boolean indicating whether or not to shell out or use
   // the rugged implementation
   reserved 6;
-  TransactionStep transaction_step = 7;
+  Transaction transaction = 7;
 }
 
 message WriteRefResponse {
   // This used to contain an error message. Since we're shelling out
   // all exceptions are wrapped in GRPC errors.
   reserved 1;
-  TransactionStep transaction_step = 2;
+  Transaction transaction = 2;
 }
 
 message FindMergeBaseRequest {
diff --git a/proto/shared.proto b/proto/shared.proto
index 29afd1eaa2..cd84477624 100644
--- a/proto/shared.proto
+++ b/proto/shared.proto
@@ -29,19 +29,16 @@ message OperationMsg {
   Scope scope_level = 2;
 }
 
-message TransactionStep {
+message Transaction {
     enum TransactionStep {
         PRECOMMIT = 0;
         COMMIT = 1;
         ROLLBACK = 2;
     }
 
-    string id = 1;
-    TransactionStep step = 2;
+    TransactionStep step = 1;
 }
 
-
-
 enum ObjectType {
   UNKNOWN = 0;
   COMMIT = 1;
diff --git a/ruby/proto/gitaly/repository-service_pb.rb b/ruby/proto/gitaly/repository-service_pb.rb
index 00686bd903..9b1f7b0691 100644
--- a/ruby/proto/gitaly/repository-service_pb.rb
+++ b/ruby/proto/gitaly/repository-service_pb.rb
@@ -106,10 +106,10 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :revision, :bytes, 3
     optional :old_revision, :bytes, 4
     optional :force, :bool, 5
-    optional :transaction_step, :message, 7, "gitaly.TransactionStep"
+    optional :transaction, :message, 7, "gitaly.Transaction"
   end
   add_message "gitaly.WriteRefResponse" do
-    optional :transaction_step, :message, 2, "gitaly.TransactionStep"
+    optional :transaction, :message, 2, "gitaly.Transaction"
   end
   add_message "gitaly.FindMergeBaseRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
diff --git a/ruby/proto/gitaly/shared_pb.rb b/ruby/proto/gitaly/shared_pb.rb
index ed42cba994..b70b4d9003 100644
--- a/ruby/proto/gitaly/shared_pb.rb
+++ b/ruby/proto/gitaly/shared_pb.rb
@@ -19,11 +19,10 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     value :SERVER, 1
     value :STORAGE, 2
   end
-  add_message "gitaly.TransactionStep" do
-    optional :id, :string, 1
-    optional :step, :enum, 2, "gitaly.TransactionStep.TransactionStep"
+  add_message "gitaly.Transaction" do
+    optional :step, :enum, 1, "gitaly.Transaction.TransactionStep"
   end
-  add_enum "gitaly.TransactionStep.TransactionStep" do
+  add_enum "gitaly.Transaction.TransactionStep" do
     value :PRECOMMIT, 0
     value :COMMIT, 1
     value :ROLLBACK, 2
@@ -95,8 +94,8 @@ module Gitaly
   OperationMsg = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg").msgclass
   OperationMsg::Operation = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg.Operation").enummodule
   OperationMsg::Scope = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg.Scope").enummodule
-  TransactionStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.TransactionStep").msgclass
-  TransactionStep::TransactionStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.TransactionStep.TransactionStep").enummodule
+  Transaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Transaction").msgclass
+  Transaction::TransactionStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Transaction.TransactionStep").enummodule
   Repository = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Repository").msgclass
   GitCommit = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.GitCommit").msgclass
   CommitAuthor = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitAuthor").msgclass
-- 
GitLab


From 7f8b3001b3e9d9f5a4c9a35d9da8c6f5581b0186 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Wed, 26 Feb 2020 11:18:14 -0800
Subject: [PATCH 4/8] separate to different rpc

---
 internal/git/repository/repository.go         |  55 +-
 .../repositoryhandler/transactions.go         |  33 +-
 internal/praefect/coordinator.go              |  18 +-
 internal/praefect/grpc-proxy/proxy/handler.go |  20 +-
 internal/praefect/helper_test.go              |   3 +-
 internal/praefect/replicator_test.go          |   3 +-
 internal/praefect/server.go                   |   2 +-
 internal/server/server.go                     |   9 +-
 .../service/repository/testhelper_test.go     |   3 +-
 internal/service/repository/write_ref.go      |  98 +--
 internal/service/repository/write_ref_tx.go   | 137 ++++
 proto/go/gitalypb/repository-service.pb.go    | 671 +++++++++++-------
 proto/repository-service.proto                |  27 +-
 ruby/proto/gitaly/repository-service_pb.rb    |  15 +-
 .../gitaly/repository-service_services_pb.rb  |   1 +
 15 files changed, 653 insertions(+), 442 deletions(-)
 create mode 100644 internal/service/repository/write_ref_tx.go

diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index c086c1b3e2..02c1081f13 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -4,13 +4,10 @@ import (
 	"errors"
 	"sync"
 
-	"gitlab.com/gitlab-org/gitaly/internal/log"
-
 	"github.com/sirupsen/logrus"
-
-	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
-
 	"gitlab.com/gitlab-org/gitaly/internal/command"
+	"gitlab.com/gitlab-org/gitaly/internal/log"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
 
 // GitRepo supplies an interface for executing `git.Command`s
@@ -37,6 +34,7 @@ type Transactions struct {
 }
 
 func (t *Transactions) NewTransaction(transactionID string, repo *gitalypb.Repository) {
+	logrus.WithField("transaction_id", transactionID).Info("creating new transaction")
 	tx := Transaction{
 		Repo: repo,
 	}
@@ -46,15 +44,15 @@ func (t *Transactions) NewTransaction(transactionID string, repo *gitalypb.Repos
 	t.transactions[transactionID] = &tx
 
 	t.repoMutex.Lock()
+
 	_, ok := t.repositories[repo.RelativePath]
 	if !ok {
 		t.repositories[repo.RelativePath] = &sync.Mutex{}
 	}
 
 	t.repositories[repo.RelativePath].Lock()
-	t.repoMutex.Unlock()
 
-	t.log.WithField("relative_path", repo.RelativePath).Info("transaction created")
+	t.repoMutex.Unlock()
 }
 
 func (t *Transactions) Start(transactionID string, rollback command.Cmd) {
@@ -132,51 +130,12 @@ func (t *Transactions) TransactionStarted(transactionID string) bool {
 	defer t.txMutex.Unlock()
 
 	_, ok := t.transactions[transactionID]
-	if !ok {
-		return false
-	}
-	return true
+
+	return ok
 }
 
 type Transaction struct {
-	//	serviceName string
-	//	methodName  string
-	//	transactionID   string
 	Repo       GitRepo
 	Rollback   command.Cmd
 	inProgress bool
 }
-
-type RepoLock interface {
-	Lock(relativePath string)
-	Unlock(relativePath string)
-}
-
-type repoLock struct {
-	m     sync.RWMutex
-	locks map[string]sync.RWMutex
-}
-
-func (r *repoLock) Lock(relativePath string) {
-	l, ok := r.locks[relativePath]
-	if !ok {
-		l = sync.RWMutex{}
-		r.m.Lock()
-		defer r.m.Unlock()
-		r.locks[relativePath] = l
-	}
-	l.Lock()
-}
-
-func (r *repoLock) Unlock(relativePath string) {
-	l, ok := r.locks[relativePath]
-	if ok {
-		l.Lock()
-	}
-}
-
-func NewRepoLock() *repoLock {
-	return &repoLock{
-		locks: make(map[string]sync.RWMutex),
-	}
-}
diff --git a/internal/middleware/repositoryhandler/transactions.go b/internal/middleware/repositoryhandler/transactions.go
index 45c802faba..8cfeb7ae6d 100644
--- a/internal/middleware/repositoryhandler/transactions.go
+++ b/internal/middleware/repositoryhandler/transactions.go
@@ -6,16 +6,12 @@ import (
 	"fmt"
 	"reflect"
 
-	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
-
-	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
-
 	"github.com/google/uuid"
-	"google.golang.org/grpc/metadata"
-
 	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
-
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
 )
 
 type RepositoryRequest interface {
@@ -26,7 +22,7 @@ func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions
 	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
 		mi, err := registry.LookupMethod(info.FullMethod)
 		if err != nil {
-			return nil, err
+			return handler(ctx, req)
 		}
 
 		if mi.Scope == protoregistry.ScopeRepository && mi.Operation == protoregistry.OpMutator {
@@ -37,7 +33,6 @@ func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions
 				transactionID = md.Get("transaction_id")[0]
 			} else {
 				transactionID = uuid.New().String()
-
 			}
 
 			if !transactions.TransactionStarted(transactionID) {
@@ -45,20 +40,20 @@ func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions
 				if !ok {
 					return nil, errors.New("not a repository request")
 				}
-
-				transactions.NewTransaction(transactionID, repoReq.GetRepository())
+				if repoReq.GetRepository() != nil {
+					transactions.NewTransaction(transactionID, repoReq.GetRepository())
+				}
 			}
 
 			defer transactions.Unlock(transactionID)
 
-			ctx = metadata.NewIncomingContext(ctx, metadata.New(map[string]string{"transaction_id": transactionID}))
+			md.Set("transaction_id", transactionID)
+			ctx = metadata.NewIncomingContext(ctx, md)
 
 			grpc.SetTrailer(ctx, metadata.New(map[string]string{"transaction_id": transactionID}))
 		}
 
-		res, err := handler(ctx, req)
-
-		return res, err
+		return handler(ctx, req)
 	}
 }
 
@@ -102,7 +97,7 @@ func (t TransactionServerStream) RecvMsg(m interface{}) error {
 	if !t.transactions.TransactionStarted(t.transactionID) {
 		fmt.Printf("Receiving Message: type=%s\n", reflect.TypeOf(m).String())
 		repoReq, ok := m.(RepositoryRequest)
-		if ok {
+		if ok && repoReq.GetRepository() != nil {
 			t.transactions.NewTransaction(t.transactionID, repoReq.GetRepository())
 		}
 	}
@@ -115,17 +110,15 @@ func (t TransactionServerStream) RecvMsg(m interface{}) error {
 // StreamInterceptor returns a Stream Interceptor
 func RepositoryTransactionServerInterceptor(transactions *repository.Transactions, registry *protoregistry.Registry) grpc.StreamServerInterceptor {
 	return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
-		ctx := stream.Context()
-
 		mi, err := registry.LookupMethod(info.FullMethod)
 		if err != nil {
-			return err
+			return handler(srv, stream)
 		}
 
 		if mi.Scope == protoregistry.ScopeRepository && mi.Operation == protoregistry.OpMutator {
 			var transactionID string
 
-			md, ok := metadata.FromIncomingContext(ctx)
+			md, ok := metadata.FromIncomingContext(stream.Context())
 			if ok && len(md.Get("transaction_id")) > 0 {
 				transactionID = md.Get("transaction_id")[0]
 			} else {
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index fa7a24abac..3319935d2a 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -8,10 +8,6 @@ import (
 	"sync"
 	"syscall"
 
-	"google.golang.org/grpc/metadata"
-
-	"google.golang.org/grpc"
-
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/protoc-gen-go/descriptor"
 	"github.com/sirupsen/logrus"
@@ -21,7 +17,9 @@ import (
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/nodes"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 )
 
@@ -114,7 +112,7 @@ func (c *Coordinator) directRepositoryScopedMessage(ctx context.Context, mi prot
 func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string, peeker proxy.StreamModifier) (*proxy.StreamParameters, error) {
 	// For phase 1, we need to route messages based on the storage location
 	// to the appropriate Gitaly node.
-	c.log.Debugf("Stream director received method %s", fullMethodName)
+	c.log.Infof("Stream director received method %s", fullMethodName)
 
 	c.failoverMutex.RLock()
 	defer c.failoverMutex.RUnlock()
@@ -149,14 +147,14 @@ func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string,
 	return proxy.NewStreamParameters(ctx, primary.GetConnection(), func() {}, nil), nil
 }
 
-func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
+func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
 	var writeRefReq gitalypb.WriteRefRequest
 
 	if err := serverStream.RecvMsg(&writeRefReq); err != nil {
 		return err
 	}
 
-	shard, err := s.nodeMgr.GetShard(writeRefReq.GetRepository().GetStorageName())
+	shard, err := c.nodeMgr.GetShard(writeRefReq.GetRepository().GetStorageName())
 	if err != nil {
 		return err
 	}
@@ -186,7 +184,7 @@ func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		}
 		var trailer metadata.MD
 
-		if _, err := client.WriteRef(ctx, &gitalypb.WriteRefRequest{
+		if _, err := client.WriteRefTx(ctx, &gitalypb.WriteRefTxRequest{
 			Repository:  targetRepo,
 			Ref:         writeRefReq.Ref,
 			Revision:    writeRefReq.Revision,
@@ -210,7 +208,7 @@ func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 	if len(errs) == 0 {
 		for transactionID, node := range transactionIDs {
 			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-			if _, err = client.WriteRef(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefRequest{
+			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{
 				Transaction: &gitalypb.Transaction{
 					Step: gitalypb.Transaction_COMMIT,
 				}}); err != nil {
@@ -224,7 +222,7 @@ func (s *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 	// Rollback
 	for transactionID, node := range transactionIDs {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-		if _, err = client.WriteRef(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefRequest{
+		if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{
 			Transaction: &gitalypb.Transaction{
 				Step: gitalypb.Transaction_ROLLBACK,
 			}}); err != nil {
diff --git a/internal/praefect/grpc-proxy/proxy/handler.go b/internal/praefect/grpc-proxy/proxy/handler.go
index 3c3676d34d..70ec007d7b 100644
--- a/internal/praefect/grpc-proxy/proxy/handler.go
+++ b/internal/praefect/grpc-proxy/proxy/handler.go
@@ -27,7 +27,7 @@ var (
 // The behaviour is the same as if you were registering a handler method, e.g. from a codegenerated pb.go file.
 //
 // This can *only* be used if the `server` also uses grpcproxy.CodecForServer() ServerOption.
-func RegisterService(server *grpc.Server, streamer grpc.StreamHandler, serviceName string, methodNames ...string) {
+func RegisterMutator(server *grpc.Server, streamer grpc.StreamHandler, serviceName string, methodNames ...string) {
 	fakeDesc := &grpc.ServiceDesc{
 		ServiceName: serviceName,
 		HandlerType: (*interface{})(nil),
@@ -44,6 +44,24 @@ func RegisterService(server *grpc.Server, streamer grpc.StreamHandler, serviceNa
 	server.RegisterService(fakeDesc, streamer)
 }
 
+func RegisterService(server *grpc.Server, director StreamDirector, serviceName string, methodNames ...string) {
+	streamer := &handler{director}
+	fakeDesc := &grpc.ServiceDesc{
+		ServiceName: serviceName,
+		HandlerType: (*interface{})(nil),
+	}
+	for _, m := range methodNames {
+		streamDesc := grpc.StreamDesc{
+			StreamName:    m,
+			Handler:       streamer.handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		}
+		fakeDesc.Streams = append(fakeDesc.Streams, streamDesc)
+	}
+	server.RegisterService(fakeDesc, streamer)
+}
+
 // TransparentHandler returns a handler that attempts to proxy all requests that are not registered in the server.
 // The indented use here is as a transparent proxy, where the server doesn't know about the services implemented by the
 // backends. It should be used as a `grpc.UnknownServiceHandler`.
diff --git a/internal/praefect/helper_test.go b/internal/praefect/helper_test.go
index 16094ac6c0..e6b9551716 100644
--- a/internal/praefect/helper_test.go
+++ b/internal/praefect/helper_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly/client"
 	internalauth "gitlab.com/gitlab-org/gitaly/internal/config/auth"
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/log"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
@@ -253,7 +254,7 @@ func runInternalGitalyServer(t *testing.T, token string) (*grpc.Server, string,
 	require.NoError(t, rubyServer.Start())
 
 	gitalypb.RegisterServerServiceServer(server, gitalyserver.NewServer())
-	gitalypb.RegisterRepositoryServiceServer(server, repository.NewServer(rubyServer))
+	gitalypb.RegisterRepositoryServiceServer(server, repository.NewServer(repo.NewTransactions(), rubyServer))
 	healthpb.RegisterHealthServer(server, health.NewServer())
 
 	errQ := make(chan error)
diff --git a/internal/praefect/replicator_test.go b/internal/praefect/replicator_test.go
index 24b10b0517..f9b039248d 100644
--- a/internal/praefect/replicator_test.go
+++ b/internal/praefect/replicator_test.go
@@ -13,6 +13,7 @@ import (
 	gitalyauth "gitlab.com/gitlab-org/gitaly/auth"
 	gitaly_config "gitlab.com/gitlab-org/gitaly/internal/config"
 	"gitlab.com/gitlab-org/gitaly/internal/git/objectpool"
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/models"
@@ -449,7 +450,7 @@ func newReplicationService(tb testing.TB) (*grpc.Server, string) {
 
 	svr := testhelper.NewTestGrpcServer(tb, nil, nil)
 
-	gitalypb.RegisterRepositoryServiceServer(svr, repository.NewServer(&rubyserver.Server{}))
+	gitalypb.RegisterRepositoryServiceServer(svr, repository.NewServer(repo.NewTransactions(), &rubyserver.Server{}))
 	gitalypb.RegisterObjectPoolServiceServer(svr, objectpoolservice.NewServer())
 	gitalypb.RegisterRemoteServiceServer(svr, remote.NewServer(&rubyserver.Server{}))
 	reflection.Register(svr)
diff --git a/internal/praefect/server.go b/internal/praefect/server.go
index ef129f2923..80c7337a7a 100644
--- a/internal/praefect/server.go
+++ b/internal/praefect/server.go
@@ -106,7 +106,7 @@ func NewServer(c *Coordinator, repl ReplMgr, grpcOpts []grpc.ServerOption, l *lo
 	}
 
 	s.warnDupeAddrs(conf)
-	proxy.RegisterService(s.s, c.HandleWriteRef, "gitaly.RepositoryService", "WriteRef")
+	proxy.RegisterMutator(s.s, c.HandleWriteRef, "gitaly.RepositoryService", "WriteRef")
 
 	return s
 }
diff --git a/internal/server/server.go b/internal/server/server.go
index 32749eb9a2..e7fd93f83f 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -5,12 +5,6 @@ import (
 	"crypto/tls"
 	"os"
 
-	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
-
-	"gitlab.com/gitlab-org/gitaly/internal/middleware/repositoryhandler"
-
-	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
-
 	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpc_logrus "github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus"
 	grpc_ctxtags "github.com/grpc-ecosystem/go-grpc-middleware/tags"
@@ -18,6 +12,7 @@ import (
 	log "github.com/sirupsen/logrus"
 	diskcache "gitlab.com/gitlab-org/gitaly/internal/cache"
 	"gitlab.com/gitlab-org/gitaly/internal/config"
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/helper/fieldextractors"
 	gitalylog "gitlab.com/gitlab-org/gitaly/internal/log"
 	"gitlab.com/gitlab-org/gitaly/internal/logsanitizer"
@@ -26,7 +21,9 @@ import (
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/limithandler"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/metadatahandler"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/panichandler"
+	"gitlab.com/gitlab-org/gitaly/internal/middleware/repositoryhandler"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/sentryhandler"
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/internal/server/auth"
diff --git a/internal/service/repository/testhelper_test.go b/internal/service/repository/testhelper_test.go
index 37c5e6d892..2c0b43c4cb 100644
--- a/internal/service/repository/testhelper_test.go
+++ b/internal/service/repository/testhelper_test.go
@@ -14,6 +14,7 @@ import (
 	"gitlab.com/gitlab-org/gitaly/client"
 	dcache "gitlab.com/gitlab-org/gitaly/internal/cache"
 	"gitlab.com/gitlab-org/gitaly/internal/config"
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	mcache "gitlab.com/gitlab-org/gitaly/internal/middleware/cache"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
@@ -84,7 +85,7 @@ func runRepoServer(t *testing.T) (*grpc.Server, string) {
 		t.Fatal(err)
 	}
 
-	gitalypb.RegisterRepositoryServiceServer(server, NewServer(RubyServer))
+	gitalypb.RegisterRepositoryServiceServer(server, NewServer(repo.NewTransactions(), RubyServer))
 	reflection.Register(server)
 
 	go server.Serve(listener)
diff --git a/internal/service/repository/write_ref.go b/internal/service/repository/write_ref.go
index bac47a5cb7..9a94c1030e 100644
--- a/internal/service/repository/write_ref.go
+++ b/internal/service/repository/write_ref.go
@@ -3,89 +3,33 @@ package repository
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 
-	"google.golang.org/grpc/metadata"
-
-	"gitlab.com/gitlab-org/gitaly/internal/command"
-
 	"gitlab.com/gitlab-org/gitaly/internal/git"
 	"gitlab.com/gitlab-org/gitaly/internal/git/updateref"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
 
-func nonTransactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
-	if err := writeRef(ctx, req); err != nil {
-		return nil, helper.ErrInternal(err)
-	}
-
-	return &gitalypb.WriteRefResponse{}, nil
-}
-
-func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
-	var resp gitalypb.WriteRefResponse
-
-	md, ok := metadata.FromIncomingContext(ctx)
-	if !ok {
-		return nil, helper.ErrInternal(errors.New("couldn't get metadata"))
-	}
-	if len(md.Get("transaction_id")) == 0 {
-		return nil, helper.ErrInternal(errors.New("expected request_id"))
-	}
-
-	transactionID := md.Get("transaction_id")[0]
-
-	switch req.Transaction.Step {
-	case gitalypb.Transaction_PRECOMMIT:
-		if err := writeRef(ctx, req); err != nil {
-			return nil, helper.ErrInternal(err)
-		}
-
-		rollback, err := rollbackRef(req)
-		if err != nil {
-			return nil, err
-		}
-		s.transactions.Start(transactionID, rollback)
-
-	case gitalypb.Transaction_COMMIT:
-		if err := s.transactions.Commit(transactionID); err != nil {
-			return nil, err
-		}
-	case gitalypb.Transaction_ROLLBACK:
-		if err := s.transactions.Rollback(transactionID); err != nil {
-			return nil, err
-		}
-	}
-
-	return &resp, nil
-}
-
 func (s *server) WriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*gitalypb.WriteRefResponse, error) {
 	if err := validateWriteRefRequest(req); err != nil {
 		return nil, helper.ErrInvalidArgument(err)
 	}
-
-	if req.Transaction == nil {
-		return nonTransactionalWriteRef(ctx, req)
+	if err := writeRef(ctx, req); err != nil {
+		return nil, helper.ErrInternal(err)
 	}
 
-	return s.transactionalWriteRef(ctx, req)
-}
-
-func rollbackSymbolicRef(req *gitalypb.WriteRefRequest) (*command.Command, error) {
-	return git.SafeCmd(context.Background(), req.GetRepository(), nil, git.SubCmd{Name: "symbolic-ref", Args: []string{string(req.GetRef()), string(req.GetOldRevision())}})
+	return &gitalypb.WriteRefResponse{}, nil
 }
 
-func writeRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
-	if string(req.Ref) == "HEAD" {
+func writeRef(ctx context.Context, req writeRefRequest) error {
+	if string(req.GetRef()) == "HEAD" {
 		return updateSymbolicRef(ctx, req)
 	}
 	return updateRef(ctx, req)
 }
 
-func updateSymbolicRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
+func updateSymbolicRef(ctx context.Context, req writeRefRequest) error {
 	cmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, git.SubCmd{Name: "symbolic-ref", Args: []string{string(req.GetRef()), string(req.GetRevision())}})
 	if err != nil {
 		return fmt.Errorf("error when creating symbolic-ref command: %v", err)
@@ -96,23 +40,7 @@ func updateSymbolicRef(ctx context.Context, req *gitalypb.WriteRefRequest) error
 	return nil
 }
 
-func rollbackRef(req *gitalypb.WriteRefRequest) (command.Cmd, error) {
-	if string(req.Ref) == "HEAD" {
-		return rollbackSymbolicRef(req)
-	}
-
-	u, err := updateref.New(context.Background(), req.GetRepository())
-	if err != nil {
-		return nil, fmt.Errorf("error when running creating new updater: %v", err)
-	}
-	if err = u.Update(string(req.GetRef()), string(req.GetOldRevision()), string(req.GetRevision())); err != nil {
-		return nil, fmt.Errorf("error when creating rollback-ref command: %v", err)
-	}
-
-	return u, nil
-}
-
-func updateRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
+func updateRef(ctx context.Context, req writeRefRequest) error {
 	u, err := updateref.New(ctx, req.GetRepository())
 	if err != nil {
 		return fmt.Errorf("error when running creating new updater: %v", err)
@@ -126,20 +54,20 @@ func updateRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
 	return nil
 }
 
-func validateWriteRefRequest(req *gitalypb.WriteRefRequest) error {
-	if err := git.ValidateRevision(req.Ref); err != nil {
+func validateWriteRefRequest(req writeRefRequest) error {
+	if err := git.ValidateRevision(req.GetRef()); err != nil {
 		return fmt.Errorf("invalid ref: %v", err)
 	}
-	if err := git.ValidateRevision(req.Revision); err != nil {
+	if err := git.ValidateRevision(req.GetRevision()); err != nil {
 		return fmt.Errorf("invalid revision: %v", err)
 	}
-	if len(req.OldRevision) > 0 {
-		if err := git.ValidateRevision(req.OldRevision); err != nil {
+	if len(req.GetOldRevision()) > 0 {
+		if err := git.ValidateRevision(req.GetOldRevision()); err != nil {
 			return fmt.Errorf("invalid OldRevision: %v", err)
 		}
 	}
 
-	if !bytes.Equal(req.Ref, []byte("HEAD")) && !bytes.HasPrefix(req.Ref, []byte("refs/")) {
+	if !bytes.Equal(req.GetRef(), []byte("HEAD")) && !bytes.HasPrefix(req.GetRef(), []byte("refs/")) {
 		return fmt.Errorf("ref has to be a full reference")
 	}
 	return nil
diff --git a/internal/service/repository/write_ref_tx.go b/internal/service/repository/write_ref_tx.go
new file mode 100644
index 0000000000..ceaf3560fe
--- /dev/null
+++ b/internal/service/repository/write_ref_tx.go
@@ -0,0 +1,137 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"io/ioutil"
+	"os/exec"
+
+	"gitlab.com/gitlab-org/gitaly/internal/command"
+	"gitlab.com/gitlab-org/gitaly/internal/git"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/internal/helper/text"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+	"google.golang.org/grpc/metadata"
+)
+
+type writeRefRequest interface {
+	GetRef() []byte
+	GetRevision() []byte
+	GetOldRevision() []byte
+	GetRepository() *gitalypb.Repository
+}
+
+func (s *server) WriteRefTx(ctx context.Context, req *gitalypb.WriteRefTxRequest) (*gitalypb.WriteRefTxResponse, error) {
+	if req.GetTransaction().Step == gitalypb.Transaction_PRECOMMIT {
+		if err := validateWriteRefRequest(req); err != nil {
+			return nil, helper.ErrInvalidArgument(err)
+		}
+	}
+
+	if req.Transaction == nil {
+		return nil, helper.ErrInvalidArgument(errors.New("transaction is empty"))
+	}
+
+	return s.transactionalWriteRef(ctx, req)
+}
+
+func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefTxRequest) (*gitalypb.WriteRefTxResponse, error) {
+	var resp gitalypb.WriteRefTxResponse
+
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return nil, helper.ErrInternal(errors.New("couldn't get metadata"))
+	}
+	if len(md.Get("transaction_id")) == 0 {
+		return nil, helper.ErrInternal(errors.New("expected request_id"))
+	}
+
+	transactionID := md.Get("transaction_id")[0]
+
+	switch req.Transaction.Step {
+	case gitalypb.Transaction_PRECOMMIT:
+		err := preCommit(ctx, req)
+		if err != nil {
+			return nil, err
+		}
+
+		rollback, err := rollbackRef(req)
+		if err != nil {
+			return nil, err
+		}
+
+		s.transactions.Start(transactionID, rollback)
+	case gitalypb.Transaction_COMMIT:
+		if err := writeRef(ctx, req); err != nil {
+			return nil, helper.ErrInternal(err)
+		}
+
+		if err := s.transactions.Commit(transactionID); err != nil {
+			return nil, err
+		}
+	case gitalypb.Transaction_ROLLBACK:
+		if err := s.transactions.Rollback(transactionID); err != nil {
+			return nil, err
+		}
+	default:
+		return nil, errors.New("unknown transaction step")
+	}
+
+	return &resp, nil
+}
+
+func preCommit(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
+	if req.GetOldRevision() == nil {
+		return nil
+	}
+
+	cmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, git.SubCmd{
+		Name: "rev-parse",
+		Args: []string{string(req.GetRef())},
+	})
+	if err != nil {
+		return err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return err
+	}
+
+	rev, err := ioutil.ReadAll(cmd)
+	if err != nil {
+		return err
+	}
+
+	if text.ChompBytes(rev) != string(req.GetOldRevision()) {
+		return errors.New("not ready")
+	}
+
+	return nil
+}
+
+func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (*command.Command, error) {
+	return git.SafeCmd(context.Background(), req.GetRepository(), nil, git.SubCmd{Name: "symbolic-ref", Args: []string{string(req.GetRef()), string(req.GetOldRevision())}})
+}
+
+func rollbackRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+	if string(req.Ref) == "HEAD" {
+		return rollbackSymbolicRef(req)
+	}
+
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	args := []string{"-C", repoPath, "update-ref"}
+
+	if req.GetOldRevision() == nil {
+		args = append(args, "-d", string(req.GetRevision()))
+	} else {
+		args = append(args, string(req.GetOldRevision()), string(req.GetRevision()))
+	}
+
+	c := exec.Command("git", args...)
+
+	return c, nil
+}
diff --git a/proto/go/gitalypb/repository-service.pb.go b/proto/go/gitalypb/repository-service.pb.go
index a86203ee5e..b432870f21 100644
--- a/proto/go/gitalypb/repository-service.pb.go
+++ b/proto/go/gitalypb/repository-service.pb.go
@@ -92,7 +92,7 @@ func (x GetRawChangesResponse_RawChange_Operation) String() string {
 }
 
 func (GetRawChangesResponse_RawChange_Operation) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{61, 0, 0}
+	return fileDescriptor_e9b1768cf174c79b, []int{63, 0, 0}
 }
 
 type RepositoryExistsRequest struct {
@@ -1199,15 +1199,14 @@ func (m *FsckResponse) GetError() []byte {
 }
 
 type WriteRefRequest struct {
-	Repository           *Repository  `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	Ref                  []byte       `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
-	Revision             []byte       `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
-	OldRevision          []byte       `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
-	Force                bool         `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
-	Transaction          *Transaction `protobuf:"bytes,7,opt,name=transaction,proto3" json:"transaction,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Ref                  []byte      `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
+	Revision             []byte      `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	OldRevision          []byte      `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
+	Force                bool        `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
 }
 
 func (m *WriteRefRequest) Reset()         { *m = WriteRefRequest{} }
@@ -1270,18 +1269,10 @@ func (m *WriteRefRequest) GetForce() bool {
 	return false
 }
 
-func (m *WriteRefRequest) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
 type WriteRefResponse struct {
-	Transaction          *Transaction `protobuf:"bytes,2,opt,name=transaction,proto3" json:"transaction,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *WriteRefResponse) Reset()         { *m = WriteRefResponse{} }
@@ -1309,7 +1300,120 @@ func (m *WriteRefResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WriteRefResponse proto.InternalMessageInfo
 
-func (m *WriteRefResponse) GetTransaction() *Transaction {
+type WriteRefTxRequest struct {
+	Repository           *Repository  `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Ref                  []byte       `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
+	Revision             []byte       `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	OldRevision          []byte       `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
+	Force                bool         `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
+	Transaction          *Transaction `protobuf:"bytes,7,opt,name=transaction,proto3" json:"transaction,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *WriteRefTxRequest) Reset()         { *m = WriteRefTxRequest{} }
+func (m *WriteRefTxRequest) String() string { return proto.CompactTextString(m) }
+func (*WriteRefTxRequest) ProtoMessage()    {}
+func (*WriteRefTxRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e9b1768cf174c79b, []int{28}
+}
+
+func (m *WriteRefTxRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WriteRefTxRequest.Unmarshal(m, b)
+}
+func (m *WriteRefTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WriteRefTxRequest.Marshal(b, m, deterministic)
+}
+func (m *WriteRefTxRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WriteRefTxRequest.Merge(m, src)
+}
+func (m *WriteRefTxRequest) XXX_Size() int {
+	return xxx_messageInfo_WriteRefTxRequest.Size(m)
+}
+func (m *WriteRefTxRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_WriteRefTxRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WriteRefTxRequest proto.InternalMessageInfo
+
+func (m *WriteRefTxRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetRef() []byte {
+	if m != nil {
+		return m.Ref
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetOldRevision() []byte {
+	if m != nil {
+		return m.OldRevision
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetForce() bool {
+	if m != nil {
+		return m.Force
+	}
+	return false
+}
+
+func (m *WriteRefTxRequest) GetTransaction() *Transaction {
+	if m != nil {
+		return m.Transaction
+	}
+	return nil
+}
+
+type WriteRefTxResponse struct {
+	// This used to contain an error message. Since we're shelling out
+	// all exceptions are wrapped in GRPC errors.
+	Transaction          *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *WriteRefTxResponse) Reset()         { *m = WriteRefTxResponse{} }
+func (m *WriteRefTxResponse) String() string { return proto.CompactTextString(m) }
+func (*WriteRefTxResponse) ProtoMessage()    {}
+func (*WriteRefTxResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e9b1768cf174c79b, []int{29}
+}
+
+func (m *WriteRefTxResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WriteRefTxResponse.Unmarshal(m, b)
+}
+func (m *WriteRefTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WriteRefTxResponse.Marshal(b, m, deterministic)
+}
+func (m *WriteRefTxResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WriteRefTxResponse.Merge(m, src)
+}
+func (m *WriteRefTxResponse) XXX_Size() int {
+	return xxx_messageInfo_WriteRefTxResponse.Size(m)
+}
+func (m *WriteRefTxResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_WriteRefTxResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WriteRefTxResponse proto.InternalMessageInfo
+
+func (m *WriteRefTxResponse) GetTransaction() *Transaction {
 	if m != nil {
 		return m.Transaction
 	}
@@ -1331,7 +1435,7 @@ func (m *FindMergeBaseRequest) Reset()         { *m = FindMergeBaseRequest{} }
 func (m *FindMergeBaseRequest) String() string { return proto.CompactTextString(m) }
 func (*FindMergeBaseRequest) ProtoMessage()    {}
 func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{28}
+	return fileDescriptor_e9b1768cf174c79b, []int{30}
 }
 
 func (m *FindMergeBaseRequest) XXX_Unmarshal(b []byte) error {
@@ -1377,7 +1481,7 @@ func (m *FindMergeBaseResponse) Reset()         { *m = FindMergeBaseResponse{} }
 func (m *FindMergeBaseResponse) String() string { return proto.CompactTextString(m) }
 func (*FindMergeBaseResponse) ProtoMessage()    {}
 func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{29}
+	return fileDescriptor_e9b1768cf174c79b, []int{31}
 }
 
 func (m *FindMergeBaseResponse) XXX_Unmarshal(b []byte) error {
@@ -1417,7 +1521,7 @@ func (m *CreateForkRequest) Reset()         { *m = CreateForkRequest{} }
 func (m *CreateForkRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateForkRequest) ProtoMessage()    {}
 func (*CreateForkRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{30}
+	return fileDescriptor_e9b1768cf174c79b, []int{32}
 }
 
 func (m *CreateForkRequest) XXX_Unmarshal(b []byte) error {
@@ -1462,7 +1566,7 @@ func (m *CreateForkResponse) Reset()         { *m = CreateForkResponse{} }
 func (m *CreateForkResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateForkResponse) ProtoMessage()    {}
 func (*CreateForkResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{31}
+	return fileDescriptor_e9b1768cf174c79b, []int{33}
 }
 
 func (m *CreateForkResponse) XXX_Unmarshal(b []byte) error {
@@ -1495,7 +1599,7 @@ func (m *IsRebaseInProgressRequest) Reset()         { *m = IsRebaseInProgressReq
 func (m *IsRebaseInProgressRequest) String() string { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressRequest) ProtoMessage()    {}
 func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{32}
+	return fileDescriptor_e9b1768cf174c79b, []int{34}
 }
 
 func (m *IsRebaseInProgressRequest) XXX_Unmarshal(b []byte) error {
@@ -1541,7 +1645,7 @@ func (m *IsRebaseInProgressResponse) Reset()         { *m = IsRebaseInProgressRe
 func (m *IsRebaseInProgressResponse) String() string { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressResponse) ProtoMessage()    {}
 func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{33}
+	return fileDescriptor_e9b1768cf174c79b, []int{35}
 }
 
 func (m *IsRebaseInProgressResponse) XXX_Unmarshal(b []byte) error {
@@ -1581,7 +1685,7 @@ func (m *IsSquashInProgressRequest) Reset()         { *m = IsSquashInProgressReq
 func (m *IsSquashInProgressRequest) String() string { return proto.CompactTextString(m) }
 func (*IsSquashInProgressRequest) ProtoMessage()    {}
 func (*IsSquashInProgressRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{34}
+	return fileDescriptor_e9b1768cf174c79b, []int{36}
 }
 
 func (m *IsSquashInProgressRequest) XXX_Unmarshal(b []byte) error {
@@ -1627,7 +1731,7 @@ func (m *IsSquashInProgressResponse) Reset()         { *m = IsSquashInProgressRe
 func (m *IsSquashInProgressResponse) String() string { return proto.CompactTextString(m) }
 func (*IsSquashInProgressResponse) ProtoMessage()    {}
 func (*IsSquashInProgressResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{35}
+	return fileDescriptor_e9b1768cf174c79b, []int{37}
 }
 
 func (m *IsSquashInProgressResponse) XXX_Unmarshal(b []byte) error {
@@ -1667,7 +1771,7 @@ func (m *CreateRepositoryFromURLRequest) Reset()         { *m = CreateRepository
 func (m *CreateRepositoryFromURLRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromURLRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromURLRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{36}
+	return fileDescriptor_e9b1768cf174c79b, []int{38}
 }
 
 func (m *CreateRepositoryFromURLRequest) XXX_Unmarshal(b []byte) error {
@@ -1712,7 +1816,7 @@ func (m *CreateRepositoryFromURLResponse) Reset()         { *m = CreateRepositor
 func (m *CreateRepositoryFromURLResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromURLResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromURLResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{37}
+	return fileDescriptor_e9b1768cf174c79b, []int{39}
 }
 
 func (m *CreateRepositoryFromURLResponse) XXX_Unmarshal(b []byte) error {
@@ -1744,7 +1848,7 @@ func (m *CreateBundleRequest) Reset()         { *m = CreateBundleRequest{} }
 func (m *CreateBundleRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateBundleRequest) ProtoMessage()    {}
 func (*CreateBundleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{38}
+	return fileDescriptor_e9b1768cf174c79b, []int{40}
 }
 
 func (m *CreateBundleRequest) XXX_Unmarshal(b []byte) error {
@@ -1783,7 +1887,7 @@ func (m *CreateBundleResponse) Reset()         { *m = CreateBundleResponse{} }
 func (m *CreateBundleResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateBundleResponse) ProtoMessage()    {}
 func (*CreateBundleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{39}
+	return fileDescriptor_e9b1768cf174c79b, []int{41}
 }
 
 func (m *CreateBundleResponse) XXX_Unmarshal(b []byte) error {
@@ -1823,7 +1927,7 @@ func (m *SetConfigRequest) Reset()         { *m = SetConfigRequest{} }
 func (m *SetConfigRequest) String() string { return proto.CompactTextString(m) }
 func (*SetConfigRequest) ProtoMessage()    {}
 func (*SetConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{40}
+	return fileDescriptor_e9b1768cf174c79b, []int{42}
 }
 
 func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error {
@@ -1874,7 +1978,7 @@ func (m *SetConfigRequest_Entry) Reset()         { *m = SetConfigRequest_Entry{}
 func (m *SetConfigRequest_Entry) String() string { return proto.CompactTextString(m) }
 func (*SetConfigRequest_Entry) ProtoMessage()    {}
 func (*SetConfigRequest_Entry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{40, 0}
+	return fileDescriptor_e9b1768cf174c79b, []int{42, 0}
 }
 
 func (m *SetConfigRequest_Entry) XXX_Unmarshal(b []byte) error {
@@ -1971,7 +2075,7 @@ func (m *SetConfigResponse) Reset()         { *m = SetConfigResponse{} }
 func (m *SetConfigResponse) String() string { return proto.CompactTextString(m) }
 func (*SetConfigResponse) ProtoMessage()    {}
 func (*SetConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{41}
+	return fileDescriptor_e9b1768cf174c79b, []int{43}
 }
 
 func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error {
@@ -2004,7 +2108,7 @@ func (m *DeleteConfigRequest) Reset()         { *m = DeleteConfigRequest{} }
 func (m *DeleteConfigRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteConfigRequest) ProtoMessage()    {}
 func (*DeleteConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{42}
+	return fileDescriptor_e9b1768cf174c79b, []int{44}
 }
 
 func (m *DeleteConfigRequest) XXX_Unmarshal(b []byte) error {
@@ -2049,7 +2153,7 @@ func (m *DeleteConfigResponse) Reset()         { *m = DeleteConfigResponse{} }
 func (m *DeleteConfigResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteConfigResponse) ProtoMessage()    {}
 func (*DeleteConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{43}
+	return fileDescriptor_e9b1768cf174c79b, []int{45}
 }
 
 func (m *DeleteConfigResponse) XXX_Unmarshal(b []byte) error {
@@ -2082,7 +2186,7 @@ func (m *RestoreCustomHooksRequest) Reset()         { *m = RestoreCustomHooksReq
 func (m *RestoreCustomHooksRequest) String() string { return proto.CompactTextString(m) }
 func (*RestoreCustomHooksRequest) ProtoMessage()    {}
 func (*RestoreCustomHooksRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{44}
+	return fileDescriptor_e9b1768cf174c79b, []int{46}
 }
 
 func (m *RestoreCustomHooksRequest) XXX_Unmarshal(b []byte) error {
@@ -2127,7 +2231,7 @@ func (m *RestoreCustomHooksResponse) Reset()         { *m = RestoreCustomHooksRe
 func (m *RestoreCustomHooksResponse) String() string { return proto.CompactTextString(m) }
 func (*RestoreCustomHooksResponse) ProtoMessage()    {}
 func (*RestoreCustomHooksResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{45}
+	return fileDescriptor_e9b1768cf174c79b, []int{47}
 }
 
 func (m *RestoreCustomHooksResponse) XXX_Unmarshal(b []byte) error {
@@ -2159,7 +2263,7 @@ func (m *BackupCustomHooksRequest) Reset()         { *m = BackupCustomHooksReque
 func (m *BackupCustomHooksRequest) String() string { return proto.CompactTextString(m) }
 func (*BackupCustomHooksRequest) ProtoMessage()    {}
 func (*BackupCustomHooksRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{46}
+	return fileDescriptor_e9b1768cf174c79b, []int{48}
 }
 
 func (m *BackupCustomHooksRequest) XXX_Unmarshal(b []byte) error {
@@ -2198,7 +2302,7 @@ func (m *BackupCustomHooksResponse) Reset()         { *m = BackupCustomHooksResp
 func (m *BackupCustomHooksResponse) String() string { return proto.CompactTextString(m) }
 func (*BackupCustomHooksResponse) ProtoMessage()    {}
 func (*BackupCustomHooksResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{47}
+	return fileDescriptor_e9b1768cf174c79b, []int{49}
 }
 
 func (m *BackupCustomHooksResponse) XXX_Unmarshal(b []byte) error {
@@ -2239,7 +2343,7 @@ func (m *CreateRepositoryFromBundleRequest) Reset()         { *m = CreateReposit
 func (m *CreateRepositoryFromBundleRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromBundleRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromBundleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{48}
+	return fileDescriptor_e9b1768cf174c79b, []int{50}
 }
 
 func (m *CreateRepositoryFromBundleRequest) XXX_Unmarshal(b []byte) error {
@@ -2284,7 +2388,7 @@ func (m *CreateRepositoryFromBundleResponse) Reset()         { *m = CreateReposi
 func (m *CreateRepositoryFromBundleResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromBundleResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromBundleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{49}
+	return fileDescriptor_e9b1768cf174c79b, []int{51}
 }
 
 func (m *CreateRepositoryFromBundleResponse) XXX_Unmarshal(b []byte) error {
@@ -2316,7 +2420,7 @@ func (m *FindLicenseRequest) Reset()         { *m = FindLicenseRequest{} }
 func (m *FindLicenseRequest) String() string { return proto.CompactTextString(m) }
 func (*FindLicenseRequest) ProtoMessage()    {}
 func (*FindLicenseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{50}
+	return fileDescriptor_e9b1768cf174c79b, []int{52}
 }
 
 func (m *FindLicenseRequest) XXX_Unmarshal(b []byte) error {
@@ -2355,7 +2459,7 @@ func (m *FindLicenseResponse) Reset()         { *m = FindLicenseResponse{} }
 func (m *FindLicenseResponse) String() string { return proto.CompactTextString(m) }
 func (*FindLicenseResponse) ProtoMessage()    {}
 func (*FindLicenseResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{51}
+	return fileDescriptor_e9b1768cf174c79b, []int{53}
 }
 
 func (m *FindLicenseResponse) XXX_Unmarshal(b []byte) error {
@@ -2394,7 +2498,7 @@ func (m *GetInfoAttributesRequest) Reset()         { *m = GetInfoAttributesReque
 func (m *GetInfoAttributesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetInfoAttributesRequest) ProtoMessage()    {}
 func (*GetInfoAttributesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{52}
+	return fileDescriptor_e9b1768cf174c79b, []int{54}
 }
 
 func (m *GetInfoAttributesRequest) XXX_Unmarshal(b []byte) error {
@@ -2433,7 +2537,7 @@ func (m *GetInfoAttributesResponse) Reset()         { *m = GetInfoAttributesResp
 func (m *GetInfoAttributesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetInfoAttributesResponse) ProtoMessage()    {}
 func (*GetInfoAttributesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{53}
+	return fileDescriptor_e9b1768cf174c79b, []int{55}
 }
 
 func (m *GetInfoAttributesResponse) XXX_Unmarshal(b []byte) error {
@@ -2472,7 +2576,7 @@ func (m *CalculateChecksumRequest) Reset()         { *m = CalculateChecksumReque
 func (m *CalculateChecksumRequest) String() string { return proto.CompactTextString(m) }
 func (*CalculateChecksumRequest) ProtoMessage()    {}
 func (*CalculateChecksumRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{54}
+	return fileDescriptor_e9b1768cf174c79b, []int{56}
 }
 
 func (m *CalculateChecksumRequest) XXX_Unmarshal(b []byte) error {
@@ -2511,7 +2615,7 @@ func (m *CalculateChecksumResponse) Reset()         { *m = CalculateChecksumResp
 func (m *CalculateChecksumResponse) String() string { return proto.CompactTextString(m) }
 func (*CalculateChecksumResponse) ProtoMessage()    {}
 func (*CalculateChecksumResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{55}
+	return fileDescriptor_e9b1768cf174c79b, []int{57}
 }
 
 func (m *CalculateChecksumResponse) XXX_Unmarshal(b []byte) error {
@@ -2550,7 +2654,7 @@ func (m *GetSnapshotRequest) Reset()         { *m = GetSnapshotRequest{} }
 func (m *GetSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*GetSnapshotRequest) ProtoMessage()    {}
 func (*GetSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{56}
+	return fileDescriptor_e9b1768cf174c79b, []int{58}
 }
 
 func (m *GetSnapshotRequest) XXX_Unmarshal(b []byte) error {
@@ -2589,7 +2693,7 @@ func (m *GetSnapshotResponse) Reset()         { *m = GetSnapshotResponse{} }
 func (m *GetSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*GetSnapshotResponse) ProtoMessage()    {}
 func (*GetSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{57}
+	return fileDescriptor_e9b1768cf174c79b, []int{59}
 }
 
 func (m *GetSnapshotResponse) XXX_Unmarshal(b []byte) error {
@@ -2630,7 +2734,7 @@ func (m *CreateRepositoryFromSnapshotRequest) Reset()         { *m = CreateRepos
 func (m *CreateRepositoryFromSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromSnapshotRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{58}
+	return fileDescriptor_e9b1768cf174c79b, []int{60}
 }
 
 func (m *CreateRepositoryFromSnapshotRequest) XXX_Unmarshal(b []byte) error {
@@ -2682,7 +2786,7 @@ func (m *CreateRepositoryFromSnapshotResponse) Reset()         { *m = CreateRepo
 func (m *CreateRepositoryFromSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromSnapshotResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{59}
+	return fileDescriptor_e9b1768cf174c79b, []int{61}
 }
 
 func (m *CreateRepositoryFromSnapshotResponse) XXX_Unmarshal(b []byte) error {
@@ -2716,7 +2820,7 @@ func (m *GetRawChangesRequest) Reset()         { *m = GetRawChangesRequest{} }
 func (m *GetRawChangesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesRequest) ProtoMessage()    {}
 func (*GetRawChangesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{60}
+	return fileDescriptor_e9b1768cf174c79b, []int{62}
 }
 
 func (m *GetRawChangesRequest) XXX_Unmarshal(b []byte) error {
@@ -2769,7 +2873,7 @@ func (m *GetRawChangesResponse) Reset()         { *m = GetRawChangesResponse{} }
 func (m *GetRawChangesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesResponse) ProtoMessage()    {}
 func (*GetRawChangesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{61}
+	return fileDescriptor_e9b1768cf174c79b, []int{63}
 }
 
 func (m *GetRawChangesResponse) XXX_Unmarshal(b []byte) error {
@@ -2819,7 +2923,7 @@ func (m *GetRawChangesResponse_RawChange) Reset()         { *m = GetRawChangesRe
 func (m *GetRawChangesResponse_RawChange) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesResponse_RawChange) ProtoMessage()    {}
 func (*GetRawChangesResponse_RawChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{61, 0}
+	return fileDescriptor_e9b1768cf174c79b, []int{63, 0}
 }
 
 func (m *GetRawChangesResponse_RawChange) XXX_Unmarshal(b []byte) error {
@@ -2925,7 +3029,7 @@ func (m *SearchFilesByNameRequest) Reset()         { *m = SearchFilesByNameReque
 func (m *SearchFilesByNameRequest) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByNameRequest) ProtoMessage()    {}
 func (*SearchFilesByNameRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{62}
+	return fileDescriptor_e9b1768cf174c79b, []int{64}
 }
 
 func (m *SearchFilesByNameRequest) XXX_Unmarshal(b []byte) error {
@@ -2978,7 +3082,7 @@ func (m *SearchFilesByNameResponse) Reset()         { *m = SearchFilesByNameResp
 func (m *SearchFilesByNameResponse) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByNameResponse) ProtoMessage()    {}
 func (*SearchFilesByNameResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{63}
+	return fileDescriptor_e9b1768cf174c79b, []int{65}
 }
 
 func (m *SearchFilesByNameResponse) XXX_Unmarshal(b []byte) error {
@@ -3020,7 +3124,7 @@ func (m *SearchFilesByContentRequest) Reset()         { *m = SearchFilesByConten
 func (m *SearchFilesByContentRequest) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByContentRequest) ProtoMessage()    {}
 func (*SearchFilesByContentRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{64}
+	return fileDescriptor_e9b1768cf174c79b, []int{66}
 }
 
 func (m *SearchFilesByContentRequest) XXX_Unmarshal(b []byte) error {
@@ -3082,7 +3186,7 @@ func (m *SearchFilesByContentResponse) Reset()         { *m = SearchFilesByConte
 func (m *SearchFilesByContentResponse) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByContentResponse) ProtoMessage()    {}
 func (*SearchFilesByContentResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{65}
+	return fileDescriptor_e9b1768cf174c79b, []int{67}
 }
 
 func (m *SearchFilesByContentResponse) XXX_Unmarshal(b []byte) error {
@@ -3138,7 +3242,7 @@ func (m *Remote) Reset()         { *m = Remote{} }
 func (m *Remote) String() string { return proto.CompactTextString(m) }
 func (*Remote) ProtoMessage()    {}
 func (*Remote) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{66}
+	return fileDescriptor_e9b1768cf174c79b, []int{68}
 }
 
 func (m *Remote) XXX_Unmarshal(b []byte) error {
@@ -3200,7 +3304,7 @@ func (m *FetchHTTPRemoteRequest) Reset()         { *m = FetchHTTPRemoteRequest{}
 func (m *FetchHTTPRemoteRequest) String() string { return proto.CompactTextString(m) }
 func (*FetchHTTPRemoteRequest) ProtoMessage()    {}
 func (*FetchHTTPRemoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{67}
+	return fileDescriptor_e9b1768cf174c79b, []int{69}
 }
 
 func (m *FetchHTTPRemoteRequest) XXX_Unmarshal(b []byte) error {
@@ -3252,7 +3356,7 @@ func (m *FetchHTTPRemoteResponse) Reset()         { *m = FetchHTTPRemoteResponse
 func (m *FetchHTTPRemoteResponse) String() string { return proto.CompactTextString(m) }
 func (*FetchHTTPRemoteResponse) ProtoMessage()    {}
 func (*FetchHTTPRemoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{68}
+	return fileDescriptor_e9b1768cf174c79b, []int{70}
 }
 
 func (m *FetchHTTPRemoteResponse) XXX_Unmarshal(b []byte) error {
@@ -3284,7 +3388,7 @@ func (m *GetObjectDirectorySizeRequest) Reset()         { *m = GetObjectDirector
 func (m *GetObjectDirectorySizeRequest) String() string { return proto.CompactTextString(m) }
 func (*GetObjectDirectorySizeRequest) ProtoMessage()    {}
 func (*GetObjectDirectorySizeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{69}
+	return fileDescriptor_e9b1768cf174c79b, []int{71}
 }
 
 func (m *GetObjectDirectorySizeRequest) XXX_Unmarshal(b []byte) error {
@@ -3324,7 +3428,7 @@ func (m *GetObjectDirectorySizeResponse) Reset()         { *m = GetObjectDirecto
 func (m *GetObjectDirectorySizeResponse) String() string { return proto.CompactTextString(m) }
 func (*GetObjectDirectorySizeResponse) ProtoMessage()    {}
 func (*GetObjectDirectorySizeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{70}
+	return fileDescriptor_e9b1768cf174c79b, []int{72}
 }
 
 func (m *GetObjectDirectorySizeResponse) XXX_Unmarshal(b []byte) error {
@@ -3365,7 +3469,7 @@ func (m *CloneFromPoolRequest) Reset()         { *m = CloneFromPoolRequest{} }
 func (m *CloneFromPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolRequest) ProtoMessage()    {}
 func (*CloneFromPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{71}
+	return fileDescriptor_e9b1768cf174c79b, []int{73}
 }
 
 func (m *CloneFromPoolRequest) XXX_Unmarshal(b []byte) error {
@@ -3417,7 +3521,7 @@ func (m *CloneFromPoolResponse) Reset()         { *m = CloneFromPoolResponse{} }
 func (m *CloneFromPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolResponse) ProtoMessage()    {}
 func (*CloneFromPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{72}
+	return fileDescriptor_e9b1768cf174c79b, []int{74}
 }
 
 func (m *CloneFromPoolResponse) XXX_Unmarshal(b []byte) error {
@@ -3451,7 +3555,7 @@ func (m *CloneFromPoolInternalRequest) Reset()         { *m = CloneFromPoolInter
 func (m *CloneFromPoolInternalRequest) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolInternalRequest) ProtoMessage()    {}
 func (*CloneFromPoolInternalRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{73}
+	return fileDescriptor_e9b1768cf174c79b, []int{75}
 }
 
 func (m *CloneFromPoolInternalRequest) XXX_Unmarshal(b []byte) error {
@@ -3503,7 +3607,7 @@ func (m *CloneFromPoolInternalResponse) Reset()         { *m = CloneFromPoolInte
 func (m *CloneFromPoolInternalResponse) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolInternalResponse) ProtoMessage()    {}
 func (*CloneFromPoolInternalResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{74}
+	return fileDescriptor_e9b1768cf174c79b, []int{76}
 }
 
 func (m *CloneFromPoolInternalResponse) XXX_Unmarshal(b []byte) error {
@@ -3535,7 +3639,7 @@ func (m *RemoveRepositoryRequest) Reset()         { *m = RemoveRepositoryRequest
 func (m *RemoveRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*RemoveRepositoryRequest) ProtoMessage()    {}
 func (*RemoveRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{75}
+	return fileDescriptor_e9b1768cf174c79b, []int{77}
 }
 
 func (m *RemoveRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3573,7 +3677,7 @@ func (m *RemoveRepositoryResponse) Reset()         { *m = RemoveRepositoryRespon
 func (m *RemoveRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*RemoveRepositoryResponse) ProtoMessage()    {}
 func (*RemoveRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{76}
+	return fileDescriptor_e9b1768cf174c79b, []int{78}
 }
 
 func (m *RemoveRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3606,7 +3710,7 @@ func (m *RenameRepositoryRequest) Reset()         { *m = RenameRepositoryRequest
 func (m *RenameRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*RenameRepositoryRequest) ProtoMessage()    {}
 func (*RenameRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{77}
+	return fileDescriptor_e9b1768cf174c79b, []int{79}
 }
 
 func (m *RenameRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3651,7 +3755,7 @@ func (m *RenameRepositoryResponse) Reset()         { *m = RenameRepositoryRespon
 func (m *RenameRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*RenameRepositoryResponse) ProtoMessage()    {}
 func (*RenameRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{78}
+	return fileDescriptor_e9b1768cf174c79b, []int{80}
 }
 
 func (m *RenameRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3684,7 +3788,7 @@ func (m *ReplicateRepositoryRequest) Reset()         { *m = ReplicateRepositoryR
 func (m *ReplicateRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*ReplicateRepositoryRequest) ProtoMessage()    {}
 func (*ReplicateRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{79}
+	return fileDescriptor_e9b1768cf174c79b, []int{81}
 }
 
 func (m *ReplicateRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3729,7 +3833,7 @@ func (m *ReplicateRepositoryResponse) Reset()         { *m = ReplicateRepository
 func (m *ReplicateRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*ReplicateRepositoryResponse) ProtoMessage()    {}
 func (*ReplicateRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{80}
+	return fileDescriptor_e9b1768cf174c79b, []int{82}
 }
 
 func (m *ReplicateRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3781,6 +3885,8 @@ func init() {
 	proto.RegisterType((*FsckResponse)(nil), "gitaly.FsckResponse")
 	proto.RegisterType((*WriteRefRequest)(nil), "gitaly.WriteRefRequest")
 	proto.RegisterType((*WriteRefResponse)(nil), "gitaly.WriteRefResponse")
+	proto.RegisterType((*WriteRefTxRequest)(nil), "gitaly.WriteRefTxRequest")
+	proto.RegisterType((*WriteRefTxResponse)(nil), "gitaly.WriteRefTxResponse")
 	proto.RegisterType((*FindMergeBaseRequest)(nil), "gitaly.FindMergeBaseRequest")
 	proto.RegisterType((*FindMergeBaseResponse)(nil), "gitaly.FindMergeBaseResponse")
 	proto.RegisterType((*CreateForkRequest)(nil), "gitaly.CreateForkRequest")
@@ -3841,192 +3947,195 @@ func init() {
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor_e9b1768cf174c79b) }
 
 var fileDescriptor_e9b1768cf174c79b = []byte{
-	// 2949 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdd, 0x6f, 0x1b, 0xc7,
-	0x11, 0x37, 0xa9, 0x0f, 0x92, 0x43, 0xda, 0xa6, 0x56, 0xb2, 0x45, 0x9d, 0x2d, 0xcb, 0x3e, 0x3b,
-	0x8e, 0x93, 0x38, 0xb2, 0x63, 0xb7, 0x68, 0xda, 0xa2, 0x28, 0x44, 0x7d, 0xc7, 0xb6, 0xa4, 0x9c,
-	0x94, 0x06, 0x31, 0x10, 0x5c, 0x8e, 0xc7, 0xa5, 0x78, 0xd5, 0xf1, 0x96, 0xde, 0x5b, 0x5a, 0x51,
-	0xd0, 0x3e, 0xb4, 0x40, 0x5e, 0x03, 0x14, 0x28, 0x9a, 0x3e, 0xf6, 0xa9, 0x0f, 0xfd, 0x1f, 0x8a,
-	0xa2, 0x2f, 0xfd, 0x1f, 0xf2, 0x57, 0xf4, 0xbd, 0x4f, 0xc5, 0x7e, 0xdc, 0xf7, 0x1d, 0xe3, 0x82,
-	0x44, 0xfa, 0x76, 0x3b, 0x3b, 0x3b, 0x33, 0x3b, 0x3b, 0xfb, 0x31, 0xbf, 0x39, 0x68, 0x51, 0x3c,
-	0x24, 0xbe, 0xc3, 0x08, 0xbd, 0x78, 0xdf, 0xc7, 0xf4, 0xb5, 0x63, 0xe3, 0xf5, 0x21, 0x25, 0x8c,
-	0xa0, 0xf9, 0x53, 0x87, 0x59, 0xee, 0x85, 0xd6, 0xf0, 0xfb, 0x16, 0xc5, 0x5d, 0x49, 0xd5, 0x8f,
-	0x61, 0xd9, 0x08, 0x47, 0x6c, 0x7f, 0xe9, 0xf8, 0xcc, 0x37, 0xf0, 0xab, 0x11, 0xf6, 0x19, 0xfa,
-	0x10, 0x20, 0x12, 0xd6, 0x2a, 0xdd, 0x2e, 0x3d, 0xa8, 0x3f, 0x41, 0xeb, 0x52, 0xca, 0x7a, 0x34,
-	0xa8, 0x3d, 0xfb, 0xe7, 0x7f, 0x3d, 0x2c, 0x19, 0x31, 0x5e, 0xfd, 0x09, 0xb4, 0xb2, 0x42, 0xfd,
-	0x21, 0xf1, 0x7c, 0x8c, 0xae, 0xc3, 0x3c, 0x16, 0x14, 0x21, 0xb1, 0x6a, 0xa8, 0x96, 0x7e, 0x22,
-	0xc6, 0x58, 0xf6, 0xd9, 0xbe, 0x67, 0x53, 0x3c, 0xc0, 0x1e, 0xb3, 0xdc, 0xc9, 0x2d, 0xb9, 0x01,
-	0x2b, 0x39, 0x52, 0xa5, 0x29, 0x3a, 0x85, 0x05, 0xd9, 0xb9, 0x33, 0x72, 0x27, 0xd7, 0x85, 0xee,
-	0xc2, 0x65, 0x9b, 0x62, 0x8b, 0x61, 0xb3, 0xe3, 0xb0, 0x81, 0x35, 0x6c, 0x95, 0xc5, 0x04, 0x1b,
-	0x92, 0xd8, 0x16, 0x34, 0x7d, 0x09, 0x50, 0x5c, 0xa7, 0xb2, 0xe4, 0x35, 0x5c, 0xdb, 0xb5, 0x68,
-	0xc7, 0x3a, 0xc5, 0x9b, 0xc4, 0x75, 0xb1, 0xcd, 0x7e, 0x20, 0x6b, 0x5a, 0x70, 0x3d, 0xad, 0x57,
-	0x59, 0xf4, 0x11, 0x5c, 0xd9, 0x74, 0xb1, 0xe5, 0x8d, 0x86, 0x93, 0x2f, 0xc2, 0x02, 0x5c, 0x0d,
-	0x65, 0x29, 0xf1, 0x1f, 0xc3, 0xb5, 0x68, 0xc8, 0xb1, 0xf3, 0x15, 0x9e, 0x5c, 0xcb, 0x43, 0xb8,
-	0x9e, 0x16, 0xa9, 0x42, 0x0e, 0xc1, 0xac, 0xef, 0x7c, 0x85, 0x85, 0xb4, 0x19, 0x43, 0x7c, 0xeb,
-	0xaf, 0x60, 0x65, 0x63, 0x38, 0x74, 0x2f, 0x76, 0x1d, 0x66, 0x31, 0x46, 0x9d, 0xce, 0x88, 0xe1,
-	0xc9, 0x23, 0x1f, 0x69, 0x50, 0xa5, 0xf8, 0xb5, 0xe3, 0x3b, 0xc4, 0x13, 0x0e, 0x6f, 0x18, 0x61,
-	0x5b, 0xbf, 0x09, 0x5a, 0x9e, 0x4a, 0xe5, 0x91, 0x7f, 0x94, 0x01, 0xed, 0x60, 0x66, 0xf7, 0x0d,
-	0x3c, 0x20, 0x6c, 0x72, 0x7f, 0xf0, 0x8d, 0x46, 0x85, 0x28, 0x61, 0x48, 0xcd, 0x50, 0x2d, 0xb4,
-	0x04, 0x73, 0x3d, 0x42, 0x6d, 0xdc, 0x9a, 0x11, 0x01, 0x21, 0x1b, 0x68, 0x19, 0x2a, 0x1e, 0x31,
-	0x99, 0x75, 0xea, 0xb7, 0x66, 0xe5, 0xbe, 0xf4, 0xc8, 0x89, 0x75, 0xea, 0xa3, 0x16, 0x54, 0x98,
-	0x33, 0xc0, 0x64, 0xc4, 0x5a, 0x73, 0xb7, 0x4b, 0x0f, 0xe6, 0x8c, 0xa0, 0xc9, 0x87, 0xf8, 0x7e,
-	0xdf, 0x3c, 0xc3, 0x17, 0xad, 0x79, 0xa9, 0xc1, 0xf7, 0xfb, 0xcf, 0xf0, 0x05, 0x5a, 0x83, 0xfa,
-	0x99, 0x47, 0xce, 0x3d, 0xb3, 0x4f, 0xf8, 0x3e, 0xaf, 0x88, 0x4e, 0x10, 0xa4, 0x3d, 0x4e, 0x41,
-	0x2b, 0x50, 0xf5, 0x88, 0x39, 0xa4, 0x23, 0x0f, 0xb7, 0x6a, 0x42, 0x5b, 0xc5, 0x23, 0x47, 0xbc,
-	0x89, 0x9e, 0xc2, 0x65, 0x69, 0xa7, 0x39, 0xb4, 0xa8, 0x35, 0xf0, 0x5b, 0x20, 0xa6, 0x7c, 0x25,
-	0x9a, 0xb2, 0xf0, 0x4e, 0x43, 0x32, 0x1d, 0x09, 0x9e, 0x8f, 0x66, 0xab, 0xd5, 0x66, 0x4d, 0xbf,
-	0x06, 0x8b, 0x09, 0x07, 0x2a, 0xc7, 0x1e, 0xc3, 0xf2, 0xa6, 0x88, 0xf9, 0xc8, 0x5b, 0x93, 0x07,
-	0x9b, 0x06, 0xad, 0xac, 0x50, 0xa5, 0xf0, 0xeb, 0x32, 0x2c, 0xec, 0x62, 0xb6, 0x41, 0xed, 0xbe,
-	0xf3, 0x7a, 0x0a, 0x0b, 0x79, 0x03, 0x6a, 0x36, 0x19, 0x0c, 0x1c, 0x66, 0x3a, 0x5d, 0xb5, 0x96,
-	0x55, 0x49, 0xd8, 0xef, 0xf2, 0x55, 0x1e, 0x52, 0xdc, 0x73, 0xbe, 0x14, 0xcb, 0x59, 0x33, 0x54,
-	0x0b, 0x7d, 0x08, 0xf3, 0x3d, 0x42, 0x07, 0x16, 0x13, 0xcb, 0x79, 0xe5, 0xc9, 0xed, 0x40, 0x55,
-	0xc6, 0xb2, 0xf5, 0x1d, 0xc1, 0x67, 0x28, 0x7e, 0xbe, 0x5b, 0x86, 0x16, 0xeb, 0x8b, 0xd5, 0x6e,
-	0x18, 0xe2, 0x5b, 0x7f, 0x0a, 0xf3, 0x92, 0x0b, 0x55, 0x60, 0xe6, 0xe5, 0xfe, 0x51, 0xf3, 0x12,
-	0xff, 0x38, 0xd9, 0x30, 0x9a, 0x25, 0x04, 0x30, 0x7f, 0xb2, 0x61, 0x98, 0xbb, 0x2f, 0x9b, 0x65,
-	0x54, 0x87, 0x0a, 0xff, 0x6e, 0xbf, 0x7c, 0xd2, 0x9c, 0xd1, 0x1f, 0x00, 0x8a, 0x2b, 0x8b, 0x36,
-	0x63, 0xd7, 0x62, 0x96, 0xf0, 0x40, 0xc3, 0x10, 0xdf, 0x7c, 0x89, 0xf6, 0x2c, 0xff, 0x39, 0xb1,
-	0x2d, 0xb7, 0x4d, 0x2d, 0xcf, 0xee, 0x4f, 0x61, 0x2b, 0xea, 0x8f, 0xa1, 0x95, 0x15, 0xaa, 0x8c,
-	0x58, 0x82, 0xb9, 0xd7, 0x96, 0x3b, 0xc2, 0xea, 0x0e, 0x92, 0x0d, 0xfd, 0xbb, 0x12, 0xb4, 0x44,
-	0x04, 0x1d, 0x93, 0x11, 0xb5, 0xb1, 0x1c, 0x35, 0xf9, 0xfa, 0xfd, 0x12, 0x16, 0x7c, 0x21, 0xd0,
-	0x8c, 0x09, 0x28, 0x17, 0x09, 0x30, 0x9a, 0x92, 0xd9, 0x48, 0x1c, 0xe5, 0x4a, 0x40, 0x47, 0x98,
-	0x24, 0x96, 0xba, 0x61, 0x34, 0xfc, 0x98, 0x99, 0x68, 0x15, 0x80, 0x59, 0xf4, 0x14, 0x33, 0x93,
-	0xe2, 0x9e, 0x58, 0xf4, 0x86, 0x51, 0x93, 0x14, 0x03, 0xf7, 0xf4, 0xa7, 0xb0, 0x92, 0x33, 0xb5,
-	0xe8, 0x4e, 0xa6, 0xd8, 0x1f, 0xb9, 0x2c, 0xb8, 0x93, 0x65, 0x4b, 0xdf, 0x85, 0xfa, 0x8e, 0x6f,
-	0x9f, 0x4d, 0xbe, 0x16, 0xf7, 0xa0, 0x21, 0x05, 0x45, 0xfe, 0xc7, 0x94, 0x12, 0xaa, 0xa2, 0x40,
-	0x36, 0xf4, 0x7f, 0x97, 0xe0, 0xea, 0xa7, 0xd4, 0xe1, 0x9b, 0xaa, 0x37, 0xb9, 0xdb, 0x9b, 0x30,
-	0xc3, 0x3d, 0x21, 0x4f, 0x61, 0xfe, 0x99, 0x38, 0x9c, 0x67, 0x92, 0x87, 0x33, 0xba, 0x03, 0x0d,
-	0xe2, 0x76, 0xcd, 0xb0, 0x5f, 0x3a, 0xb0, 0x4e, 0xdc, 0xae, 0x11, 0xb0, 0x84, 0x07, 0xe7, 0x5c,
-	0xfc, 0xe0, 0xfc, 0x31, 0xd4, 0x19, 0xb5, 0x3c, 0xdf, 0xb2, 0x19, 0x1f, 0x57, 0x11, 0x16, 0x2e,
-	0x06, 0x16, 0x9e, 0x44, 0x5d, 0x46, 0x9c, 0xef, 0xa3, 0xd9, 0xea, 0x7c, 0xb3, 0xa2, 0x1f, 0x42,
-	0x33, 0x9a, 0xb0, 0xf2, 0x4d, 0x4a, 0x60, 0xf9, 0x8d, 0x05, 0x96, 0x9a, 0x65, 0xdd, 0x83, 0xa5,
-	0x1d, 0xc7, 0xeb, 0xbe, 0xc0, 0xf4, 0x14, 0xb7, 0x2d, 0x7f, 0x0a, 0xa7, 0xcf, 0x4d, 0xa8, 0x05,
-	0x4e, 0xf1, 0x5b, 0xe5, 0xdb, 0x33, 0x3c, 0xac, 0x42, 0x82, 0xfe, 0x1e, 0x5c, 0x4b, 0xe9, 0x8b,
-	0xb6, 0x79, 0xc7, 0xf2, 0xe5, 0x06, 0xab, 0x19, 0xe2, 0x5b, 0xff, 0xa6, 0x04, 0x0b, 0xf2, 0xd4,
-	0xdc, 0x21, 0xf4, 0xec, 0xff, 0xbf, 0xb1, 0xf8, 0x63, 0x2c, 0x6e, 0x4f, 0xf8, 0x2c, 0x5c, 0xd9,
-	0xf7, 0x0d, 0xcc, 0x4d, 0xde, 0xf7, 0x8e, 0x28, 0x39, 0xa5, 0xd8, 0xf7, 0xa7, 0x72, 0x8c, 0x53,
-	0x21, 0x34, 0x76, 0x8c, 0x4b, 0xc2, 0x7e, 0x57, 0xff, 0x05, 0x68, 0x79, 0x3a, 0x95, 0x33, 0xd7,
-	0xa0, 0xee, 0x78, 0xe6, 0x50, 0x91, 0xd5, 0x26, 0x05, 0x27, 0x64, 0x94, 0x26, 0x1f, 0xbf, 0x1a,
-	0x59, 0x7e, 0x7f, 0xca, 0x26, 0xfb, 0x42, 0x68, 0xcc, 0x64, 0x49, 0x08, 0x4c, 0xce, 0xea, 0x7c,
-	0x53, 0x93, 0x5d, 0xb8, 0x95, 0xbe, 0x41, 0x77, 0x28, 0x19, 0x7c, 0x62, 0x3c, 0x9f, 0xca, 0xd6,
-	0x1f, 0x51, 0x57, 0x59, 0xcc, 0x3f, 0xf5, 0x3b, 0xb0, 0x56, 0xa8, 0x4d, 0x2d, 0xfb, 0x21, 0x2c,
-	0x4a, 0x96, 0xf6, 0xc8, 0xeb, 0xba, 0x53, 0x78, 0x90, 0xbe, 0x0b, 0x4b, 0x49, 0x81, 0x63, 0x6e,
-	0xc0, 0x6f, 0xca, 0xd0, 0x3c, 0xc6, 0x6c, 0x93, 0x78, 0x3d, 0xe7, 0x74, 0x72, 0x07, 0x7c, 0x08,
-	0x15, 0xec, 0x31, 0xea, 0x60, 0xb9, 0x65, 0xeb, 0x4f, 0x6e, 0x05, 0xc3, 0xd2, 0x4a, 0xd6, 0xb7,
-	0x3d, 0x46, 0x2f, 0x8c, 0x80, 0x5d, 0xfb, 0xba, 0x04, 0x73, 0x82, 0xc4, 0x9d, 0xc8, 0x9f, 0x76,
-	0x72, 0x03, 0xf3, 0x4f, 0xb4, 0x0a, 0x35, 0x71, 0x51, 0x9a, 0x3e, 0xa3, 0xd2, 0xb9, 0x7b, 0x97,
-	0x8c, 0xaa, 0x20, 0x1d, 0x33, 0x8a, 0xee, 0x40, 0x5d, 0x76, 0x3b, 0x1e, 0x7b, 0xfa, 0x44, 0x9c,
-	0xb0, 0x73, 0x7b, 0x97, 0x0c, 0x10, 0xc4, 0x7d, 0x4e, 0x43, 0x6b, 0x20, 0x5b, 0x66, 0x87, 0x10,
-	0x57, 0x3e, 0x34, 0xf7, 0x2e, 0x19, 0x52, 0x6a, 0x9b, 0x10, 0xb7, 0x5d, 0x51, 0x17, 0xb3, 0xbe,
-	0x08, 0x0b, 0x31, 0x53, 0xd5, 0x12, 0xd9, 0xb0, 0xb8, 0x85, 0x5d, 0xcc, 0xf0, 0xb4, 0xfc, 0x84,
-	0x60, 0xf6, 0x0c, 0x5f, 0x48, 0x27, 0xd5, 0x0c, 0xf1, 0xad, 0x5f, 0x87, 0xa5, 0xa4, 0x12, 0xa5,
-	0xdc, 0xe1, 0xa9, 0xa4, 0xcf, 0x08, 0xc5, 0x9b, 0x23, 0x9f, 0x91, 0xc1, 0x1e, 0x21, 0x67, 0xfe,
-	0x54, 0x4c, 0x10, 0xd1, 0x50, 0x8e, 0x45, 0xc3, 0x4d, 0xd0, 0xf2, 0x54, 0x29, 0x43, 0x4e, 0xa0,
-	0xd5, 0xb6, 0xec, 0xb3, 0xd1, 0x70, 0x9a, 0x76, 0xe8, 0x8f, 0x60, 0x25, 0x47, 0xea, 0x98, 0x90,
-	0x7d, 0x05, 0x77, 0xf2, 0xb6, 0xd4, 0x94, 0x76, 0x4f, 0xae, 0x5f, 0xee, 0x81, 0x3e, 0x4e, 0xa5,
-	0xf2, 0xcf, 0x01, 0x20, 0x7e, 0x27, 0x3d, 0x77, 0x6c, 0xec, 0x4d, 0xe1, 0x06, 0xd4, 0x37, 0x61,
-	0x31, 0x21, 0x4f, 0xf9, 0xe4, 0x21, 0x20, 0x57, 0x92, 0x4c, 0xbf, 0x4f, 0x28, 0x33, 0x3d, 0x6b,
-	0x10, 0xdc, 0x77, 0x4d, 0xd5, 0x73, 0xcc, 0x3b, 0x0e, 0xac, 0x81, 0x58, 0xb4, 0x5d, 0xcc, 0xf6,
-	0xbd, 0x1e, 0xd9, 0x98, 0x5e, 0xba, 0xa9, 0xff, 0x1c, 0x56, 0x72, 0xa4, 0x2a, 0x03, 0x6f, 0x01,
-	0x44, 0x79, 0xa6, 0x5a, 0xba, 0x18, 0x85, 0x9b, 0xb4, 0x69, 0xb9, 0xf6, 0xc8, 0xb5, 0x18, 0xde,
-	0xec, 0x63, 0xfb, 0xcc, 0x1f, 0x0d, 0x26, 0x37, 0xe9, 0x27, 0xb0, 0x92, 0x23, 0x55, 0x99, 0xa4,
-	0x41, 0xd5, 0x56, 0x34, 0xe5, 0xa9, 0xb0, 0xcd, 0x97, 0x6d, 0x17, 0xb3, 0x63, 0xcf, 0x1a, 0xfa,
-	0x7d, 0x32, 0x39, 0x00, 0xa2, 0xbf, 0x03, 0x8b, 0x09, 0x79, 0x63, 0x42, 0xf9, 0xdb, 0x12, 0xdc,
-	0xcd, 0x0b, 0xac, 0xa9, 0x19, 0xc3, 0x33, 0xde, 0x3e, 0x63, 0x43, 0x33, 0xba, 0x96, 0x2a, 0xbc,
-	0xfd, 0x09, 0x75, 0xf9, 0x25, 0x2b, 0xba, 0xac, 0x11, 0xeb, 0xab, 0x24, 0x4e, 0xf0, 0x6e, 0x8c,
-	0x58, 0x5f, 0xbf, 0x0f, 0xf7, 0xc6, 0x1b, 0xa6, 0x62, 0xfe, 0x4f, 0x25, 0x58, 0xda, 0xc5, 0xcc,
-	0xb0, 0xce, 0x37, 0xfb, 0x96, 0x77, 0x3a, 0x0d, 0x28, 0xe3, 0x2e, 0x5c, 0xee, 0x51, 0x32, 0x30,
-	0x13, 0x78, 0x46, 0xcd, 0x68, 0x70, 0x62, 0xf8, 0x26, 0x5e, 0x83, 0x3a, 0x23, 0x66, 0xe2, 0x55,
-	0x5d, 0x33, 0x80, 0x91, 0x80, 0x41, 0xff, 0xfb, 0x2c, 0x5c, 0x4b, 0x19, 0xa6, 0x16, 0x62, 0x0f,
-	0xea, 0xd4, 0x3a, 0x37, 0x6d, 0x49, 0x6e, 0x95, 0xc4, 0x3d, 0xf5, 0x76, 0x2c, 0x4d, 0xcd, 0x8e,
-	0x59, 0x0f, 0x49, 0x06, 0xd0, 0xb0, 0x57, 0xfb, 0x6e, 0x06, 0x6a, 0x61, 0x0f, 0x5a, 0x86, 0x4a,
-	0xc7, 0x25, 0x1d, 0xfe, 0x64, 0x91, 0x21, 0x36, 0xcf, 0x9b, 0xfb, 0xdd, 0x10, 0x06, 0x2a, 0x47,
-	0x30, 0x10, 0x5a, 0x85, 0xaa, 0x87, 0xcf, 0x4d, 0x91, 0xf0, 0x0a, 0xe3, 0xdb, 0xe5, 0x56, 0xc9,
-	0xa8, 0x78, 0xf8, 0xfc, 0xc8, 0x62, 0x3c, 0xa9, 0xaa, 0xf2, 0xac, 0x40, 0x74, 0xcf, 0x46, 0xdd,
-	0xc4, 0xed, 0x8a, 0xee, 0x43, 0xa8, 0x91, 0x21, 0xa6, 0x96, 0x78, 0xa8, 0xcf, 0x89, 0x3c, 0xfb,
-	0x83, 0x37, 0x9c, 0xc0, 0xfa, 0x61, 0x30, 0xd0, 0x88, 0x64, 0x70, 0x9f, 0x73, 0x9f, 0x44, 0x42,
-	0x25, 0xb0, 0xd2, 0xa0, 0xd6, 0x79, 0xc8, 0xcf, 0x63, 0x89, 0x1b, 0x35, 0x20, 0x5d, 0x2c, 0xd2,
-	0x8d, 0x39, 0x61, 0xd0, 0x0b, 0xd2, 0xc5, 0x02, 0x58, 0xc1, 0xe7, 0xb2, 0xab, 0x2a, 0xbb, 0x3c,
-	0x7c, 0x2e, 0xba, 0xee, 0xc1, 0x95, 0x60, 0xa6, 0x66, 0xe7, 0x82, 0x9f, 0x08, 0x35, 0x99, 0x45,
-	0xaa, 0xb9, 0xb6, 0x39, 0x8d, 0x73, 0x05, 0x13, 0x56, 0x5c, 0x20, 0xb9, 0xd4, 0x94, 0x05, 0x97,
-	0xee, 0x40, 0x2d, 0x32, 0xa7, 0x0e, 0x95, 0x4f, 0x0e, 0x9e, 0x1d, 0x1c, 0x7e, 0x7a, 0xd0, 0xbc,
-	0x84, 0x6a, 0x30, 0xb7, 0xb1, 0xb5, 0xb5, 0xbd, 0x25, 0x71, 0x81, 0xcd, 0xc3, 0xa3, 0xfd, 0xed,
-	0x2d, 0x89, 0x0b, 0x6c, 0x6d, 0x3f, 0xdf, 0x3e, 0xd9, 0xde, 0x6a, 0xce, 0xa0, 0x06, 0x54, 0x5f,
-	0x1c, 0x6e, 0xed, 0xef, 0xf0, 0xae, 0x59, 0xde, 0x65, 0x6c, 0x1f, 0x6c, 0xbc, 0xd8, 0xde, 0x6a,
-	0xce, 0xa1, 0x26, 0x34, 0x4e, 0x3e, 0x3b, 0xda, 0x36, 0x37, 0xf7, 0x36, 0x0e, 0x76, 0xb7, 0xb7,
-	0x9a, 0xf3, 0xfa, 0x6f, 0xa0, 0x75, 0x8c, 0x2d, 0x6a, 0xf7, 0x77, 0x1c, 0x17, 0xfb, 0xed, 0x0b,
-	0x7e, 0x98, 0x4e, 0x1e, 0xdb, 0x4b, 0x30, 0xf7, 0x6a, 0x84, 0x55, 0xb6, 0x50, 0x33, 0x64, 0x23,
-	0xc8, 0x18, 0x67, 0xc2, 0x8c, 0x51, 0xff, 0x00, 0x56, 0x72, 0xb4, 0x47, 0x49, 0x6c, 0x8f, 0x93,
-	0x45, 0xe8, 0x36, 0x0c, 0xd9, 0xd0, 0xff, 0x56, 0x82, 0x1b, 0x89, 0x31, 0x9b, 0xc4, 0x63, 0xd8,
-	0x63, 0x3f, 0x98, 0xd1, 0xe8, 0x1d, 0x68, 0xda, 0xfd, 0x91, 0x77, 0x86, 0x79, 0x3a, 0x2b, 0x6d,
-	0x55, 0x98, 0xde, 0x55, 0x45, 0x0f, 0x8f, 0x8d, 0x0b, 0xb8, 0x99, 0x6f, 0xab, 0x9a, 0x62, 0x0b,
-	0x2a, 0x03, 0x8b, 0xd9, 0xfd, 0x70, 0x92, 0x41, 0x13, 0xad, 0x02, 0x88, 0x4f, 0x33, 0x76, 0x49,
-	0xd7, 0x04, 0x65, 0xcb, 0x62, 0x16, 0xba, 0x0d, 0x0d, 0xec, 0x75, 0x4d, 0xd2, 0x33, 0x05, 0x4d,
-	0x61, 0x8d, 0x80, 0xbd, 0xee, 0x61, 0xef, 0x05, 0xa7, 0xe8, 0x7f, 0x28, 0xc1, 0xbc, 0x44, 0xea,
-	0x82, 0xe7, 0x7a, 0x29, 0x7c, 0xae, 0xf3, 0xad, 0x2a, 0x6e, 0x53, 0x39, 0x53, 0xf1, 0x8d, 0x7e,
-	0x06, 0x2b, 0xe1, 0x39, 0x49, 0xa8, 0xf3, 0x95, 0x88, 0x3e, 0xb3, 0x8f, 0xad, 0x2e, 0xa6, 0xea,
-	0xe0, 0x59, 0x0e, 0xce, 0xcd, 0xb0, 0x7f, 0x4f, 0x74, 0xa3, 0xb7, 0xe0, 0xca, 0xc0, 0xa1, 0x94,
-	0x50, 0x93, 0xe2, 0xde, 0xc0, 0x1a, 0xfa, 0xad, 0x59, 0xf1, 0xe2, 0xbb, 0x2c, 0xa9, 0x86, 0x24,
-	0xea, 0x7f, 0x2c, 0xc1, 0x75, 0x81, 0x92, 0xec, 0x9d, 0x9c, 0x1c, 0x4d, 0x0b, 0x87, 0xbd, 0x9f,
-	0xc0, 0x61, 0xb3, 0x50, 0x66, 0x80, 0xcb, 0xc6, 0x80, 0xd6, 0x99, 0x04, 0xd0, 0xaa, 0xaf, 0xc0,
-	0x72, 0xc6, 0x2a, 0xb5, 0x80, 0x9f, 0xc1, 0xea, 0x2e, 0x66, 0x87, 0x9d, 0x5f, 0x63, 0x9b, 0x6d,
-	0x39, 0x14, 0xdb, 0xd3, 0xc3, 0xd3, 0x7f, 0x04, 0xb7, 0x8a, 0x44, 0x8f, 0xc1, 0xd5, 0xff, 0x52,
-	0x82, 0xa5, 0x4d, 0x97, 0x78, 0x98, 0x5f, 0x53, 0x47, 0x84, 0xb8, 0xd3, 0x70, 0xe0, 0xec, 0x90,
-	0xa7, 0x0b, 0xa9, 0xcc, 0x5e, 0x5a, 0x26, 0x54, 0x88, 0xfe, 0x98, 0xa3, 0x67, 0xc6, 0x39, 0x5a,
-	0x5f, 0x86, 0x6b, 0x29, 0x0b, 0x95, 0x33, 0xff, 0x59, 0x82, 0x9b, 0x89, 0x9e, 0x7d, 0x8f, 0x61,
-	0xea, 0x59, 0x3f, 0xe0, 0x1c, 0x72, 0x21, 0x8d, 0x99, 0xff, 0x01, 0xd2, 0x58, 0x83, 0xd5, 0x82,
-	0x29, 0x44, 0x70, 0x38, 0xf7, 0xc7, 0xeb, 0x69, 0xc3, 0xe1, 0x59, 0xa1, 0x4a, 0xe1, 0x97, 0x5c,
-	0xa1, 0x27, 0x0e, 0xce, 0xa9, 0x29, 0x14, 0x17, 0x25, 0x76, 0x2d, 0xe6, 0xbc, 0xc6, 0xf2, 0x76,
-	0x56, 0x8f, 0x93, 0x80, 0xc8, 0xef, 0x2a, 0x69, 0x55, 0x5a, 0xb3, 0xb2, 0xea, 0xf7, 0x25, 0x9e,
-	0x63, 0x0d, 0x5d, 0xc7, 0x9e, 0x6e, 0x65, 0x00, 0xbd, 0x0b, 0xf3, 0x72, 0x51, 0xc6, 0x20, 0x51,
-	0x8a, 0x43, 0x5f, 0x85, 0x1b, 0xb9, 0x36, 0x48, 0x1b, 0x9f, 0xfc, 0x75, 0x55, 0x14, 0x28, 0x83,
-	0x92, 0x96, 0xac, 0xe6, 0xa2, 0xcf, 0xa1, 0x99, 0x2e, 0xae, 0xa2, 0xb5, 0xac, 0x92, 0x44, 0x2d,
-	0x57, 0xbb, 0x5d, 0xcc, 0xa0, 0x1c, 0x32, 0xff, 0x9f, 0x6f, 0x1f, 0x94, 0xab, 0x65, 0xf4, 0x45,
-	0x50, 0x14, 0x8d, 0x55, 0x4c, 0x51, 0x7c, 0x78, 0x6e, 0x89, 0x56, 0xbb, 0x33, 0x86, 0x23, 0xa1,
-	0xa1, 0x84, 0x9e, 0x01, 0x44, 0x25, 0x50, 0xb4, 0x92, 0x1c, 0x18, 0x2b, 0xc5, 0x6a, 0x5a, 0x5e,
-	0x57, 0x4a, 0xd8, 0xa7, 0x70, 0x25, 0x59, 0xc1, 0x44, 0xab, 0xe1, 0x0b, 0x2c, 0xaf, 0xa2, 0xaa,
-	0xdd, 0x2a, 0xea, 0xce, 0x0a, 0x4e, 0x96, 0x13, 0x23, 0xc1, 0xb9, 0x95, 0xcb, 0x48, 0x70, 0x7e,
-	0x15, 0x32, 0x14, 0x6c, 0x03, 0xca, 0x96, 0x01, 0x51, 0xe8, 0xbf, 0xc2, 0xaa, 0xa4, 0xa6, 0x8f,
-	0x63, 0x49, 0x29, 0x39, 0x80, 0x7a, 0xac, 0x16, 0x86, 0x42, 0x4f, 0x66, 0x2b, 0x8c, 0xda, 0x8d,
-	0xdc, 0xbe, 0x94, 0xbc, 0xcf, 0xa1, 0x99, 0xce, 0x43, 0xa2, 0xa0, 0x2b, 0x28, 0xaf, 0x45, 0x41,
-	0x57, 0x58, 0x2a, 0x0b, 0xc4, 0xbf, 0x00, 0x88, 0x4a, 0x45, 0x51, 0x48, 0x64, 0x6a, 0x55, 0x51,
-	0x48, 0x64, 0x2b, 0x4b, 0x81, 0xb0, 0xc7, 0xc2, 0xda, 0x74, 0xe9, 0x27, 0xb2, 0xb6, 0xa0, 0xd2,
-	0x14, 0x59, 0x5b, 0x54, 0x35, 0x8a, 0x6f, 0x91, 0x4c, 0x2d, 0x25, 0xda, 0x22, 0x45, 0x15, 0xa4,
-	0x68, 0x8b, 0x14, 0x16, 0x62, 0x42, 0x7f, 0xfc, 0x14, 0x66, 0x77, 0x7c, 0xfb, 0x0c, 0x85, 0xb0,
-	0x7f, 0xac, 0x0c, 0xa3, 0x2d, 0x25, 0x89, 0xa9, 0xa1, 0xdb, 0x50, 0x0d, 0x4a, 0x0a, 0x68, 0x39,
-	0xe0, 0x4c, 0x55, 0x55, 0xb4, 0x56, 0xb6, 0x23, 0x25, 0xe6, 0x04, 0x2e, 0x27, 0x80, 0x7d, 0x74,
-	0x33, 0xd4, 0x9a, 0x53, 0x5f, 0xd0, 0x56, 0x0b, 0x7a, 0x53, 0x9e, 0x7b, 0x06, 0x10, 0x01, 0xee,
-	0xd1, 0x3a, 0x67, 0x8a, 0x02, 0xd1, 0x3a, 0xe7, 0xe0, 0xf3, 0xb1, 0x8d, 0x94, 0xc5, 0xcc, 0xa3,
-	0x8d, 0x54, 0x88, 0xe1, 0x47, 0x1b, 0xa9, 0x18, 0x72, 0x0f, 0x2d, 0x16, 0x4a, 0xd2, 0x28, 0x77,
-	0x5c, 0x49, 0x01, 0xea, 0x1e, 0x57, 0x52, 0x04, 0x92, 0x87, 0x4a, 0x68, 0xb6, 0x44, 0xad, 0xd0,
-	0x69, 0x74, 0xbf, 0x68, 0x0f, 0x25, 0xc1, 0x72, 0xed, 0xed, 0xef, 0xe5, 0x4b, 0x79, 0xef, 0x18,
-	0x1a, 0x71, 0x74, 0x1a, 0xdd, 0x48, 0x0a, 0x48, 0xc0, 0x78, 0xda, 0xcd, 0xfc, 0xce, 0xe4, 0x34,
-	0x1e, 0x97, 0xd0, 0x6f, 0x41, 0x2b, 0x06, 0xe8, 0xd0, 0x3b, 0xe3, 0x6c, 0x4c, 0x2a, 0x7c, 0xf7,
-	0x4d, 0x58, 0x93, 0x33, 0x7a, 0x50, 0x42, 0x7b, 0x50, 0x0b, 0x41, 0x63, 0xd4, 0x2a, 0x82, 0xbc,
-	0xb5, 0x95, 0x9c, 0x9e, 0x94, 0x77, 0x3e, 0x86, 0x46, 0x1c, 0x04, 0x8e, 0xbc, 0x93, 0x83, 0x3f,
-	0x47, 0xde, 0xc9, 0xc5, 0x8d, 0xe3, 0x47, 0x72, 0x04, 0x23, 0xc6, 0x8e, 0xe4, 0x0c, 0x56, 0x19,
-	0x3b, 0x92, 0xb3, 0xb8, 0x63, 0x18, 0x34, 0x1d, 0xf1, 0x97, 0x41, 0x12, 0xfb, 0x43, 0xf1, 0x32,
-	0x7f, 0x2e, 0xd8, 0x18, 0x9d, 0x42, 0x85, 0xc0, 0x61, 0x6c, 0x3d, 0xbf, 0x80, 0x85, 0x0c, 0x98,
-	0x17, 0xe9, 0x28, 0x42, 0x0f, 0x23, 0x1d, 0x85, 0x48, 0x60, 0x38, 0x8b, 0x36, 0x54, 0xd4, 0xbf,
-	0x41, 0xe8, 0x7a, 0x38, 0x2a, 0xf1, 0xe3, 0x91, 0xb6, 0x9c, 0xa1, 0xa7, 0x3c, 0x7b, 0x04, 0xf5,
-	0x18, 0xd2, 0x87, 0xe2, 0x77, 0x44, 0x0a, 0xc1, 0x8b, 0x3c, 0x9b, 0x03, 0x0d, 0xc6, 0xe6, 0xfd,
-	0x3b, 0x9e, 0x09, 0x8c, 0xc1, 0xdd, 0xd0, 0x7b, 0xe3, 0xe2, 0x33, 0xad, 0xf4, 0xe1, 0x9b, 0x31,
-	0xa7, 0x66, 0xf5, 0x2b, 0xb8, 0x9c, 0xc0, 0x90, 0xa2, 0x13, 0x38, 0x0f, 0xe8, 0x8b, 0x4e, 0xe0,
-	0x5c, 0xe0, 0x29, 0x36, 0xb7, 0x33, 0x58, 0xca, 0xcb, 0xf9, 0xd1, 0xdd, 0x68, 0x57, 0x14, 0xa2,
-	0x17, 0xda, 0xbd, 0xf1, 0x4c, 0x19, 0x65, 0x1d, 0x58, 0xc8, 0x00, 0x28, 0x51, 0x00, 0x15, 0x21,
-	0x3b, 0x51, 0x00, 0x15, 0xa2, 0x2f, 0x31, 0x1d, 0x18, 0x50, 0xb6, 0x5a, 0x82, 0x62, 0x0f, 0xd2,
-	0x82, 0xa2, 0x4d, 0x74, 0x44, 0x8f, 0x29, 0xb6, 0x44, 0x87, 0x4b, 0x07, 0x16, 0x32, 0x05, 0x92,
-	0x68, 0x2a, 0x45, 0x15, 0x99, 0x68, 0x2a, 0x85, 0xd5, 0x95, 0xd8, 0x54, 0x5e, 0xc2, 0xd5, 0x54,
-	0xa6, 0x8f, 0x6e, 0x25, 0x5e, 0x0d, 0x19, 0x60, 0x42, 0x5b, 0x2b, 0xec, 0x4f, 0xc5, 0x13, 0x81,
-	0xeb, 0xf9, 0xf9, 0x3c, 0x7a, 0x2b, 0x16, 0x3a, 0xc5, 0x50, 0x82, 0x76, 0xff, 0xfb, 0xd8, 0x52,
-	0x5b, 0xfb, 0x04, 0x2e, 0x27, 0x52, 0xd1, 0x28, 0x80, 0xf3, 0x00, 0x82, 0x28, 0x80, 0xf3, 0x93,
-	0xf3, 0x60, 0x1a, 0x6e, 0x2a, 0x7b, 0x0f, 0x12, 0x5c, 0x74, 0x2f, 0x77, 0x7c, 0x2a, 0x85, 0xd7,
-	0xde, 0xfa, 0x1e, 0xae, 0xec, 0xbb, 0x37, 0x9d, 0xd8, 0xc6, 0x93, 0xad, 0xdc, 0x3c, 0x3a, 0x9e,
-	0x6c, 0x15, 0xe4, 0xc4, 0x09, 0xf1, 0xc9, 0x0c, 0x35, 0x2e, 0x3e, 0x37, 0x6b, 0x8e, 0x8b, 0x2f,
-	0x48, 0x6e, 0x03, 0xf1, 0x3d, 0x58, 0xcc, 0xc9, 0x2f, 0x51, 0x2c, 0xee, 0x8b, 0x12, 0x60, 0xed,
-	0xee, 0x58, 0x9e, 0xa4, 0x9e, 0xf6, 0xe3, 0x97, 0x9c, 0xdb, 0xb5, 0x3a, 0xeb, 0x36, 0x19, 0x3c,
-	0x92, 0x9f, 0xef, 0x13, 0x7a, 0xfa, 0x48, 0xca, 0x78, 0x24, 0x7e, 0x35, 0x7e, 0x74, 0x4a, 0x54,
-	0x7b, 0xd8, 0xe9, 0xcc, 0x0b, 0xd2, 0xd3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x6a, 0xc3, 0xa4,
-	0x50, 0xaf, 0x2c, 0x00, 0x00,
+	// 2993 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcb, 0x6f, 0x1c, 0xc7,
+	0xd1, 0xd7, 0xf2, 0xb5, 0xbb, 0xc5, 0x95, 0xb4, 0x6c, 0x52, 0xe2, 0x72, 0x24, 0x8a, 0xd2, 0x48,
+	0x96, 0x65, 0x5b, 0xa6, 0x64, 0xe9, 0xfb, 0xf0, 0xf9, 0x4b, 0x10, 0x04, 0x7c, 0x93, 0x7a, 0x90,
+	0xf4, 0x90, 0x8e, 0x61, 0x01, 0xc6, 0x78, 0x76, 0xb6, 0xc9, 0x9d, 0x70, 0x76, 0x7a, 0xd5, 0xd3,
+	0x4b, 0x8a, 0x46, 0x72, 0x48, 0x00, 0x5f, 0x0d, 0x04, 0x08, 0xe2, 0x1c, 0x73, 0xce, 0x5f, 0x90,
+	0x4b, 0x10, 0xe4, 0x92, 0xff, 0xc1, 0x7f, 0x46, 0x90, 0x5b, 0x4e, 0x41, 0x3f, 0x66, 0x7a, 0x9e,
+	0x6b, 0x05, 0x5c, 0x38, 0xc8, 0x6d, 0xba, 0xba, 0xba, 0xaa, 0xba, 0xba, 0xfa, 0x51, 0xbf, 0x1a,
+	0x68, 0x51, 0xdc, 0x27, 0xa1, 0xc7, 0x08, 0x3d, 0xff, 0x30, 0xc4, 0xf4, 0xd4, 0x73, 0xf1, 0x72,
+	0x9f, 0x12, 0x46, 0xd0, 0xd4, 0xb1, 0xc7, 0x1c, 0xff, 0xdc, 0x68, 0x84, 0x5d, 0x87, 0xe2, 0x8e,
+	0xa4, 0x9a, 0x07, 0x30, 0x6f, 0xc5, 0x23, 0x36, 0xde, 0x78, 0x21, 0x0b, 0x2d, 0xfc, 0x7a, 0x80,
+	0x43, 0x86, 0x3e, 0x06, 0xd0, 0xc2, 0x5a, 0x95, 0xdb, 0x95, 0x07, 0xd3, 0x4f, 0xd0, 0xb2, 0x94,
+	0xb2, 0xac, 0x07, 0xad, 0x4e, 0xfc, 0xfe, 0x6f, 0x0f, 0x2b, 0x56, 0x82, 0xd7, 0x7c, 0x02, 0xad,
+	0xbc, 0xd0, 0xb0, 0x4f, 0x82, 0x10, 0xa3, 0xeb, 0x30, 0x85, 0x05, 0x45, 0x48, 0xac, 0x59, 0xaa,
+	0x65, 0x1e, 0x8a, 0x31, 0x8e, 0x7b, 0xb2, 0x13, 0xb8, 0x14, 0xf7, 0x70, 0xc0, 0x1c, 0xff, 0xe2,
+	0x96, 0xdc, 0x80, 0x85, 0x02, 0xa9, 0xd2, 0x14, 0x93, 0xc2, 0x8c, 0xec, 0xdc, 0x1c, 0xf8, 0x17,
+	0xd7, 0x85, 0xee, 0xc2, 0x65, 0x97, 0x62, 0x87, 0x61, 0xbb, 0xed, 0xb1, 0x9e, 0xd3, 0x6f, 0x8d,
+	0x89, 0x09, 0x36, 0x24, 0x71, 0x55, 0xd0, 0xcc, 0x39, 0x40, 0x49, 0x9d, 0xca, 0x92, 0x53, 0xb8,
+	0xb6, 0xe5, 0xd0, 0xb6, 0x73, 0x8c, 0xd7, 0x88, 0xef, 0x63, 0x97, 0xfd, 0x40, 0xd6, 0xb4, 0xe0,
+	0x7a, 0x56, 0xaf, 0xb2, 0xe8, 0x19, 0x5c, 0x59, 0xf3, 0xb1, 0x13, 0x0c, 0xfa, 0x17, 0x5f, 0x84,
+	0x19, 0xb8, 0x1a, 0xcb, 0x52, 0xe2, 0x3f, 0x81, 0x6b, 0x7a, 0xc8, 0x81, 0xf7, 0x15, 0xbe, 0xb8,
+	0x96, 0x87, 0x70, 0x3d, 0x2b, 0x52, 0x85, 0x1c, 0x82, 0x89, 0xd0, 0xfb, 0x0a, 0x0b, 0x69, 0xe3,
+	0x96, 0xf8, 0x36, 0x5f, 0xc3, 0xc2, 0x4a, 0xbf, 0xef, 0x9f, 0x6f, 0x79, 0xcc, 0x61, 0x8c, 0x7a,
+	0xed, 0x01, 0xc3, 0x17, 0x8f, 0x7c, 0x64, 0x40, 0x8d, 0xe2, 0x53, 0x2f, 0xf4, 0x48, 0x20, 0x1c,
+	0xde, 0xb0, 0xe2, 0xb6, 0x79, 0x13, 0x8c, 0x22, 0x95, 0xca, 0x23, 0x7f, 0x19, 0x03, 0xb4, 0x89,
+	0x99, 0xdb, 0xb5, 0x70, 0x8f, 0xb0, 0x8b, 0xfb, 0x83, 0x6f, 0x34, 0x2a, 0x44, 0x09, 0x43, 0xea,
+	0x96, 0x6a, 0xa1, 0x39, 0x98, 0x3c, 0x22, 0xd4, 0xc5, 0xad, 0x71, 0x11, 0x10, 0xb2, 0x81, 0xe6,
+	0xa1, 0x1a, 0x10, 0x9b, 0x39, 0xc7, 0x61, 0x6b, 0x42, 0xee, 0xcb, 0x80, 0x1c, 0x3a, 0xc7, 0x21,
+	0x6a, 0x41, 0x95, 0x79, 0x3d, 0x4c, 0x06, 0xac, 0x35, 0x79, 0xbb, 0xf2, 0x60, 0xd2, 0x8a, 0x9a,
+	0x7c, 0x48, 0x18, 0x76, 0xed, 0x13, 0x7c, 0xde, 0x9a, 0x92, 0x1a, 0xc2, 0xb0, 0xfb, 0x1c, 0x9f,
+	0xa3, 0x25, 0x98, 0x3e, 0x09, 0xc8, 0x59, 0x60, 0x77, 0x09, 0xdf, 0xe7, 0x55, 0xd1, 0x09, 0x82,
+	0xb4, 0xcd, 0x29, 0x68, 0x01, 0x6a, 0x01, 0xb1, 0xfb, 0x74, 0x10, 0xe0, 0x56, 0x5d, 0x68, 0xab,
+	0x06, 0x64, 0x9f, 0x37, 0xd1, 0x53, 0xb8, 0x2c, 0xed, 0xb4, 0xfb, 0x0e, 0x75, 0x7a, 0x61, 0x0b,
+	0xc4, 0x94, 0xaf, 0xe8, 0x29, 0x0b, 0xef, 0x34, 0x24, 0xd3, 0xbe, 0xe0, 0x79, 0x36, 0x51, 0xab,
+	0x35, 0xeb, 0xe6, 0x35, 0x98, 0x4d, 0x39, 0x50, 0x39, 0xf6, 0x00, 0xe6, 0xd7, 0x44, 0xcc, 0x6b,
+	0x6f, 0x5d, 0x3c, 0xd8, 0x0c, 0x68, 0xe5, 0x85, 0x2a, 0x85, 0x5f, 0x8f, 0xc1, 0xcc, 0x16, 0x66,
+	0x2b, 0xd4, 0xed, 0x7a, 0xa7, 0x23, 0x58, 0xc8, 0x1b, 0x50, 0x77, 0x49, 0xaf, 0xe7, 0x31, 0xdb,
+	0xeb, 0xa8, 0xb5, 0xac, 0x49, 0xc2, 0x4e, 0x87, 0xaf, 0x72, 0x9f, 0xe2, 0x23, 0xef, 0x8d, 0x58,
+	0xce, 0xba, 0xa5, 0x5a, 0xe8, 0x63, 0x98, 0x3a, 0x22, 0xb4, 0xe7, 0x30, 0xb1, 0x9c, 0x57, 0x9e,
+	0xdc, 0x8e, 0x54, 0xe5, 0x2c, 0x5b, 0xde, 0x14, 0x7c, 0x96, 0xe2, 0xe7, 0xbb, 0xa5, 0xef, 0xb0,
+	0xae, 0x58, 0xed, 0x86, 0x25, 0xbe, 0xcd, 0xa7, 0x30, 0x25, 0xb9, 0x50, 0x15, 0xc6, 0x5f, 0xed,
+	0xec, 0x37, 0x2f, 0xf1, 0x8f, 0xc3, 0x15, 0xab, 0x59, 0x41, 0x00, 0x53, 0x87, 0x2b, 0x96, 0xbd,
+	0xf5, 0xaa, 0x39, 0x86, 0xa6, 0xa1, 0xca, 0xbf, 0x57, 0x5f, 0x3d, 0x69, 0x8e, 0x9b, 0x0f, 0x00,
+	0x25, 0x95, 0xe9, 0xcd, 0xd8, 0x71, 0x98, 0x23, 0x3c, 0xd0, 0xb0, 0xc4, 0x37, 0x5f, 0xa2, 0x6d,
+	0x27, 0x7c, 0x41, 0x5c, 0xc7, 0x5f, 0xa5, 0x4e, 0xe0, 0x76, 0x47, 0xb0, 0x15, 0xcd, 0xc7, 0xd0,
+	0xca, 0x0b, 0x55, 0x46, 0xcc, 0xc1, 0xe4, 0xa9, 0xe3, 0x0f, 0xb0, 0xba, 0x83, 0x64, 0xc3, 0xfc,
+	0xae, 0x02, 0x2d, 0x11, 0x41, 0x07, 0x64, 0x40, 0x5d, 0x2c, 0x47, 0x5d, 0x7c, 0xfd, 0x7e, 0x0a,
+	0x33, 0xa1, 0x10, 0x68, 0x27, 0x04, 0x8c, 0x95, 0x09, 0xb0, 0x9a, 0x92, 0xd9, 0x4a, 0x1d, 0xe5,
+	0x4a, 0x40, 0x5b, 0x98, 0x24, 0x96, 0xba, 0x61, 0x35, 0xc2, 0x84, 0x99, 0x68, 0x11, 0x80, 0x39,
+	0xf4, 0x18, 0x33, 0x9b, 0xe2, 0x23, 0xb1, 0xe8, 0x0d, 0xab, 0x2e, 0x29, 0x16, 0x3e, 0x32, 0x9f,
+	0xc2, 0x42, 0xc1, 0xd4, 0xf4, 0x9d, 0x4c, 0x71, 0x38, 0xf0, 0x59, 0x74, 0x27, 0xcb, 0x96, 0xb9,
+	0x05, 0xd3, 0x9b, 0xa1, 0x7b, 0x72, 0xf1, 0xb5, 0xb8, 0x07, 0x0d, 0x29, 0x48, 0xfb, 0x1f, 0x53,
+	0x4a, 0xa8, 0x8a, 0x02, 0xd9, 0x30, 0xff, 0x54, 0x81, 0xab, 0x9f, 0x51, 0x8f, 0x6f, 0xaa, 0xa3,
+	0x8b, 0xbb, 0xbd, 0x09, 0xe3, 0xdc, 0x13, 0xf2, 0x14, 0xe6, 0x9f, 0xa9, 0xc3, 0x79, 0x3c, 0x7d,
+	0x38, 0xa3, 0x3b, 0xd0, 0x20, 0x7e, 0xc7, 0x8e, 0xfb, 0xa5, 0x03, 0xa7, 0x89, 0xdf, 0xb1, 0x22,
+	0x96, 0xf8, 0xe0, 0x9c, 0x4c, 0x1c, 0x9c, 0xcf, 0x26, 0x6a, 0x53, 0xcd, 0xaa, 0xd9, 0x82, 0xa6,
+	0xb6, 0x5c, 0x4e, 0xf2, 0xd9, 0x44, 0xad, 0xd2, 0x1c, 0x33, 0xff, 0x5e, 0x81, 0x99, 0xa8, 0xeb,
+	0xf0, 0xcd, 0x7f, 0xcb, 0xb4, 0xd0, 0xff, 0xc2, 0x34, 0xa3, 0x4e, 0x10, 0x3a, 0x2e, 0xe3, 0xe3,
+	0xaa, 0xc2, 0xc2, 0xd9, 0xc8, 0xc2, 0x43, 0xdd, 0x65, 0x25, 0xf9, 0x94, 0x37, 0x9e, 0x03, 0x4a,
+	0x4e, 0x59, 0x2d, 0x7a, 0x46, 0x64, 0xe5, 0xed, 0x44, 0x9a, 0x01, 0xcc, 0x6d, 0x7a, 0x41, 0xe7,
+	0x25, 0xa6, 0xc7, 0x78, 0xd5, 0x09, 0x47, 0x70, 0xa0, 0xde, 0x84, 0x7a, 0xe4, 0x90, 0xb0, 0x35,
+	0x76, 0x7b, 0x9c, 0xef, 0x94, 0x98, 0x60, 0x7e, 0x00, 0xd7, 0x32, 0xfa, 0xf4, 0xc9, 0xd5, 0x76,
+	0x42, 0x79, 0x66, 0xd4, 0x2d, 0xf1, 0x6d, 0x7e, 0x53, 0x81, 0x19, 0x79, 0x11, 0x6c, 0x12, 0x7a,
+	0xf2, 0x9f, 0x3f, 0x2b, 0xf8, 0xfb, 0x32, 0x69, 0x4f, 0xfc, 0xd2, 0x5d, 0xd8, 0x09, 0x2d, 0xcc,
+	0x4d, 0xde, 0x09, 0xf6, 0x29, 0x39, 0xa6, 0x38, 0x0c, 0x47, 0x72, 0x33, 0x51, 0x21, 0x34, 0x71,
+	0x33, 0x49, 0xc2, 0x4e, 0xc7, 0xfc, 0x09, 0x18, 0x45, 0x3a, 0x95, 0x33, 0x97, 0x60, 0xda, 0x0b,
+	0xec, 0xbe, 0x22, 0xab, 0x73, 0x07, 0xbc, 0x98, 0x51, 0x9a, 0x7c, 0xf0, 0x7a, 0xe0, 0x84, 0xdd,
+	0x11, 0x9b, 0x1c, 0x0a, 0xa1, 0x09, 0x93, 0x25, 0x21, 0x32, 0x39, 0xaf, 0xf3, 0x6d, 0x4d, 0xf6,
+	0xe1, 0x56, 0xf6, 0x51, 0xb0, 0x49, 0x49, 0xef, 0x53, 0xeb, 0xc5, 0x48, 0xb6, 0xfd, 0x80, 0xfa,
+	0xca, 0x62, 0xfe, 0x69, 0xde, 0x81, 0xa5, 0x52, 0x6d, 0x6a, 0xd9, 0xf7, 0x60, 0x56, 0xb2, 0xac,
+	0x0e, 0x82, 0x8e, 0x3f, 0x82, 0x37, 0xf6, 0xfb, 0x30, 0x97, 0x16, 0x38, 0xe4, 0x52, 0xff, 0x66,
+	0x0c, 0x9a, 0x07, 0x98, 0xad, 0x91, 0xe0, 0xc8, 0x3b, 0xbe, 0xb8, 0x03, 0x3e, 0x86, 0x2a, 0x0e,
+	0x18, 0xf5, 0xb0, 0xdc, 0xb2, 0xd3, 0x4f, 0x6e, 0x45, 0xc3, 0xb2, 0x4a, 0x96, 0x37, 0x02, 0x46,
+	0xcf, 0xad, 0x88, 0xdd, 0xf8, 0xba, 0x02, 0x93, 0x82, 0xc4, 0x9d, 0xc8, 0x5f, 0xab, 0x72, 0x03,
+	0xf3, 0x4f, 0xb4, 0x08, 0x75, 0x71, 0xf7, 0xdb, 0x21, 0xa3, 0xd2, 0xb9, 0xdb, 0x97, 0xac, 0x9a,
+	0x20, 0x1d, 0x30, 0x8a, 0xee, 0xc0, 0xb4, 0xec, 0xf6, 0x02, 0xf6, 0xf4, 0x89, 0x38, 0x5d, 0x27,
+	0xb7, 0x2f, 0x59, 0x20, 0x88, 0x3b, 0x9c, 0x86, 0x96, 0x40, 0xb6, 0xec, 0x36, 0x21, 0xbe, 0x7c,
+	0x3b, 0x6f, 0x5f, 0xb2, 0xa4, 0xd4, 0x55, 0x42, 0xfc, 0xd5, 0xaa, 0x7a, 0x6b, 0x98, 0xb3, 0x30,
+	0x93, 0x30, 0x55, 0x2d, 0x91, 0x0b, 0xb3, 0xeb, 0xd8, 0xc7, 0x0c, 0x8f, 0xca, 0x4f, 0x08, 0x26,
+	0x4e, 0xf0, 0xb9, 0x74, 0x52, 0xdd, 0x12, 0xdf, 0xe6, 0x75, 0x98, 0x4b, 0x2b, 0x51, 0xca, 0x3d,
+	0x9e, 0x1d, 0x87, 0x8c, 0x50, 0xbc, 0x36, 0x08, 0x19, 0xe9, 0x6d, 0x13, 0x72, 0x12, 0x8e, 0xc4,
+	0x04, 0x11, 0x0d, 0x63, 0x89, 0x68, 0xb8, 0x09, 0x46, 0x91, 0x2a, 0x65, 0xc8, 0x21, 0xb4, 0x56,
+	0x1d, 0xf7, 0x64, 0xd0, 0x1f, 0xa5, 0x1d, 0xe6, 0x23, 0x58, 0x28, 0x90, 0x3a, 0x24, 0x64, 0x5f,
+	0xc3, 0x9d, 0xa2, 0x2d, 0x35, 0xa2, 0xdd, 0x53, 0xe8, 0x97, 0x7b, 0x60, 0x0e, 0x53, 0xa9, 0xfc,
+	0xb3, 0x0b, 0x88, 0xdf, 0x49, 0x2f, 0x3c, 0x17, 0x07, 0x23, 0xb8, 0x01, 0xcd, 0x35, 0x98, 0x4d,
+	0xc9, 0x53, 0x3e, 0x79, 0x08, 0xc8, 0x97, 0x24, 0x3b, 0xec, 0x12, 0xca, 0xec, 0xc0, 0xe9, 0x45,
+	0xf7, 0x5d, 0x53, 0xf5, 0x1c, 0xf0, 0x8e, 0x5d, 0xa7, 0x27, 0x16, 0x6d, 0x0b, 0xb3, 0x9d, 0xe0,
+	0x88, 0xac, 0x8c, 0x2e, 0x83, 0x36, 0x7f, 0x0c, 0x0b, 0x05, 0x52, 0x95, 0x81, 0xb7, 0x00, 0x74,
+	0xea, 0xac, 0x96, 0x2e, 0x41, 0xe1, 0x26, 0xad, 0x39, 0xbe, 0x3b, 0xf0, 0x1d, 0x86, 0xd7, 0xba,
+	0xd8, 0x3d, 0x09, 0x07, 0xbd, 0x8b, 0x9b, 0xf4, 0x7f, 0xb0, 0x50, 0x20, 0x55, 0x99, 0x64, 0x40,
+	0xcd, 0x55, 0x34, 0xe5, 0xa9, 0xb8, 0xcd, 0x97, 0x6d, 0x0b, 0xb3, 0x83, 0xc0, 0xe9, 0x87, 0x5d,
+	0x72, 0x71, 0x4c, 0xc7, 0x7c, 0x0f, 0x66, 0x53, 0xf2, 0x86, 0x84, 0xf2, 0xb7, 0x15, 0xb8, 0x5b,
+	0x14, 0x58, 0x23, 0x33, 0x86, 0x27, 0xf1, 0x5d, 0xc6, 0xfa, 0xb6, 0xbe, 0x96, 0xaa, 0xbc, 0xfd,
+	0x29, 0xf5, 0xf9, 0x25, 0x2b, 0xba, 0x9c, 0x01, 0xeb, 0xaa, 0xbc, 0x54, 0xf0, 0xae, 0x0c, 0x58,
+	0xd7, 0xbc, 0x0f, 0xf7, 0x86, 0x1b, 0xa6, 0x62, 0xfe, 0x77, 0x15, 0x98, 0xdb, 0xc2, 0xcc, 0x72,
+	0xce, 0xd6, 0xba, 0x4e, 0x70, 0x3c, 0x0a, 0x74, 0xe6, 0x2e, 0x5c, 0x3e, 0xa2, 0xa4, 0x67, 0xa7,
+	0x20, 0x9a, 0xba, 0xd5, 0xe0, 0xc4, 0xf8, 0x3d, 0xbc, 0x04, 0xd3, 0x8c, 0xd8, 0xa9, 0x17, 0x75,
+	0xdd, 0x02, 0x46, 0x22, 0x06, 0xf3, 0xcf, 0x13, 0x70, 0x2d, 0x63, 0x98, 0x5a, 0x88, 0x6d, 0x98,
+	0xa6, 0xce, 0x99, 0xed, 0x4a, 0x72, 0xab, 0x22, 0xee, 0xa9, 0x77, 0x13, 0x99, 0x77, 0x7e, 0xcc,
+	0x72, 0x4c, 0xb2, 0x80, 0xc6, 0xbd, 0xc6, 0x77, 0xe3, 0x50, 0x8f, 0x7b, 0xd0, 0x3c, 0x54, 0xdb,
+	0x3e, 0x69, 0xf3, 0x27, 0x8b, 0x0c, 0xb1, 0x29, 0xde, 0xdc, 0xe9, 0xc4, 0xc8, 0xd6, 0x98, 0x46,
+	0xb6, 0xd0, 0x22, 0xd4, 0x02, 0x7c, 0x66, 0x8b, 0x1c, 0x5e, 0x18, 0xbf, 0x3a, 0xd6, 0xaa, 0x58,
+	0xd5, 0x00, 0x9f, 0xed, 0x3b, 0x8c, 0xe7, 0x89, 0x35, 0x9e, 0x11, 0x88, 0xee, 0x09, 0xdd, 0x4d,
+	0xfc, 0x8e, 0xe8, 0xde, 0x83, 0x3a, 0xe9, 0x63, 0xea, 0x88, 0x27, 0xfa, 0xa4, 0x80, 0x0e, 0x3e,
+	0x7a, 0xcb, 0x09, 0x2c, 0xef, 0x45, 0x03, 0x2d, 0x2d, 0x83, 0xfb, 0x9c, 0xfb, 0x44, 0x0b, 0x95,
+	0x58, 0x51, 0x83, 0x3a, 0x67, 0x31, 0x3f, 0x8f, 0x25, 0x6e, 0x54, 0x8f, 0x74, 0xb0, 0x48, 0x35,
+	0x26, 0x85, 0x41, 0x2f, 0x49, 0x07, 0x0b, 0xac, 0x08, 0x9f, 0xc9, 0xae, 0x9a, 0xec, 0x0a, 0xf0,
+	0x99, 0xe8, 0xba, 0x07, 0x57, 0xa2, 0x99, 0xda, 0xed, 0x73, 0x7e, 0x22, 0xd4, 0x65, 0x62, 0xac,
+	0xe6, 0xba, 0xca, 0x69, 0x9c, 0x2b, 0x9a, 0xb0, 0xe2, 0x02, 0xc9, 0xa5, 0xa6, 0x2c, 0xb8, 0x4c,
+	0x0f, 0xea, 0xda, 0x9c, 0x69, 0xa8, 0x7e, 0xba, 0xfb, 0x7c, 0x77, 0xef, 0xb3, 0xdd, 0xe6, 0x25,
+	0x54, 0x87, 0xc9, 0x95, 0xf5, 0xf5, 0x8d, 0x75, 0x09, 0x75, 0xac, 0xed, 0xed, 0xef, 0x6c, 0xac,
+	0x4b, 0xa8, 0x63, 0x7d, 0xe3, 0xc5, 0xc6, 0xe1, 0xc6, 0x7a, 0x73, 0x1c, 0x35, 0xa0, 0xf6, 0x72,
+	0x6f, 0x7d, 0x67, 0x93, 0x77, 0x4d, 0xf0, 0x2e, 0x6b, 0x63, 0x77, 0xe5, 0xe5, 0xc6, 0x7a, 0x73,
+	0x12, 0x35, 0xa1, 0x71, 0xf8, 0xf9, 0xfe, 0x86, 0xbd, 0xb6, 0xbd, 0xb2, 0xbb, 0xb5, 0xb1, 0xde,
+	0x9c, 0x32, 0x7f, 0x01, 0xad, 0x03, 0xec, 0x50, 0xb7, 0xbb, 0xe9, 0xf9, 0x38, 0x5c, 0x3d, 0xe7,
+	0x87, 0xe9, 0xc5, 0x63, 0x7b, 0x0e, 0x26, 0x5f, 0x0f, 0xb0, 0xca, 0x16, 0xea, 0x96, 0x6c, 0x44,
+	0xd9, 0xe2, 0x78, 0x9c, 0x2d, 0x9a, 0x1f, 0xc1, 0x42, 0x81, 0x76, 0x9d, 0x97, 0x1f, 0x71, 0xb2,
+	0x08, 0xdd, 0x86, 0x25, 0x1b, 0xe6, 0x1f, 0x2b, 0x70, 0x23, 0x35, 0x66, 0x8d, 0x04, 0x0c, 0x07,
+	0xec, 0x07, 0x33, 0x1a, 0xbd, 0x07, 0x4d, 0xb7, 0x3b, 0x08, 0x4e, 0x30, 0x4f, 0x65, 0xa5, 0xad,
+	0x0a, 0xa6, 0xbc, 0xaa, 0xe8, 0xf1, 0xb1, 0x71, 0x0e, 0x37, 0x8b, 0x6d, 0x55, 0x53, 0x6c, 0x41,
+	0xb5, 0xe7, 0x30, 0xb7, 0x1b, 0x4f, 0x32, 0x6a, 0xa2, 0x45, 0x00, 0xf1, 0x69, 0x27, 0x2e, 0xe9,
+	0xba, 0xa0, 0xac, 0x3b, 0xcc, 0x41, 0xb7, 0xa1, 0x81, 0x83, 0x8e, 0x4d, 0x8e, 0x6c, 0x41, 0x53,
+	0xf0, 0x29, 0xe0, 0xa0, 0xb3, 0x77, 0xf4, 0x92, 0x53, 0xcc, 0xdf, 0x54, 0x60, 0x4a, 0x82, 0x8f,
+	0xd1, 0x73, 0xbd, 0x12, 0x3f, 0xd7, 0xf9, 0x56, 0x15, 0xb7, 0xa9, 0x9c, 0xa9, 0xf8, 0x46, 0x3f,
+	0x82, 0x85, 0xf8, 0x9c, 0x24, 0xd4, 0xfb, 0x4a, 0x44, 0x9f, 0xdd, 0xc5, 0x4e, 0x07, 0x53, 0x75,
+	0xf0, 0xcc, 0x47, 0xe7, 0x66, 0xdc, 0xbf, 0x2d, 0xba, 0xd1, 0x3b, 0x70, 0xa5, 0xe7, 0x51, 0x4a,
+	0xa8, 0x4d, 0xf1, 0x51, 0xcf, 0xe9, 0x87, 0xad, 0x09, 0xf1, 0xe2, 0xbb, 0x2c, 0xa9, 0x96, 0x24,
+	0x9a, 0xbf, 0xad, 0xc0, 0x75, 0x01, 0xfc, 0x6c, 0x1f, 0x1e, 0xee, 0x8f, 0x0a, 0x5a, 0xbe, 0x9f,
+	0x82, 0x96, 0xf3, 0xe8, 0x6c, 0x04, 0x35, 0x27, 0xb0, 0xe3, 0xf1, 0x14, 0x76, 0x6c, 0x2e, 0xc0,
+	0x7c, 0xce, 0x2a, 0xb5, 0x80, 0x9f, 0xc3, 0xe2, 0x16, 0x66, 0x7b, 0xed, 0x9f, 0x63, 0x97, 0xad,
+	0x7b, 0x14, 0xbb, 0xa3, 0x2b, 0x11, 0xfc, 0x0f, 0xdc, 0x2a, 0x13, 0x3d, 0xa4, 0x54, 0xf0, 0x87,
+	0x0a, 0xcc, 0xad, 0xf9, 0x24, 0xc0, 0xfc, 0x9a, 0xda, 0x27, 0xc4, 0x1f, 0x85, 0x03, 0x27, 0xfa,
+	0x3c, 0x5d, 0xc8, 0x64, 0xf6, 0xd2, 0x32, 0xa1, 0x42, 0xf4, 0x27, 0x1c, 0x3d, 0x3e, 0xcc, 0xd1,
+	0xe6, 0x3c, 0x5c, 0xcb, 0x58, 0xa8, 0x9c, 0xf9, 0xd7, 0x0a, 0xdc, 0x4c, 0xf5, 0xec, 0x04, 0x0c,
+	0xd3, 0xc0, 0xf9, 0x01, 0xe7, 0x50, 0x08, 0x69, 0x8c, 0xff, 0x1b, 0x90, 0xc6, 0x12, 0x2c, 0x96,
+	0x4c, 0x41, 0x23, 0xfc, 0xdc, 0x1f, 0xa7, 0xa3, 0x46, 0xf8, 0xf3, 0x42, 0x95, 0xc2, 0x37, 0x5c,
+	0x61, 0x20, 0x0e, 0xce, 0x91, 0x29, 0x14, 0x17, 0x25, 0xf6, 0x1d, 0xe6, 0x9d, 0x62, 0x79, 0x3b,
+	0xab, 0xc7, 0x49, 0x44, 0xe4, 0x77, 0x95, 0xb4, 0x2a, 0xab, 0x59, 0x59, 0xf5, 0xeb, 0x0a, 0xcf,
+	0xb1, 0xfa, 0xbe, 0xe7, 0x8e, 0xb6, 0xd8, 0x81, 0xde, 0x87, 0x29, 0xb9, 0x28, 0x43, 0x90, 0x28,
+	0xc5, 0x61, 0x2e, 0xc2, 0x8d, 0x42, 0x1b, 0xa4, 0x8d, 0x4f, 0xfe, 0xb1, 0x28, 0x6a, 0xae, 0x51,
+	0x95, 0x4e, 0x16, 0xa8, 0xd1, 0x17, 0xd0, 0xcc, 0xd6, 0x8b, 0xd1, 0x52, 0x5e, 0x49, 0xaa, 0x3c,
+	0x6d, 0xdc, 0x2e, 0x67, 0x50, 0x0e, 0x99, 0xfa, 0xe7, 0xb7, 0x0f, 0xc6, 0x6a, 0x63, 0xe8, 0xcb,
+	0xa8, 0xce, 0x9b, 0x28, 0x02, 0xa3, 0xe4, 0xf0, 0xc2, 0xaa, 0xb3, 0x71, 0x67, 0x08, 0x47, 0x4a,
+	0x43, 0x05, 0x3d, 0x07, 0xd0, 0x55, 0x5d, 0xb4, 0x90, 0x1e, 0x98, 0xa8, 0x2e, 0x1b, 0x46, 0x51,
+	0x57, 0x46, 0xd8, 0x67, 0x70, 0x25, 0x5d, 0x94, 0x45, 0x8b, 0xf1, 0x0b, 0xac, 0xa8, 0x48, 0x6c,
+	0xdc, 0x2a, 0xeb, 0xce, 0x0b, 0x4e, 0x57, 0x48, 0xb5, 0xe0, 0xc2, 0x62, 0xac, 0x16, 0x5c, 0x5c,
+	0x58, 0x8d, 0x05, 0xbb, 0x80, 0xf2, 0x95, 0x4d, 0x14, 0xfb, 0xaf, 0xb4, 0xd0, 0x6a, 0x98, 0xc3,
+	0x58, 0x32, 0x4a, 0x76, 0x61, 0x3a, 0x51, 0xde, 0x43, 0xb1, 0x27, 0xf3, 0x45, 0x53, 0xe3, 0x46,
+	0x61, 0x5f, 0x46, 0xde, 0x17, 0xd0, 0xcc, 0xe6, 0x21, 0x3a, 0xe8, 0x4a, 0x2a, 0x86, 0x3a, 0xe8,
+	0x4a, 0xab, 0x7f, 0x91, 0xf8, 0x97, 0x00, 0xba, 0xfa, 0xa5, 0x43, 0x22, 0x57, 0x7e, 0xd3, 0x21,
+	0x91, 0x2f, 0x96, 0x45, 0xc2, 0x1e, 0x0b, 0x6b, 0xb3, 0xd5, 0x2c, 0x6d, 0x6d, 0x49, 0xf1, 0x4c,
+	0x5b, 0x5b, 0x56, 0x08, 0x4b, 0x6e, 0x91, 0x5c, 0x79, 0x48, 0x6f, 0x91, 0xb2, 0xa2, 0x98, 0xde,
+	0x22, 0xa5, 0xb5, 0xa5, 0xd8, 0x1f, 0xff, 0x0f, 0x13, 0x9b, 0xa1, 0x7b, 0x82, 0x62, 0xc0, 0x3f,
+	0x51, 0x59, 0x32, 0xe6, 0xd2, 0xc4, 0xcc, 0xd0, 0x0d, 0xa8, 0x45, 0xe5, 0x04, 0x34, 0x1f, 0x71,
+	0x66, 0x0a, 0x45, 0x46, 0x2b, 0xdf, 0x91, 0xdf, 0xa4, 0xba, 0x2a, 0xa1, 0x57, 0x24, 0x57, 0x9c,
+	0xd1, 0x2b, 0x92, 0x2f, 0x62, 0xc4, 0xc2, 0x0e, 0xe1, 0x72, 0xaa, 0x4a, 0x80, 0x6e, 0xc6, 0x53,
+	0x28, 0x28, 0x56, 0x18, 0x8b, 0x25, 0xbd, 0x99, 0x65, 0x78, 0x0e, 0xa0, 0xd1, 0x7b, 0x6d, 0x62,
+	0xae, 0xc2, 0xa0, 0x4d, 0x2c, 0x00, 0xfb, 0x13, 0xbb, 0x32, 0x0f, 0xc0, 0xeb, 0x5d, 0x59, 0x5a,
+	0x10, 0xd0, 0xbb, 0xb2, 0x1c, 0xbf, 0x8f, 0x2d, 0x16, 0x4a, 0xb2, 0x90, 0x79, 0x52, 0x49, 0x09,
+	0x84, 0x9f, 0x54, 0x52, 0x86, 0xb8, 0xc7, 0x4a, 0x68, 0xbe, 0x84, 0xaf, 0xa0, 0x6e, 0x74, 0xbf,
+	0x6c, 0x43, 0xa6, 0x91, 0x77, 0xe3, 0xdd, 0xef, 0xe5, 0xcb, 0x78, 0xef, 0x00, 0x1a, 0x49, 0xa8,
+	0x1b, 0xdd, 0x48, 0x0b, 0x48, 0x61, 0x82, 0xc6, 0xcd, 0xe2, 0xce, 0xf4, 0x34, 0x1e, 0x57, 0xd0,
+	0x2f, 0xc1, 0x28, 0x47, 0xfb, 0xd0, 0x7b, 0xc3, 0x6c, 0x4c, 0x2b, 0x7c, 0xff, 0x6d, 0x58, 0xd3,
+	0x33, 0x7a, 0x50, 0x41, 0xdb, 0x50, 0x8f, 0x11, 0x68, 0xd4, 0x2a, 0xc3, 0xcf, 0x8d, 0x85, 0x82,
+	0x9e, 0x8c, 0x77, 0x3e, 0x81, 0x46, 0x12, 0x51, 0xd6, 0xde, 0x29, 0x00, 0xb3, 0xb5, 0x77, 0x0a,
+	0x41, 0xe8, 0xe4, 0xf9, 0xae, 0x31, 0xc9, 0xc4, 0xf9, 0x9e, 0x03, 0x3e, 0x13, 0xe7, 0x7b, 0x1e,
+	0xc4, 0x8c, 0x83, 0xa6, 0x2d, 0xfe, 0xc2, 0x48, 0x03, 0x89, 0x28, 0xf9, 0x1b, 0x44, 0x21, 0x72,
+	0xa9, 0x8f, 0xb4, 0x52, 0x14, 0x32, 0xb1, 0x9e, 0x5f, 0xc2, 0x4c, 0x0e, 0x19, 0xd4, 0x3a, 0xca,
+	0xa0, 0x48, 0xad, 0xa3, 0x14, 0x56, 0x8c, 0x67, 0xb1, 0x0a, 0x55, 0xf5, 0xef, 0x14, 0xba, 0x1e,
+	0x8f, 0x4a, 0xfd, 0x98, 0x65, 0xcc, 0xe7, 0xe8, 0x19, 0xcf, 0xee, 0xc3, 0x74, 0x02, 0x36, 0x44,
+	0xc9, 0x0b, 0x27, 0x03, 0x07, 0x6a, 0xcf, 0x16, 0xe0, 0x8c, 0x89, 0x79, 0xff, 0x8a, 0xa7, 0x15,
+	0x43, 0x40, 0x3c, 0xf4, 0xc1, 0xb0, 0xf8, 0xcc, 0x2a, 0x7d, 0xf8, 0x76, 0xcc, 0x99, 0x59, 0xfd,
+	0x0c, 0x2e, 0xa7, 0x00, 0x29, 0x7d, 0x02, 0x17, 0xa1, 0x86, 0xfa, 0x04, 0x2e, 0x44, 0xb1, 0x12,
+	0x73, 0x3b, 0x81, 0xb9, 0x22, 0x00, 0x01, 0xdd, 0xd5, 0xbb, 0xa2, 0x14, 0x0a, 0x31, 0xee, 0x0d,
+	0x67, 0xca, 0x29, 0x6b, 0xc3, 0x4c, 0x0e, 0x8d, 0xd1, 0x01, 0x54, 0x06, 0x13, 0xe9, 0x00, 0x2a,
+	0x85, 0x72, 0x12, 0x3a, 0x30, 0xa0, 0x7c, 0xe9, 0x05, 0x25, 0x5e, 0xb7, 0x25, 0x15, 0x20, 0x7d,
+	0x44, 0x0f, 0xa9, 0xdc, 0xe8, 0xc3, 0xa5, 0x0d, 0x33, 0xb9, 0x6a, 0x8b, 0x9e, 0x4a, 0x59, 0x79,
+	0x47, 0x4f, 0xa5, 0xb4, 0x54, 0x93, 0x98, 0xca, 0x2b, 0xb8, 0x9a, 0x81, 0x0d, 0xd0, 0xad, 0xd4,
+	0x13, 0x24, 0x87, 0x72, 0x18, 0x4b, 0xa5, 0xfd, 0x99, 0x78, 0x22, 0x70, 0xbd, 0x18, 0x1c, 0x40,
+	0xef, 0x24, 0x42, 0xa7, 0x1c, 0x97, 0x30, 0xee, 0x7f, 0x1f, 0x5b, 0x66, 0x6b, 0x1f, 0xc2, 0xe5,
+	0x54, 0x5e, 0xab, 0x03, 0xb8, 0x08, 0x6d, 0xd0, 0x01, 0x5c, 0x9c, 0xe9, 0x47, 0xd3, 0xf0, 0x33,
+	0x50, 0x40, 0x94, 0x2d, 0xa3, 0x7b, 0x85, 0xe3, 0x33, 0x78, 0x80, 0xf1, 0xce, 0xf7, 0x70, 0xe5,
+	0x1f, 0xd1, 0xd9, 0x2c, 0x39, 0x99, 0xb9, 0x15, 0x26, 0xe5, 0xc9, 0xcc, 0xad, 0x24, 0xc1, 0x4e,
+	0x89, 0x4f, 0xa7, 0xbb, 0x49, 0xf1, 0x85, 0x29, 0x78, 0x52, 0x7c, 0x49, 0xa6, 0x1c, 0x89, 0x3f,
+	0x82, 0xd9, 0x82, 0x64, 0x15, 0x25, 0xe2, 0xbe, 0x2c, 0x9b, 0x36, 0xee, 0x0e, 0xe5, 0x49, 0xeb,
+	0x59, 0x7d, 0xfc, 0x8a, 0x73, 0xfb, 0x4e, 0x7b, 0xd9, 0x25, 0xbd, 0x47, 0xf2, 0xf3, 0x43, 0x42,
+	0x8f, 0x1f, 0x49, 0x19, 0x8f, 0xc4, 0xaf, 0xd8, 0x8f, 0x8e, 0x89, 0x6a, 0xf7, 0xdb, 0xed, 0x29,
+	0x41, 0x7a, 0xfa, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf2, 0xbb, 0xb2, 0xb1, 0xcf, 0x2d, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -4054,6 +4163,7 @@ type RepositoryServiceClient interface {
 	FetchSourceBranch(ctx context.Context, in *FetchSourceBranchRequest, opts ...grpc.CallOption) (*FetchSourceBranchResponse, error)
 	Fsck(ctx context.Context, in *FsckRequest, opts ...grpc.CallOption) (*FsckResponse, error)
 	WriteRef(ctx context.Context, in *WriteRefRequest, opts ...grpc.CallOption) (*WriteRefResponse, error)
+	WriteRefTx(ctx context.Context, in *WriteRefTxRequest, opts ...grpc.CallOption) (*WriteRefTxResponse, error)
 	FindMergeBase(ctx context.Context, in *FindMergeBaseRequest, opts ...grpc.CallOption) (*FindMergeBaseResponse, error)
 	CreateFork(ctx context.Context, in *CreateForkRequest, opts ...grpc.CallOption) (*CreateForkResponse, error)
 	IsRebaseInProgress(ctx context.Context, in *IsRebaseInProgressRequest, opts ...grpc.CallOption) (*IsRebaseInProgressResponse, error)
@@ -4231,6 +4341,15 @@ func (c *repositoryServiceClient) WriteRef(ctx context.Context, in *WriteRefRequ
 	return out, nil
 }
 
+func (c *repositoryServiceClient) WriteRefTx(ctx context.Context, in *WriteRefTxRequest, opts ...grpc.CallOption) (*WriteRefTxResponse, error) {
+	out := new(WriteRefTxResponse)
+	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/WriteRefTx", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *repositoryServiceClient) FindMergeBase(ctx context.Context, in *FindMergeBaseRequest, opts ...grpc.CallOption) (*FindMergeBaseResponse, error) {
 	out := new(FindMergeBaseResponse)
 	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/FindMergeBase", in, out, opts...)
@@ -4700,6 +4819,7 @@ type RepositoryServiceServer interface {
 	FetchSourceBranch(context.Context, *FetchSourceBranchRequest) (*FetchSourceBranchResponse, error)
 	Fsck(context.Context, *FsckRequest) (*FsckResponse, error)
 	WriteRef(context.Context, *WriteRefRequest) (*WriteRefResponse, error)
+	WriteRefTx(context.Context, *WriteRefTxRequest) (*WriteRefTxResponse, error)
 	FindMergeBase(context.Context, *FindMergeBaseRequest) (*FindMergeBaseResponse, error)
 	CreateFork(context.Context, *CreateForkRequest) (*CreateForkResponse, error)
 	IsRebaseInProgress(context.Context, *IsRebaseInProgressRequest) (*IsRebaseInProgressResponse, error)
@@ -4772,6 +4892,9 @@ func (*UnimplementedRepositoryServiceServer) Fsck(ctx context.Context, req *Fsck
 func (*UnimplementedRepositoryServiceServer) WriteRef(ctx context.Context, req *WriteRefRequest) (*WriteRefResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method WriteRef not implemented")
 }
+func (*UnimplementedRepositoryServiceServer) WriteRefTx(ctx context.Context, req *WriteRefTxRequest) (*WriteRefTxResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method WriteRefTx not implemented")
+}
 func (*UnimplementedRepositoryServiceServer) FindMergeBase(ctx context.Context, req *FindMergeBaseRequest) (*FindMergeBaseResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method FindMergeBase not implemented")
 }
@@ -5095,6 +5218,24 @@ func _RepositoryService_WriteRef_Handler(srv interface{}, ctx context.Context, d
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RepositoryService_WriteRefTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(WriteRefTxRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).WriteRefTx(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/WriteRefTx",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).WriteRefTx(ctx, req.(*WriteRefTxRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _RepositoryService_FindMergeBase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FindMergeBaseRequest)
 	if err := dec(in); err != nil {
@@ -5670,6 +5811,10 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "WriteRef",
 			Handler:    _RepositoryService_WriteRef_Handler,
 		},
+		{
+			MethodName: "WriteRefTx",
+			Handler:    _RepositoryService_WriteRefTx_Handler,
+		},
 		{
 			MethodName: "FindMergeBase",
 			Handler:    _RepositoryService_FindMergeBase_Handler,
diff --git a/proto/repository-service.proto b/proto/repository-service.proto
index 4462eea49a..1eb7a4d940 100644
--- a/proto/repository-service.proto
+++ b/proto/repository-service.proto
@@ -72,6 +72,11 @@ service RepositoryService {
       op: MUTATOR
     };
   }
+  rpc WriteRefTx(WriteRefTxRequest) returns (WriteRefTxResponse) {
+      option (op_type) = {
+      op: MUTATOR
+    };
+  }
   rpc FindMergeBase(FindMergeBaseRequest) returns (FindMergeBaseResponse) {
     option (op_type) = {
       op: ACCESSOR
@@ -336,14 +341,30 @@ message WriteRefRequest {
   // This used to be a boolean indicating whether or not to shell out or use
   // the rugged implementation
   reserved 6;
-  Transaction transaction = 7;
 }
 
 message WriteRefResponse {
+    // This used to contain an error message. Since we're shelling out
+    // all exceptions are wrapped in GRPC errors.
+    reserved 1;
+}
+
+message WriteRefTxRequest {
+    Repository repository = 1 [(target_repository)=true];
+    bytes ref = 2;
+    bytes revision = 3;
+    bytes old_revision = 4;
+    bool force = 5;
+    // This used to be a boolean indicating whether or not to shell out or use
+    // the rugged implementation
+    reserved 6;
+    Transaction transaction = 7;
+}
+
+message WriteRefTxResponse {
   // This used to contain an error message. Since we're shelling out
   // all exceptions are wrapped in GRPC errors.
-  reserved 1;
-  Transaction transaction = 2;
+  Transaction transaction = 1;
 }
 
 message FindMergeBaseRequest {
diff --git a/ruby/proto/gitaly/repository-service_pb.rb b/ruby/proto/gitaly/repository-service_pb.rb
index 9b1f7b0691..6d8741ace3 100644
--- a/ruby/proto/gitaly/repository-service_pb.rb
+++ b/ruby/proto/gitaly/repository-service_pb.rb
@@ -106,10 +106,19 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :revision, :bytes, 3
     optional :old_revision, :bytes, 4
     optional :force, :bool, 5
-    optional :transaction, :message, 7, "gitaly.Transaction"
   end
   add_message "gitaly.WriteRefResponse" do
-    optional :transaction, :message, 2, "gitaly.Transaction"
+  end
+  add_message "gitaly.WriteRefTxRequest" do
+    optional :repository, :message, 1, "gitaly.Repository"
+    optional :ref, :bytes, 2
+    optional :revision, :bytes, 3
+    optional :old_revision, :bytes, 4
+    optional :force, :bool, 5
+    optional :transaction, :message, 7, "gitaly.Transaction"
+  end
+  add_message "gitaly.WriteRefTxResponse" do
+    optional :transaction, :message, 1, "gitaly.Transaction"
   end
   add_message "gitaly.FindMergeBaseRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
@@ -349,6 +358,8 @@ module Gitaly
   FsckResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FsckResponse").msgclass
   WriteRefRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefRequest").msgclass
   WriteRefResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefResponse").msgclass
+  WriteRefTxRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefTxRequest").msgclass
+  WriteRefTxResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefTxResponse").msgclass
   FindMergeBaseRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FindMergeBaseRequest").msgclass
   FindMergeBaseResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FindMergeBaseResponse").msgclass
   CreateForkRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CreateForkRequest").msgclass
diff --git a/ruby/proto/gitaly/repository-service_services_pb.rb b/ruby/proto/gitaly/repository-service_services_pb.rb
index 61928048fb..d9f2d9385b 100644
--- a/ruby/proto/gitaly/repository-service_services_pb.rb
+++ b/ruby/proto/gitaly/repository-service_services_pb.rb
@@ -27,6 +27,7 @@ module Gitaly
       rpc :FetchSourceBranch, FetchSourceBranchRequest, FetchSourceBranchResponse
       rpc :Fsck, FsckRequest, FsckResponse
       rpc :WriteRef, WriteRefRequest, WriteRefResponse
+      rpc :WriteRefTx, WriteRefTxRequest, WriteRefTxResponse
       rpc :FindMergeBase, FindMergeBaseRequest, FindMergeBaseResponse
       rpc :CreateFork, CreateForkRequest, CreateForkResponse
       rpc :IsRebaseInProgress, IsRebaseInProgressRequest, IsRebaseInProgressResponse
-- 
GitLab


From e5aa22b7b28311911ab74096e3851c3a15217370 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Fri, 28 Feb 2020 10:37:23 -0800
Subject: [PATCH 5/8] 2pc to 3pc

---
 internal/git/repository/repository.go       | 72 ++++++++++++++++--
 internal/praefect/coordinator.go            | 50 ++++++++----
 internal/service/repository/write_ref_tx.go | 84 ++++++++++++++++-----
 proto/repository-service.proto              | 10 +--
 4 files changed, 167 insertions(+), 49 deletions(-)

diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index 02c1081f13..601cfd361f 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -3,6 +3,7 @@ package repository
 import (
 	"errors"
 	"sync"
+	"time"
 
 	"github.com/sirupsen/logrus"
 	"gitlab.com/gitlab-org/gitaly/internal/command"
@@ -55,7 +56,7 @@ func (t *Transactions) NewTransaction(transactionID string, repo *gitalypb.Repos
 	t.repoMutex.Unlock()
 }
 
-func (t *Transactions) Start(transactionID string, rollback command.Cmd) {
+func (t *Transactions) Start(transactionID string) {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
@@ -65,19 +66,58 @@ func (t *Transactions) Start(transactionID string, rollback command.Cmd) {
 	}
 
 	t.transactions[transactionID].inProgress = true
-	t.transactions[transactionID].Rollback = rollback
+
+	go func() {
+		<-time.NewTimer(1 * time.Second).C
+		t.txMutex.Lock()
+		tx, ok := t.transactions[transactionID]
+		if !ok {
+			return
+		}
+		if tx.prepared {
+			t.log.WithField("transaction_id", transactionID).Info("transaction has already been prepared")
+			return
+		}
+		t.txMutex.Unlock()
+
+		t.log.WithField("transaction_id", transactionID).Info("transaction has not been prepared and is timing out")
+		t.Unlock(transactionID)
+	}()
+}
+
+func (t *Transactions) PreCommit(transactionID string, c command.Cmd) {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return
+	}
+
+	go tx.PrepareCommitAndWait(c, 2*time.Second)
+}
+
+func (t *Transactions) SetRollback(transactionID string, rollback command.Cmd) {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return
+	}
+
+	tx.Rollback = rollback
 }
 
 func (t *Transactions) Commit(transactionID string) error {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
-	_, ok := t.transactions[transactionID]
+	tx, ok := t.transactions[transactionID]
 	if !ok {
 		return errors.New("request_id not found")
 	}
 
-	t.transactions[transactionID].inProgress = false
+	tx.Commit()
 
 	t.log.WithField("transaction_id", transactionID).Info("commited")
 	return nil
@@ -134,8 +174,26 @@ func (t *Transactions) TransactionStarted(transactionID string) bool {
 	return ok
 }
 
+func (t *Transaction) PrepareCommitAndWait(c command.Cmd, d time.Duration) {
+	t.prepared = true
+
+	select {
+	case <-time.NewTimer(d).C:
+	case <-t.commitCh:
+	}
+
+	t.commitErr = c.Wait()
+	t.inProgress = false
+}
+
+func (t *Transaction) Commit() {
+	close(t.commitCh)
+}
+
 type Transaction struct {
-	Repo       GitRepo
-	Rollback   command.Cmd
-	inProgress bool
+	Repo                 GitRepo
+	Rollback             command.Cmd
+	commitErr            error
+	commitCh             chan struct{}
+	inProgress, prepared bool
 }
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 3319935d2a..99b7d34fa1 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -175,7 +175,7 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 	var errs []error
 	transactionIDs := make(map[string]nodes.Node)
 
-	// PreCommit
+	// Prepare
 	for _, node := range append(secondaries, primary) {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
 		targetRepo := &gitalypb.Repository{
@@ -184,15 +184,15 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		}
 		var trailer metadata.MD
 
+		metadata.AppendToOutgoingContext(ctx, "transaction_step", "prepare")
+
 		if _, err := client.WriteRefTx(ctx, &gitalypb.WriteRefTxRequest{
 			Repository:  targetRepo,
 			Ref:         writeRefReq.Ref,
 			Revision:    writeRefReq.Revision,
 			OldRevision: writeRefReq.OldRevision,
 			Force:       writeRefReq.Force,
-			Transaction: &gitalypb.Transaction{
-				Step: gitalypb.Transaction_PRECOMMIT,
-			}}, grpc.Trailer(&trailer)); err != nil {
+		}, grpc.Trailer(&trailer)); err != nil {
 			errs = append(errs, err)
 		}
 
@@ -204,14 +204,35 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		transactionIDs[transactionID] = node
 	}
 
+	if len(errs) > 0 {
+		return errors.New("votes failed")
+	}
+
+	// PreCommit
+	for _, node := range transactionIDs {
+		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+		targetRepo := &gitalypb.Repository{
+			StorageName:  node.GetStorage(),
+			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+		}
+
+		metadata.AppendToOutgoingContext(ctx, "transaction_step", "precommit")
+		if _, err := client.WriteRefTx(ctx, &gitalypb.WriteRefTxRequest{
+			Repository:  targetRepo,
+			Ref:         writeRefReq.Ref,
+			Revision:    writeRefReq.Revision,
+			OldRevision: writeRefReq.OldRevision,
+			Force:       writeRefReq.Force,
+		}); err != nil {
+			errs = append(errs, err)
+		}
+	}
+
 	// Commit
 	if len(errs) == 0 {
-		for transactionID, node := range transactionIDs {
+		for _, node := range transactionIDs {
 			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{
-				Transaction: &gitalypb.Transaction{
-					Step: gitalypb.Transaction_COMMIT,
-				}}); err != nil {
+			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "commit"), &gitalypb.WriteRefTxRequest{}); err != nil {
 				return err
 			}
 		}
@@ -219,13 +240,14 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		return nil
 	}
 
+	if len(errs) == 0 {
+		return nil
+	}
+
 	// Rollback
-	for transactionID, node := range transactionIDs {
+	for _, node := range transactionIDs {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-		if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{
-			Transaction: &gitalypb.Transaction{
-				Step: gitalypb.Transaction_ROLLBACK,
-			}}); err != nil {
+		if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "rollback"), &gitalypb.WriteRefTxRequest{}); err != nil {
 			return err
 		}
 	}
diff --git a/internal/service/repository/write_ref_tx.go b/internal/service/repository/write_ref_tx.go
index ceaf3560fe..016adac269 100644
--- a/internal/service/repository/write_ref_tx.go
+++ b/internal/service/repository/write_ref_tx.go
@@ -22,20 +22,28 @@ type writeRefRequest interface {
 }
 
 func (s *server) WriteRefTx(ctx context.Context, req *gitalypb.WriteRefTxRequest) (*gitalypb.WriteRefTxResponse, error) {
-	if req.GetTransaction().Step == gitalypb.Transaction_PRECOMMIT {
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return nil, helper.ErrInternal(errors.New("could not get metadata from context"))
+	}
+
+	transactionSteps := md.Get("transaction_step")
+	if len(transactionSteps) == 0 {
+		return nil, nil
+	}
+
+	transactionStep := transactionSteps[len(transactionSteps)-1]
+
+	if transactionStep == "precommit" {
 		if err := validateWriteRefRequest(req); err != nil {
 			return nil, helper.ErrInvalidArgument(err)
 		}
 	}
 
-	if req.Transaction == nil {
-		return nil, helper.ErrInvalidArgument(errors.New("transaction is empty"))
-	}
-
-	return s.transactionalWriteRef(ctx, req)
+	return s.transactionalWriteRef(ctx, req, transactionStep)
 }
 
-func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefTxRequest) (*gitalypb.WriteRefTxResponse, error) {
+func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefTxRequest, transactionStep string) (*gitalypb.WriteRefTxResponse, error) {
 	var resp gitalypb.WriteRefTxResponse
 
 	md, ok := metadata.FromIncomingContext(ctx)
@@ -48,28 +56,31 @@ func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteR
 
 	transactionID := md.Get("transaction_id")[0]
 
-	switch req.Transaction.Step {
-	case gitalypb.Transaction_PRECOMMIT:
-		err := preCommit(ctx, req)
+	switch transactionStep {
+	case "prepare":
+		err := prepare(ctx, req)
 		if err != nil {
 			return nil, err
 		}
 
+		s.transactions.Start(transactionID)
+	case "precommit":
 		rollback, err := rollbackRef(req)
 		if err != nil {
 			return nil, err
 		}
-
-		s.transactions.Start(transactionID, rollback)
-	case gitalypb.Transaction_COMMIT:
-		if err := writeRef(ctx, req); err != nil {
-			return nil, helper.ErrInternal(err)
+		commit, err := preCommit(req)
+		if err != nil {
+			return nil, err
 		}
 
+		s.transactions.SetRollback(transactionID, rollback)
+		s.transactions.PreCommit(transactionID, commit)
+	case "commit":
 		if err := s.transactions.Commit(transactionID); err != nil {
 			return nil, err
 		}
-	case gitalypb.Transaction_ROLLBACK:
+	case "rollback":
 		if err := s.transactions.Rollback(transactionID); err != nil {
 			return nil, err
 		}
@@ -80,7 +91,7 @@ func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteR
 	return &resp, nil
 }
 
-func preCommit(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
+func prepare(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
 	if req.GetOldRevision() == nil {
 		return nil
 	}
@@ -109,8 +120,13 @@ func preCommit(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
 	return nil
 }
 
-func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (*command.Command, error) {
-	return git.SafeCmd(context.Background(), req.GetRepository(), nil, git.SubCmd{Name: "symbolic-ref", Args: []string{string(req.GetRef()), string(req.GetOldRevision())}})
+func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return exec.Command("git", "-C", repoPath, "symoblic-ref", string(req.GetRef()), string(req.GetOldRevision())), nil
 }
 
 func rollbackRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
@@ -135,3 +151,33 @@ func rollbackRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
 
 	return c, nil
 }
+
+func preCommit(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+	if string(req.Ref) == "HEAD" {
+		return preCommitSymbolicRef(req)
+	}
+
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	args := []string{"-C", repoPath, "update-ref", string(req.GetRevision())}
+
+	if req.GetOldRevision() != nil {
+		args = append(args, string(req.GetOldRevision()))
+	}
+
+	c := exec.Command("git", args...)
+
+	return c, nil
+}
+
+func preCommitSymbolicRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return exec.Command("git", "-C", repoPath, "symoblic-ref", string(req.GetRef()), string(req.GetRevision())), nil
+}
diff --git a/proto/repository-service.proto b/proto/repository-service.proto
index 1eb7a4d940..ca3cd91184 100644
--- a/proto/repository-service.proto
+++ b/proto/repository-service.proto
@@ -355,17 +355,9 @@ message WriteRefTxRequest {
     bytes revision = 3;
     bytes old_revision = 4;
     bool force = 5;
-    // This used to be a boolean indicating whether or not to shell out or use
-    // the rugged implementation
-    reserved 6;
-    Transaction transaction = 7;
 }
 
-message WriteRefTxResponse {
-  // This used to contain an error message. Since we're shelling out
-  // all exceptions are wrapped in GRPC errors.
-  Transaction transaction = 1;
-}
+message WriteRefTxResponse {}
 
 message FindMergeBaseRequest {
   Repository repository = 1 [(target_repository)=true];
-- 
GitLab


From fddf14364f47dc2204a710caf5d3020dc95bcce7 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Fri, 28 Feb 2020 14:25:42 -0800
Subject: [PATCH 6/8] modifying rpc so that we send transaction steps through
 header

---
 proto/go/gitalypb/repository-service.pb.go | 390 ++++++++++-----------
 ruby/proto/gitaly/repository-service_pb.rb |   2 -
 2 files changed, 185 insertions(+), 207 deletions(-)

diff --git a/proto/go/gitalypb/repository-service.pb.go b/proto/go/gitalypb/repository-service.pb.go
index b432870f21..2a2c6d6cb2 100644
--- a/proto/go/gitalypb/repository-service.pb.go
+++ b/proto/go/gitalypb/repository-service.pb.go
@@ -1301,15 +1301,14 @@ func (m *WriteRefResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_WriteRefResponse proto.InternalMessageInfo
 
 type WriteRefTxRequest struct {
-	Repository           *Repository  `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	Ref                  []byte       `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
-	Revision             []byte       `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
-	OldRevision          []byte       `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
-	Force                bool         `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
-	Transaction          *Transaction `protobuf:"bytes,7,opt,name=transaction,proto3" json:"transaction,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Ref                  []byte      `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
+	Revision             []byte      `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	OldRevision          []byte      `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
+	Force                bool        `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
 }
 
 func (m *WriteRefTxRequest) Reset()         { *m = WriteRefTxRequest{} }
@@ -1372,20 +1371,10 @@ func (m *WriteRefTxRequest) GetForce() bool {
 	return false
 }
 
-func (m *WriteRefTxRequest) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
 type WriteRefTxResponse struct {
-	// This used to contain an error message. Since we're shelling out
-	// all exceptions are wrapped in GRPC errors.
-	Transaction          *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *WriteRefTxResponse) Reset()         { *m = WriteRefTxResponse{} }
@@ -1413,13 +1402,6 @@ func (m *WriteRefTxResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WriteRefTxResponse proto.InternalMessageInfo
 
-func (m *WriteRefTxResponse) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
 type FindMergeBaseRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	// We use a repeated field because rugged supports finding a base
@@ -3947,194 +3929,192 @@ func init() {
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor_e9b1768cf174c79b) }
 
 var fileDescriptor_e9b1768cf174c79b = []byte{
-	// 2993 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcb, 0x6f, 0x1c, 0xc7,
-	0xd1, 0xd7, 0xf2, 0xb5, 0xbb, 0xc5, 0x95, 0xb4, 0x6c, 0x52, 0xe2, 0x72, 0x24, 0x8a, 0xd2, 0x48,
-	0x96, 0x65, 0x5b, 0xa6, 0x64, 0xe9, 0xfb, 0xf0, 0xf9, 0x4b, 0x10, 0x04, 0x7c, 0x93, 0x7a, 0x90,
-	0xf4, 0x90, 0x8e, 0x61, 0x01, 0xc6, 0x78, 0x76, 0xb6, 0xc9, 0x9d, 0x70, 0x76, 0x7a, 0xd5, 0xd3,
-	0x4b, 0x8a, 0x46, 0x72, 0x48, 0x00, 0x5f, 0x0d, 0x04, 0x08, 0xe2, 0x1c, 0x73, 0xce, 0x5f, 0x90,
-	0x4b, 0x10, 0xe4, 0x92, 0xff, 0xc1, 0x7f, 0x46, 0x90, 0x5b, 0x4e, 0x41, 0x3f, 0x66, 0x7a, 0x9e,
-	0x6b, 0x05, 0x5c, 0x38, 0xc8, 0x6d, 0xba, 0xba, 0xba, 0xaa, 0xba, 0xba, 0xfa, 0x51, 0xbf, 0x1a,
-	0x68, 0x51, 0xdc, 0x27, 0xa1, 0xc7, 0x08, 0x3d, 0xff, 0x30, 0xc4, 0xf4, 0xd4, 0x73, 0xf1, 0x72,
-	0x9f, 0x12, 0x46, 0xd0, 0xd4, 0xb1, 0xc7, 0x1c, 0xff, 0xdc, 0x68, 0x84, 0x5d, 0x87, 0xe2, 0x8e,
-	0xa4, 0x9a, 0x07, 0x30, 0x6f, 0xc5, 0x23, 0x36, 0xde, 0x78, 0x21, 0x0b, 0x2d, 0xfc, 0x7a, 0x80,
-	0x43, 0x86, 0x3e, 0x06, 0xd0, 0xc2, 0x5a, 0x95, 0xdb, 0x95, 0x07, 0xd3, 0x4f, 0xd0, 0xb2, 0x94,
-	0xb2, 0xac, 0x07, 0xad, 0x4e, 0xfc, 0xfe, 0x6f, 0x0f, 0x2b, 0x56, 0x82, 0xd7, 0x7c, 0x02, 0xad,
-	0xbc, 0xd0, 0xb0, 0x4f, 0x82, 0x10, 0xa3, 0xeb, 0x30, 0x85, 0x05, 0x45, 0x48, 0xac, 0x59, 0xaa,
-	0x65, 0x1e, 0x8a, 0x31, 0x8e, 0x7b, 0xb2, 0x13, 0xb8, 0x14, 0xf7, 0x70, 0xc0, 0x1c, 0xff, 0xe2,
-	0x96, 0xdc, 0x80, 0x85, 0x02, 0xa9, 0xd2, 0x14, 0x93, 0xc2, 0x8c, 0xec, 0xdc, 0x1c, 0xf8, 0x17,
-	0xd7, 0x85, 0xee, 0xc2, 0x65, 0x97, 0x62, 0x87, 0x61, 0xbb, 0xed, 0xb1, 0x9e, 0xd3, 0x6f, 0x8d,
-	0x89, 0x09, 0x36, 0x24, 0x71, 0x55, 0xd0, 0xcc, 0x39, 0x40, 0x49, 0x9d, 0xca, 0x92, 0x53, 0xb8,
-	0xb6, 0xe5, 0xd0, 0xb6, 0x73, 0x8c, 0xd7, 0x88, 0xef, 0x63, 0x97, 0xfd, 0x40, 0xd6, 0xb4, 0xe0,
-	0x7a, 0x56, 0xaf, 0xb2, 0xe8, 0x19, 0x5c, 0x59, 0xf3, 0xb1, 0x13, 0x0c, 0xfa, 0x17, 0x5f, 0x84,
-	0x19, 0xb8, 0x1a, 0xcb, 0x52, 0xe2, 0x3f, 0x81, 0x6b, 0x7a, 0xc8, 0x81, 0xf7, 0x15, 0xbe, 0xb8,
-	0x96, 0x87, 0x70, 0x3d, 0x2b, 0x52, 0x85, 0x1c, 0x82, 0x89, 0xd0, 0xfb, 0x0a, 0x0b, 0x69, 0xe3,
-	0x96, 0xf8, 0x36, 0x5f, 0xc3, 0xc2, 0x4a, 0xbf, 0xef, 0x9f, 0x6f, 0x79, 0xcc, 0x61, 0x8c, 0x7a,
-	0xed, 0x01, 0xc3, 0x17, 0x8f, 0x7c, 0x64, 0x40, 0x8d, 0xe2, 0x53, 0x2f, 0xf4, 0x48, 0x20, 0x1c,
-	0xde, 0xb0, 0xe2, 0xb6, 0x79, 0x13, 0x8c, 0x22, 0x95, 0xca, 0x23, 0x7f, 0x19, 0x03, 0xb4, 0x89,
-	0x99, 0xdb, 0xb5, 0x70, 0x8f, 0xb0, 0x8b, 0xfb, 0x83, 0x6f, 0x34, 0x2a, 0x44, 0x09, 0x43, 0xea,
-	0x96, 0x6a, 0xa1, 0x39, 0x98, 0x3c, 0x22, 0xd4, 0xc5, 0xad, 0x71, 0x11, 0x10, 0xb2, 0x81, 0xe6,
-	0xa1, 0x1a, 0x10, 0x9b, 0x39, 0xc7, 0x61, 0x6b, 0x42, 0xee, 0xcb, 0x80, 0x1c, 0x3a, 0xc7, 0x21,
-	0x6a, 0x41, 0x95, 0x79, 0x3d, 0x4c, 0x06, 0xac, 0x35, 0x79, 0xbb, 0xf2, 0x60, 0xd2, 0x8a, 0x9a,
-	0x7c, 0x48, 0x18, 0x76, 0xed, 0x13, 0x7c, 0xde, 0x9a, 0x92, 0x1a, 0xc2, 0xb0, 0xfb, 0x1c, 0x9f,
-	0xa3, 0x25, 0x98, 0x3e, 0x09, 0xc8, 0x59, 0x60, 0x77, 0x09, 0xdf, 0xe7, 0x55, 0xd1, 0x09, 0x82,
-	0xb4, 0xcd, 0x29, 0x68, 0x01, 0x6a, 0x01, 0xb1, 0xfb, 0x74, 0x10, 0xe0, 0x56, 0x5d, 0x68, 0xab,
-	0x06, 0x64, 0x9f, 0x37, 0xd1, 0x53, 0xb8, 0x2c, 0xed, 0xb4, 0xfb, 0x0e, 0x75, 0x7a, 0x61, 0x0b,
-	0xc4, 0x94, 0xaf, 0xe8, 0x29, 0x0b, 0xef, 0x34, 0x24, 0xd3, 0xbe, 0xe0, 0x79, 0x36, 0x51, 0xab,
-	0x35, 0xeb, 0xe6, 0x35, 0x98, 0x4d, 0x39, 0x50, 0x39, 0xf6, 0x00, 0xe6, 0xd7, 0x44, 0xcc, 0x6b,
-	0x6f, 0x5d, 0x3c, 0xd8, 0x0c, 0x68, 0xe5, 0x85, 0x2a, 0x85, 0x5f, 0x8f, 0xc1, 0xcc, 0x16, 0x66,
-	0x2b, 0xd4, 0xed, 0x7a, 0xa7, 0x23, 0x58, 0xc8, 0x1b, 0x50, 0x77, 0x49, 0xaf, 0xe7, 0x31, 0xdb,
-	0xeb, 0xa8, 0xb5, 0xac, 0x49, 0xc2, 0x4e, 0x87, 0xaf, 0x72, 0x9f, 0xe2, 0x23, 0xef, 0x8d, 0x58,
-	0xce, 0xba, 0xa5, 0x5a, 0xe8, 0x63, 0x98, 0x3a, 0x22, 0xb4, 0xe7, 0x30, 0xb1, 0x9c, 0x57, 0x9e,
-	0xdc, 0x8e, 0x54, 0xe5, 0x2c, 0x5b, 0xde, 0x14, 0x7c, 0x96, 0xe2, 0xe7, 0xbb, 0xa5, 0xef, 0xb0,
-	0xae, 0x58, 0xed, 0x86, 0x25, 0xbe, 0xcd, 0xa7, 0x30, 0x25, 0xb9, 0x50, 0x15, 0xc6, 0x5f, 0xed,
-	0xec, 0x37, 0x2f, 0xf1, 0x8f, 0xc3, 0x15, 0xab, 0x59, 0x41, 0x00, 0x53, 0x87, 0x2b, 0x96, 0xbd,
-	0xf5, 0xaa, 0x39, 0x86, 0xa6, 0xa1, 0xca, 0xbf, 0x57, 0x5f, 0x3d, 0x69, 0x8e, 0x9b, 0x0f, 0x00,
-	0x25, 0x95, 0xe9, 0xcd, 0xd8, 0x71, 0x98, 0x23, 0x3c, 0xd0, 0xb0, 0xc4, 0x37, 0x5f, 0xa2, 0x6d,
-	0x27, 0x7c, 0x41, 0x5c, 0xc7, 0x5f, 0xa5, 0x4e, 0xe0, 0x76, 0x47, 0xb0, 0x15, 0xcd, 0xc7, 0xd0,
-	0xca, 0x0b, 0x55, 0x46, 0xcc, 0xc1, 0xe4, 0xa9, 0xe3, 0x0f, 0xb0, 0xba, 0x83, 0x64, 0xc3, 0xfc,
-	0xae, 0x02, 0x2d, 0x11, 0x41, 0x07, 0x64, 0x40, 0x5d, 0x2c, 0x47, 0x5d, 0x7c, 0xfd, 0x7e, 0x0a,
-	0x33, 0xa1, 0x10, 0x68, 0x27, 0x04, 0x8c, 0x95, 0x09, 0xb0, 0x9a, 0x92, 0xd9, 0x4a, 0x1d, 0xe5,
-	0x4a, 0x40, 0x5b, 0x98, 0x24, 0x96, 0xba, 0x61, 0x35, 0xc2, 0x84, 0x99, 0x68, 0x11, 0x80, 0x39,
-	0xf4, 0x18, 0x33, 0x9b, 0xe2, 0x23, 0xb1, 0xe8, 0x0d, 0xab, 0x2e, 0x29, 0x16, 0x3e, 0x32, 0x9f,
-	0xc2, 0x42, 0xc1, 0xd4, 0xf4, 0x9d, 0x4c, 0x71, 0x38, 0xf0, 0x59, 0x74, 0x27, 0xcb, 0x96, 0xb9,
-	0x05, 0xd3, 0x9b, 0xa1, 0x7b, 0x72, 0xf1, 0xb5, 0xb8, 0x07, 0x0d, 0x29, 0x48, 0xfb, 0x1f, 0x53,
-	0x4a, 0xa8, 0x8a, 0x02, 0xd9, 0x30, 0xff, 0x54, 0x81, 0xab, 0x9f, 0x51, 0x8f, 0x6f, 0xaa, 0xa3,
-	0x8b, 0xbb, 0xbd, 0x09, 0xe3, 0xdc, 0x13, 0xf2, 0x14, 0xe6, 0x9f, 0xa9, 0xc3, 0x79, 0x3c, 0x7d,
-	0x38, 0xa3, 0x3b, 0xd0, 0x20, 0x7e, 0xc7, 0x8e, 0xfb, 0xa5, 0x03, 0xa7, 0x89, 0xdf, 0xb1, 0x22,
-	0x96, 0xf8, 0xe0, 0x9c, 0x4c, 0x1c, 0x9c, 0xcf, 0x26, 0x6a, 0x53, 0xcd, 0xaa, 0xd9, 0x82, 0xa6,
-	0xb6, 0x5c, 0x4e, 0xf2, 0xd9, 0x44, 0xad, 0xd2, 0x1c, 0x33, 0xff, 0x5e, 0x81, 0x99, 0xa8, 0xeb,
-	0xf0, 0xcd, 0x7f, 0xcb, 0xb4, 0xd0, 0xff, 0xc2, 0x34, 0xa3, 0x4e, 0x10, 0x3a, 0x2e, 0xe3, 0xe3,
-	0xaa, 0xc2, 0xc2, 0xd9, 0xc8, 0xc2, 0x43, 0xdd, 0x65, 0x25, 0xf9, 0x94, 0x37, 0x9e, 0x03, 0x4a,
-	0x4e, 0x59, 0x2d, 0x7a, 0x46, 0x64, 0xe5, 0xed, 0x44, 0x9a, 0x01, 0xcc, 0x6d, 0x7a, 0x41, 0xe7,
-	0x25, 0xa6, 0xc7, 0x78, 0xd5, 0x09, 0x47, 0x70, 0xa0, 0xde, 0x84, 0x7a, 0xe4, 0x90, 0xb0, 0x35,
-	0x76, 0x7b, 0x9c, 0xef, 0x94, 0x98, 0x60, 0x7e, 0x00, 0xd7, 0x32, 0xfa, 0xf4, 0xc9, 0xd5, 0x76,
-	0x42, 0x79, 0x66, 0xd4, 0x2d, 0xf1, 0x6d, 0x7e, 0x53, 0x81, 0x19, 0x79, 0x11, 0x6c, 0x12, 0x7a,
-	0xf2, 0x9f, 0x3f, 0x2b, 0xf8, 0xfb, 0x32, 0x69, 0x4f, 0xfc, 0xd2, 0x5d, 0xd8, 0x09, 0x2d, 0xcc,
-	0x4d, 0xde, 0x09, 0xf6, 0x29, 0x39, 0xa6, 0x38, 0x0c, 0x47, 0x72, 0x33, 0x51, 0x21, 0x34, 0x71,
-	0x33, 0x49, 0xc2, 0x4e, 0xc7, 0xfc, 0x09, 0x18, 0x45, 0x3a, 0x95, 0x33, 0x97, 0x60, 0xda, 0x0b,
-	0xec, 0xbe, 0x22, 0xab, 0x73, 0x07, 0xbc, 0x98, 0x51, 0x9a, 0x7c, 0xf0, 0x7a, 0xe0, 0x84, 0xdd,
+	// 2961 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0x4b, 0x6f, 0x1c, 0xc7,
+	0xf1, 0xd7, 0xf2, 0xb5, 0xbb, 0xc5, 0x95, 0xb4, 0x6c, 0x52, 0xe2, 0x72, 0x24, 0x8a, 0xd2, 0x48,
+	0x96, 0x65, 0x5b, 0xa6, 0x64, 0xe9, 0x0f, 0xfc, 0x9d, 0x04, 0x41, 0xc0, 0x37, 0xa9, 0x07, 0x49,
+	0x0f, 0xe9, 0x18, 0x16, 0x60, 0x8c, 0x67, 0x67, 0x9b, 0xdc, 0x09, 0x67, 0xa7, 0x57, 0x3d, 0xbd,
+	0xa4, 0x68, 0x24, 0x87, 0x04, 0xf0, 0xd5, 0x40, 0x80, 0x20, 0xce, 0x31, 0xe7, 0x9c, 0x73, 0xc8,
+	0x25, 0x08, 0x72, 0xc9, 0x77, 0xf0, 0xe7, 0xc8, 0x2d, 0xa7, 0xa0, 0x1f, 0x33, 0x3d, 0xcf, 0xb5,
+	0x02, 0x2e, 0x1c, 0xe4, 0x36, 0x5d, 0x5d, 0x5d, 0x55, 0x5d, 0x5d, 0xfd, 0xa8, 0x5f, 0x0d, 0xb4,
+	0x28, 0xee, 0x93, 0xd0, 0x63, 0x84, 0x9e, 0x7f, 0x18, 0x62, 0x7a, 0xea, 0xb9, 0x78, 0xb9, 0x4f,
+	0x09, 0x23, 0x68, 0xea, 0xd8, 0x63, 0x8e, 0x7f, 0x6e, 0x34, 0xc2, 0xae, 0x43, 0x71, 0x47, 0x52,
+	0xcd, 0x03, 0x98, 0xb7, 0xe2, 0x11, 0x1b, 0x6f, 0xbc, 0x90, 0x85, 0x16, 0x7e, 0x3d, 0xc0, 0x21,
+	0x43, 0x1f, 0x03, 0x68, 0x61, 0xad, 0xca, 0xed, 0xca, 0x83, 0xe9, 0x27, 0x68, 0x59, 0x4a, 0x59,
+	0xd6, 0x83, 0x56, 0x27, 0xfe, 0xf0, 0x8f, 0x87, 0x15, 0x2b, 0xc1, 0x6b, 0x3e, 0x81, 0x56, 0x5e,
+	0x68, 0xd8, 0x27, 0x41, 0x88, 0xd1, 0x75, 0x98, 0xc2, 0x82, 0x22, 0x24, 0xd6, 0x2c, 0xd5, 0x32,
+	0x0f, 0xc5, 0x18, 0xc7, 0x3d, 0xd9, 0x09, 0x5c, 0x8a, 0x7b, 0x38, 0x60, 0x8e, 0x7f, 0x71, 0x4b,
+	0x6e, 0xc0, 0x42, 0x81, 0x54, 0x69, 0x8a, 0x49, 0x61, 0x46, 0x76, 0x6e, 0x0e, 0xfc, 0x8b, 0xeb,
+	0x42, 0x77, 0xe1, 0xb2, 0x4b, 0xb1, 0xc3, 0xb0, 0xdd, 0xf6, 0x58, 0xcf, 0xe9, 0xb7, 0xc6, 0xc4,
+	0x04, 0x1b, 0x92, 0xb8, 0x2a, 0x68, 0xe6, 0x1c, 0xa0, 0xa4, 0x4e, 0x65, 0xc9, 0x29, 0x5c, 0xdb,
+	0x72, 0x68, 0xdb, 0x39, 0xc6, 0x6b, 0xc4, 0xf7, 0xb1, 0xcb, 0x7e, 0x20, 0x6b, 0x5a, 0x70, 0x3d,
+	0xab, 0x57, 0x59, 0xf4, 0x0c, 0xae, 0xac, 0xf9, 0xd8, 0x09, 0x06, 0xfd, 0x8b, 0x2f, 0xc2, 0x0c,
+	0x5c, 0x8d, 0x65, 0x29, 0xf1, 0x9f, 0xc0, 0x35, 0x3d, 0xe4, 0xc0, 0xfb, 0x0a, 0x5f, 0x5c, 0xcb,
+	0x43, 0xb8, 0x9e, 0x15, 0xa9, 0x42, 0x0e, 0xc1, 0x44, 0xe8, 0x7d, 0x85, 0x85, 0xb4, 0x71, 0x4b,
+	0x7c, 0x9b, 0xaf, 0x61, 0x61, 0xa5, 0xdf, 0xf7, 0xcf, 0xb7, 0x3c, 0xe6, 0x30, 0x46, 0xbd, 0xf6,
+	0x80, 0xe1, 0x8b, 0x47, 0x3e, 0x32, 0xa0, 0x46, 0xf1, 0xa9, 0x17, 0x7a, 0x24, 0x10, 0x0e, 0x6f,
+	0x58, 0x71, 0xdb, 0xbc, 0x09, 0x46, 0x91, 0x4a, 0xe5, 0x91, 0xbf, 0x8d, 0x01, 0xda, 0xc4, 0xcc,
+	0xed, 0x5a, 0xb8, 0x47, 0xd8, 0xc5, 0xfd, 0xc1, 0x37, 0x1a, 0x15, 0xa2, 0x84, 0x21, 0x75, 0x4b,
+	0xb5, 0xd0, 0x1c, 0x4c, 0x1e, 0x11, 0xea, 0xe2, 0xd6, 0xb8, 0x08, 0x08, 0xd9, 0x40, 0xf3, 0x50,
+	0x0d, 0x88, 0xcd, 0x9c, 0xe3, 0xb0, 0x35, 0x21, 0xf7, 0x65, 0x40, 0x0e, 0x9d, 0xe3, 0x10, 0xb5,
+	0xa0, 0xca, 0xbc, 0x1e, 0x26, 0x03, 0xd6, 0x9a, 0xbc, 0x5d, 0x79, 0x30, 0x69, 0x45, 0x4d, 0x3e,
+	0x24, 0x0c, 0xbb, 0xf6, 0x09, 0x3e, 0x6f, 0x4d, 0x49, 0x0d, 0x61, 0xd8, 0x7d, 0x8e, 0xcf, 0xd1,
+	0x12, 0x4c, 0x9f, 0x04, 0xe4, 0x2c, 0xb0, 0xbb, 0x84, 0xef, 0xf3, 0xaa, 0xe8, 0x04, 0x41, 0xda,
+	0xe6, 0x14, 0xb4, 0x00, 0xb5, 0x80, 0xd8, 0x7d, 0x3a, 0x08, 0x70, 0xab, 0x2e, 0xb4, 0x55, 0x03,
+	0xb2, 0xcf, 0x9b, 0xe8, 0x29, 0x5c, 0x96, 0x76, 0xda, 0x7d, 0x87, 0x3a, 0xbd, 0xb0, 0x05, 0x62,
+	0xca, 0x57, 0xf4, 0x94, 0x85, 0x77, 0x1a, 0x92, 0x69, 0x5f, 0xf0, 0x3c, 0x9b, 0xa8, 0xd5, 0x9a,
+	0x75, 0xf3, 0x1a, 0xcc, 0xa6, 0x1c, 0xa8, 0x1c, 0x7b, 0x00, 0xf3, 0x6b, 0x22, 0xe6, 0xb5, 0xb7,
+	0x2e, 0x1e, 0x6c, 0x06, 0xb4, 0xf2, 0x42, 0x95, 0xc2, 0xaf, 0xc7, 0x60, 0x66, 0x0b, 0xb3, 0x15,
+	0xea, 0x76, 0xbd, 0xd3, 0x11, 0x2c, 0xe4, 0x0d, 0xa8, 0xbb, 0xa4, 0xd7, 0xf3, 0x98, 0xed, 0x75,
+	0xd4, 0x5a, 0xd6, 0x24, 0x61, 0xa7, 0xc3, 0x57, 0xb9, 0x4f, 0xf1, 0x91, 0xf7, 0x46, 0x2c, 0x67,
+	0xdd, 0x52, 0x2d, 0xf4, 0x31, 0x4c, 0x1d, 0x11, 0xda, 0x73, 0x98, 0x58, 0xce, 0x2b, 0x4f, 0x6e,
+	0x47, 0xaa, 0x72, 0x96, 0x2d, 0x6f, 0x0a, 0x3e, 0x4b, 0xf1, 0xf3, 0xdd, 0xd2, 0x77, 0x58, 0x57,
+	0xac, 0x76, 0xc3, 0x12, 0xdf, 0xe6, 0x53, 0x98, 0x92, 0x5c, 0xa8, 0x0a, 0xe3, 0xaf, 0x76, 0xf6,
+	0x9b, 0x97, 0xf8, 0xc7, 0xe1, 0x8a, 0xd5, 0xac, 0x20, 0x80, 0xa9, 0xc3, 0x15, 0xcb, 0xde, 0x7a,
+	0xd5, 0x1c, 0x43, 0xd3, 0x50, 0xe5, 0xdf, 0xab, 0xaf, 0x9e, 0x34, 0xc7, 0xcd, 0x07, 0x80, 0x92,
+	0xca, 0xf4, 0x66, 0xec, 0x38, 0xcc, 0x11, 0x1e, 0x68, 0x58, 0xe2, 0x9b, 0x2f, 0xd1, 0xb6, 0x13,
+	0xbe, 0x20, 0xae, 0xe3, 0xaf, 0x52, 0x27, 0x70, 0xbb, 0x23, 0xd8, 0x8a, 0xe6, 0x63, 0x68, 0xe5,
+	0x85, 0x2a, 0x23, 0xe6, 0x60, 0xf2, 0xd4, 0xf1, 0x07, 0x58, 0xdd, 0x41, 0xb2, 0x61, 0x7e, 0x57,
+	0x81, 0x96, 0x88, 0xa0, 0x03, 0x32, 0xa0, 0x2e, 0x96, 0xa3, 0x2e, 0xbe, 0x7e, 0x3f, 0x83, 0x99,
+	0x50, 0x08, 0xb4, 0x13, 0x02, 0xc6, 0xca, 0x04, 0x58, 0x4d, 0xc9, 0x6c, 0xa5, 0x8e, 0x72, 0x25,
+	0xa0, 0x2d, 0x4c, 0x12, 0x4b, 0xdd, 0xb0, 0x1a, 0x61, 0xc2, 0x4c, 0xb4, 0x08, 0xc0, 0x1c, 0x7a,
+	0x8c, 0x99, 0x4d, 0xf1, 0x91, 0x58, 0xf4, 0x86, 0x55, 0x97, 0x14, 0x0b, 0x1f, 0x99, 0x4f, 0x61,
+	0xa1, 0x60, 0x6a, 0xfa, 0x4e, 0xa6, 0x38, 0x1c, 0xf8, 0x2c, 0xba, 0x93, 0x65, 0xcb, 0xdc, 0x82,
+	0xe9, 0xcd, 0xd0, 0x3d, 0xb9, 0xf8, 0x5a, 0xdc, 0x83, 0x86, 0x14, 0xa4, 0xfd, 0x8f, 0x29, 0x25,
+	0x54, 0x45, 0x81, 0x6c, 0x98, 0x7f, 0xa9, 0xc0, 0xd5, 0xcf, 0xa8, 0xc7, 0x37, 0xd5, 0xd1, 0xc5,
+	0xdd, 0xde, 0x84, 0x71, 0xee, 0x09, 0x79, 0x0a, 0xf3, 0xcf, 0xd4, 0xe1, 0x3c, 0x9e, 0x3e, 0x9c,
+	0xd1, 0x1d, 0x68, 0x10, 0xbf, 0x63, 0xc7, 0xfd, 0xd2, 0x81, 0xd3, 0xc4, 0xef, 0x58, 0x11, 0x4b,
+	0x7c, 0x70, 0x4e, 0x26, 0x0e, 0xce, 0x67, 0x13, 0xb5, 0xa9, 0x66, 0xd5, 0x6c, 0x41, 0x53, 0x5b,
+	0x2e, 0x27, 0xf9, 0x6c, 0xa2, 0x56, 0x69, 0x8e, 0x99, 0x7f, 0xae, 0xc0, 0x4c, 0xd4, 0x75, 0xf8,
+	0xe6, 0x7f, 0x65, 0x5a, 0xfc, 0x9d, 0x92, 0xb4, 0x5a, 0x1d, 0x6d, 0x01, 0xcc, 0x6d, 0x7a, 0x41,
+	0xe7, 0x25, 0xa6, 0xc7, 0x78, 0xd5, 0x09, 0x47, 0x70, 0xb8, 0xdd, 0x84, 0x7a, 0x64, 0x5c, 0xd8,
+	0x1a, 0xbb, 0x3d, 0xce, 0xa3, 0x36, 0x26, 0x98, 0x1f, 0xc0, 0xb5, 0x8c, 0x3e, 0x7d, 0x8a, 0xb4,
+	0x9d, 0x50, 0xee, 0xdf, 0xba, 0x25, 0xbe, 0xcd, 0x6f, 0x2a, 0x30, 0x23, 0x0f, 0xe5, 0x4d, 0x42,
+	0x4f, 0xfe, 0xfb, 0xfb, 0x96, 0xfb, 0x30, 0x69, 0x4f, 0xfc, 0xea, 0x5c, 0xd8, 0x09, 0x2d, 0xcc,
+	0x4d, 0xde, 0x09, 0xf6, 0x29, 0x39, 0xa6, 0x38, 0x0c, 0x47, 0x72, 0x4b, 0x50, 0x21, 0x34, 0x71,
+	0x4b, 0x48, 0xc2, 0x4e, 0xc7, 0xfc, 0x29, 0x18, 0x45, 0x3a, 0x95, 0x33, 0x97, 0x60, 0xda, 0x0b,
+	0xec, 0xbe, 0x22, 0xab, 0x33, 0x00, 0xbc, 0x98, 0x51, 0x9a, 0x7c, 0xf0, 0x7a, 0xe0, 0x84, 0xdd,
 	0x11, 0x9b, 0x1c, 0x0a, 0xa1, 0x09, 0x93, 0x25, 0x21, 0x32, 0x39, 0xaf, 0xf3, 0x6d, 0x4d, 0xf6,
-	0xe1, 0x56, 0xf6, 0x51, 0xb0, 0x49, 0x49, 0xef, 0x53, 0xeb, 0xc5, 0x48, 0xb6, 0xfd, 0x80, 0xfa,
-	0xca, 0x62, 0xfe, 0x69, 0xde, 0x81, 0xa5, 0x52, 0x6d, 0x6a, 0xd9, 0xf7, 0x60, 0x56, 0xb2, 0xac,
-	0x0e, 0x82, 0x8e, 0x3f, 0x82, 0x37, 0xf6, 0xfb, 0x30, 0x97, 0x16, 0x38, 0xe4, 0x52, 0xff, 0x66,
-	0x0c, 0x9a, 0x07, 0x98, 0xad, 0x91, 0xe0, 0xc8, 0x3b, 0xbe, 0xb8, 0x03, 0x3e, 0x86, 0x2a, 0x0e,
-	0x18, 0xf5, 0xb0, 0xdc, 0xb2, 0xd3, 0x4f, 0x6e, 0x45, 0xc3, 0xb2, 0x4a, 0x96, 0x37, 0x02, 0x46,
-	0xcf, 0xad, 0x88, 0xdd, 0xf8, 0xba, 0x02, 0x93, 0x82, 0xc4, 0x9d, 0xc8, 0x5f, 0xab, 0x72, 0x03,
-	0xf3, 0x4f, 0xb4, 0x08, 0x75, 0x71, 0xf7, 0xdb, 0x21, 0xa3, 0xd2, 0xb9, 0xdb, 0x97, 0xac, 0x9a,
-	0x20, 0x1d, 0x30, 0x8a, 0xee, 0xc0, 0xb4, 0xec, 0xf6, 0x02, 0xf6, 0xf4, 0x89, 0x38, 0x5d, 0x27,
-	0xb7, 0x2f, 0x59, 0x20, 0x88, 0x3b, 0x9c, 0x86, 0x96, 0x40, 0xb6, 0xec, 0x36, 0x21, 0xbe, 0x7c,
-	0x3b, 0x6f, 0x5f, 0xb2, 0xa4, 0xd4, 0x55, 0x42, 0xfc, 0xd5, 0xaa, 0x7a, 0x6b, 0x98, 0xb3, 0x30,
-	0x93, 0x30, 0x55, 0x2d, 0x91, 0x0b, 0xb3, 0xeb, 0xd8, 0xc7, 0x0c, 0x8f, 0xca, 0x4f, 0x08, 0x26,
-	0x4e, 0xf0, 0xb9, 0x74, 0x52, 0xdd, 0x12, 0xdf, 0xe6, 0x75, 0x98, 0x4b, 0x2b, 0x51, 0xca, 0x3d,
-	0x9e, 0x1d, 0x87, 0x8c, 0x50, 0xbc, 0x36, 0x08, 0x19, 0xe9, 0x6d, 0x13, 0x72, 0x12, 0x8e, 0xc4,
-	0x04, 0x11, 0x0d, 0x63, 0x89, 0x68, 0xb8, 0x09, 0x46, 0x91, 0x2a, 0x65, 0xc8, 0x21, 0xb4, 0x56,
-	0x1d, 0xf7, 0x64, 0xd0, 0x1f, 0xa5, 0x1d, 0xe6, 0x23, 0x58, 0x28, 0x90, 0x3a, 0x24, 0x64, 0x5f,
-	0xc3, 0x9d, 0xa2, 0x2d, 0x35, 0xa2, 0xdd, 0x53, 0xe8, 0x97, 0x7b, 0x60, 0x0e, 0x53, 0xa9, 0xfc,
-	0xb3, 0x0b, 0x88, 0xdf, 0x49, 0x2f, 0x3c, 0x17, 0x07, 0x23, 0xb8, 0x01, 0xcd, 0x35, 0x98, 0x4d,
-	0xc9, 0x53, 0x3e, 0x79, 0x08, 0xc8, 0x97, 0x24, 0x3b, 0xec, 0x12, 0xca, 0xec, 0xc0, 0xe9, 0x45,
-	0xf7, 0x5d, 0x53, 0xf5, 0x1c, 0xf0, 0x8e, 0x5d, 0xa7, 0x27, 0x16, 0x6d, 0x0b, 0xb3, 0x9d, 0xe0,
-	0x88, 0xac, 0x8c, 0x2e, 0x83, 0x36, 0x7f, 0x0c, 0x0b, 0x05, 0x52, 0x95, 0x81, 0xb7, 0x00, 0x74,
-	0xea, 0xac, 0x96, 0x2e, 0x41, 0xe1, 0x26, 0xad, 0x39, 0xbe, 0x3b, 0xf0, 0x1d, 0x86, 0xd7, 0xba,
-	0xd8, 0x3d, 0x09, 0x07, 0xbd, 0x8b, 0x9b, 0xf4, 0x7f, 0xb0, 0x50, 0x20, 0x55, 0x99, 0x64, 0x40,
-	0xcd, 0x55, 0x34, 0xe5, 0xa9, 0xb8, 0xcd, 0x97, 0x6d, 0x0b, 0xb3, 0x83, 0xc0, 0xe9, 0x87, 0x5d,
-	0x72, 0x71, 0x4c, 0xc7, 0x7c, 0x0f, 0x66, 0x53, 0xf2, 0x86, 0x84, 0xf2, 0xb7, 0x15, 0xb8, 0x5b,
-	0x14, 0x58, 0x23, 0x33, 0x86, 0x27, 0xf1, 0x5d, 0xc6, 0xfa, 0xb6, 0xbe, 0x96, 0xaa, 0xbc, 0xfd,
-	0x29, 0xf5, 0xf9, 0x25, 0x2b, 0xba, 0x9c, 0x01, 0xeb, 0xaa, 0xbc, 0x54, 0xf0, 0xae, 0x0c, 0x58,
-	0xd7, 0xbc, 0x0f, 0xf7, 0x86, 0x1b, 0xa6, 0x62, 0xfe, 0x77, 0x15, 0x98, 0xdb, 0xc2, 0xcc, 0x72,
-	0xce, 0xd6, 0xba, 0x4e, 0x70, 0x3c, 0x0a, 0x74, 0xe6, 0x2e, 0x5c, 0x3e, 0xa2, 0xa4, 0x67, 0xa7,
-	0x20, 0x9a, 0xba, 0xd5, 0xe0, 0xc4, 0xf8, 0x3d, 0xbc, 0x04, 0xd3, 0x8c, 0xd8, 0xa9, 0x17, 0x75,
-	0xdd, 0x02, 0x46, 0x22, 0x06, 0xf3, 0xcf, 0x13, 0x70, 0x2d, 0x63, 0x98, 0x5a, 0x88, 0x6d, 0x98,
-	0xa6, 0xce, 0x99, 0xed, 0x4a, 0x72, 0xab, 0x22, 0xee, 0xa9, 0x77, 0x13, 0x99, 0x77, 0x7e, 0xcc,
-	0x72, 0x4c, 0xb2, 0x80, 0xc6, 0xbd, 0xc6, 0x77, 0xe3, 0x50, 0x8f, 0x7b, 0xd0, 0x3c, 0x54, 0xdb,
-	0x3e, 0x69, 0xf3, 0x27, 0x8b, 0x0c, 0xb1, 0x29, 0xde, 0xdc, 0xe9, 0xc4, 0xc8, 0xd6, 0x98, 0x46,
-	0xb6, 0xd0, 0x22, 0xd4, 0x02, 0x7c, 0x66, 0x8b, 0x1c, 0x5e, 0x18, 0xbf, 0x3a, 0xd6, 0xaa, 0x58,
-	0xd5, 0x00, 0x9f, 0xed, 0x3b, 0x8c, 0xe7, 0x89, 0x35, 0x9e, 0x11, 0x88, 0xee, 0x09, 0xdd, 0x4d,
-	0xfc, 0x8e, 0xe8, 0xde, 0x83, 0x3a, 0xe9, 0x63, 0xea, 0x88, 0x27, 0xfa, 0xa4, 0x80, 0x0e, 0x3e,
+	0xe1, 0x56, 0xf6, 0x82, 0xde, 0xa4, 0xa4, 0xf7, 0xa9, 0xf5, 0x62, 0x24, 0x5b, 0x70, 0x40, 0x7d,
+	0x65, 0x31, 0xff, 0x34, 0xef, 0xc0, 0x52, 0xa9, 0x36, 0xb5, 0xec, 0x7b, 0x30, 0x2b, 0x59, 0x56,
+	0x07, 0x41, 0xc7, 0x1f, 0xc1, 0x7b, 0xf7, 0x7d, 0x98, 0x4b, 0x0b, 0x1c, 0x72, 0xc1, 0x7e, 0x33,
+	0x06, 0xcd, 0x03, 0xcc, 0xd6, 0x48, 0x70, 0xe4, 0x1d, 0x5f, 0xdc, 0x01, 0x1f, 0x43, 0x15, 0x07,
+	0x8c, 0x7a, 0x58, 0x6e, 0xd9, 0xe9, 0x27, 0xb7, 0xa2, 0x61, 0x59, 0x25, 0xcb, 0x1b, 0x01, 0xa3,
+	0xe7, 0x56, 0xc4, 0x6e, 0x7c, 0x5d, 0x81, 0x49, 0x41, 0xe2, 0x4e, 0xe4, 0x2f, 0x47, 0xb9, 0x81,
+	0xf9, 0x27, 0x5a, 0x84, 0xba, 0xb8, 0x87, 0xed, 0x90, 0x51, 0xe9, 0xdc, 0xed, 0x4b, 0x56, 0x4d,
+	0x90, 0x0e, 0x18, 0x45, 0x77, 0x60, 0x5a, 0x76, 0x7b, 0x01, 0x7b, 0xfa, 0x44, 0x9c, 0x74, 0x93,
+	0xdb, 0x97, 0x2c, 0x10, 0xc4, 0x1d, 0x4e, 0x43, 0x4b, 0x20, 0x5b, 0x76, 0x9b, 0x10, 0x5f, 0xbe,
+	0x63, 0xb7, 0x2f, 0x59, 0x52, 0xea, 0x2a, 0x21, 0xfe, 0x6a, 0x55, 0xdd, 0xfb, 0xe6, 0x2c, 0xcc,
+	0x24, 0x4c, 0x55, 0x4b, 0xe4, 0xc2, 0xec, 0x3a, 0xf6, 0x31, 0xc3, 0xa3, 0xf2, 0x13, 0x82, 0x89,
+	0x13, 0x7c, 0x2e, 0x9d, 0x54, 0xb7, 0xc4, 0xb7, 0x79, 0x1d, 0xe6, 0xd2, 0x4a, 0x94, 0x72, 0x8f,
+	0x67, 0xaa, 0x21, 0x23, 0x14, 0xaf, 0x0d, 0x42, 0x46, 0x7a, 0xdb, 0x84, 0x9c, 0x84, 0x23, 0x31,
+	0x41, 0x44, 0xc3, 0x58, 0x22, 0x1a, 0x6e, 0x82, 0x51, 0xa4, 0x4a, 0x19, 0x72, 0x08, 0xad, 0x55,
+	0xc7, 0x3d, 0x19, 0xf4, 0x47, 0x69, 0x87, 0xf9, 0x08, 0x16, 0x0a, 0xa4, 0x0e, 0x09, 0xd9, 0xd7,
+	0x70, 0xa7, 0x68, 0x4b, 0x8d, 0x68, 0xf7, 0x14, 0xfa, 0xe5, 0x1e, 0x98, 0xc3, 0x54, 0x2a, 0xff,
+	0xec, 0x02, 0xe2, 0x77, 0xd2, 0x0b, 0xcf, 0xc5, 0xc1, 0x08, 0x6e, 0x40, 0x73, 0x0d, 0x66, 0x53,
+	0xf2, 0x94, 0x4f, 0x1e, 0x02, 0xf2, 0x25, 0xc9, 0x0e, 0xbb, 0x84, 0x32, 0x3b, 0x70, 0x7a, 0xd1,
+	0x7d, 0xd7, 0x54, 0x3d, 0x07, 0xbc, 0x63, 0xd7, 0xe9, 0x89, 0x45, 0xdb, 0xc2, 0x6c, 0x27, 0x38,
+	0x22, 0x2b, 0xa3, 0xcb, 0x66, 0xcd, 0x9f, 0xc0, 0x42, 0x81, 0x54, 0x65, 0xe0, 0x2d, 0x00, 0x9d,
+	0xc6, 0xaa, 0xa5, 0x4b, 0x50, 0xb8, 0x49, 0x6b, 0x8e, 0xef, 0x0e, 0x7c, 0x87, 0xe1, 0xb5, 0x2e,
+	0x76, 0x4f, 0xc2, 0x41, 0xef, 0xe2, 0x26, 0xfd, 0x3f, 0x2c, 0x14, 0x48, 0x55, 0x26, 0x19, 0x50,
+	0x73, 0x15, 0x4d, 0x79, 0x2a, 0x6e, 0xf3, 0x65, 0xdb, 0xc2, 0xec, 0x20, 0x70, 0xfa, 0x61, 0x97,
+	0x5c, 0x1c, 0x5f, 0x31, 0xdf, 0x83, 0xd9, 0x94, 0xbc, 0x21, 0xa1, 0xfc, 0x6d, 0x05, 0xee, 0x16,
+	0x05, 0xd6, 0xc8, 0x8c, 0xe1, 0x09, 0x75, 0x97, 0xb1, 0xbe, 0xad, 0xaf, 0xa5, 0x2a, 0x6f, 0x7f,
+	0x4a, 0x7d, 0x7e, 0xc9, 0x8a, 0x2e, 0x67, 0xc0, 0xba, 0x2a, 0x47, 0x14, 0xbc, 0x2b, 0x03, 0xd6,
+	0x35, 0xef, 0xc3, 0xbd, 0xe1, 0x86, 0xa9, 0x98, 0xff, 0x7d, 0x05, 0xe6, 0xb6, 0x30, 0xb3, 0x9c,
+	0xb3, 0xb5, 0xae, 0x13, 0x1c, 0x8f, 0x02, 0x29, 0xb9, 0x0b, 0x97, 0x8f, 0x28, 0xe9, 0xd9, 0x29,
+	0xb8, 0xa4, 0x6e, 0x35, 0x38, 0x31, 0x7e, 0x9b, 0x2e, 0xc1, 0x34, 0x23, 0x76, 0xea, 0x75, 0x5b,
+	0xb7, 0x80, 0x91, 0x88, 0xc1, 0xfc, 0xeb, 0x04, 0x5c, 0xcb, 0x18, 0xa6, 0x16, 0x62, 0x1b, 0xa6,
+	0xa9, 0x73, 0x66, 0xbb, 0x92, 0xdc, 0xaa, 0x88, 0x7b, 0xea, 0xdd, 0x44, 0x16, 0x9c, 0x1f, 0xb3,
+	0x1c, 0x93, 0x2c, 0xa0, 0x71, 0xaf, 0xf1, 0xdd, 0x38, 0xd4, 0xe3, 0x1e, 0x34, 0x0f, 0xd5, 0xb6,
+	0x4f, 0xda, 0xfc, 0xc9, 0x22, 0x43, 0x6c, 0x8a, 0x37, 0x77, 0x3a, 0x31, 0xca, 0x34, 0xa6, 0x51,
+	0x26, 0xb4, 0x08, 0xb5, 0x00, 0x9f, 0xd9, 0x22, 0x9f, 0x16, 0xc6, 0xaf, 0x8e, 0xb5, 0x2a, 0x56,
+	0x35, 0xc0, 0x67, 0xfb, 0x0e, 0xe3, 0x39, 0x5b, 0x8d, 0xbf, 0xce, 0x45, 0xf7, 0x84, 0xee, 0x26,
+	0x7e, 0x47, 0x74, 0xef, 0x41, 0x9d, 0xf4, 0x31, 0x75, 0x18, 0x9f, 0xfb, 0xa4, 0x48, 0xe3, 0x3f,
 	0x7a, 0xcb, 0x09, 0x2c, 0xef, 0x45, 0x03, 0x2d, 0x2d, 0x83, 0xfb, 0x9c, 0xfb, 0x44, 0x0b, 0x95,
-	0x58, 0x51, 0x83, 0x3a, 0x67, 0x31, 0x3f, 0x8f, 0x25, 0x6e, 0x54, 0x8f, 0x74, 0xb0, 0x48, 0x35,
-	0x26, 0x85, 0x41, 0x2f, 0x49, 0x07, 0x0b, 0xac, 0x08, 0x9f, 0xc9, 0xae, 0x9a, 0xec, 0x0a, 0xf0,
-	0x99, 0xe8, 0xba, 0x07, 0x57, 0xa2, 0x99, 0xda, 0xed, 0x73, 0x7e, 0x22, 0xd4, 0x65, 0x62, 0xac,
+	0xb8, 0x4d, 0x83, 0x3a, 0x67, 0x31, 0x3f, 0x8f, 0x25, 0x6e, 0x54, 0x8f, 0x74, 0xb0, 0x80, 0x6e,
+	0x26, 0x85, 0x41, 0x2f, 0x49, 0x07, 0x0b, 0xdc, 0x06, 0x9f, 0xc9, 0xae, 0x9a, 0xec, 0x0a, 0xf0,
+	0x99, 0xe8, 0xba, 0x07, 0x57, 0xa2, 0x99, 0xda, 0xed, 0x73, 0x7e, 0x22, 0xd4, 0x65, 0x92, 0xaa,
 	0xe6, 0xba, 0xca, 0x69, 0x9c, 0x2b, 0x9a, 0xb0, 0xe2, 0x02, 0xc9, 0xa5, 0xa6, 0x2c, 0xb8, 0x4c,
 	0x0f, 0xea, 0xda, 0x9c, 0x69, 0xa8, 0x7e, 0xba, 0xfb, 0x7c, 0x77, 0xef, 0xb3, 0xdd, 0xe6, 0x25,
-	0x54, 0x87, 0xc9, 0x95, 0xf5, 0xf5, 0x8d, 0x75, 0x09, 0x75, 0xac, 0xed, 0xed, 0xef, 0x6c, 0xac,
-	0x4b, 0xa8, 0x63, 0x7d, 0xe3, 0xc5, 0xc6, 0xe1, 0xc6, 0x7a, 0x73, 0x1c, 0x35, 0xa0, 0xf6, 0x72,
+	0x54, 0x87, 0xc9, 0x95, 0xf5, 0xf5, 0x8d, 0x75, 0x09, 0x3b, 0xac, 0xed, 0xed, 0xef, 0x6c, 0xac,
+	0x4b, 0xd8, 0x61, 0x7d, 0xe3, 0xc5, 0xc6, 0xe1, 0xc6, 0x7a, 0x73, 0x1c, 0x35, 0xa0, 0xf6, 0x72,
 	0x6f, 0x7d, 0x67, 0x93, 0x77, 0x4d, 0xf0, 0x2e, 0x6b, 0x63, 0x77, 0xe5, 0xe5, 0xc6, 0x7a, 0x73,
 	0x12, 0x35, 0xa1, 0x71, 0xf8, 0xf9, 0xfe, 0x86, 0xbd, 0xb6, 0xbd, 0xb2, 0xbb, 0xb5, 0xb1, 0xde,
-	0x9c, 0x32, 0x7f, 0x01, 0xad, 0x03, 0xec, 0x50, 0xb7, 0xbb, 0xe9, 0xf9, 0x38, 0x5c, 0x3d, 0xe7,
+	0x9c, 0x32, 0x7f, 0x09, 0xad, 0x03, 0xec, 0x50, 0xb7, 0xbb, 0xe9, 0xf9, 0x38, 0x5c, 0x3d, 0xe7,
 	0x87, 0xe9, 0xc5, 0x63, 0x7b, 0x0e, 0x26, 0x5f, 0x0f, 0xb0, 0xca, 0x16, 0xea, 0x96, 0x6c, 0x44,
-	0xd9, 0xe2, 0x78, 0x9c, 0x2d, 0x9a, 0x1f, 0xc1, 0x42, 0x81, 0x76, 0x9d, 0x97, 0x1f, 0x71, 0xb2,
-	0x08, 0xdd, 0x86, 0x25, 0x1b, 0xe6, 0x1f, 0x2b, 0x70, 0x23, 0x35, 0x66, 0x8d, 0x04, 0x0c, 0x07,
-	0xec, 0x07, 0x33, 0x1a, 0xbd, 0x07, 0x4d, 0xb7, 0x3b, 0x08, 0x4e, 0x30, 0x4f, 0x65, 0xa5, 0xad,
-	0x0a, 0xa6, 0xbc, 0xaa, 0xe8, 0xf1, 0xb1, 0x71, 0x0e, 0x37, 0x8b, 0x6d, 0x55, 0x53, 0x6c, 0x41,
+	0x99, 0xdb, 0x78, 0x9c, 0xb9, 0x99, 0x1f, 0xc1, 0x42, 0x81, 0x76, 0x9d, 0x23, 0x1f, 0x71, 0xb2,
+	0x08, 0xdd, 0x86, 0x25, 0x1b, 0xe6, 0x9f, 0x2a, 0x70, 0x23, 0x35, 0x66, 0x8d, 0x04, 0x0c, 0x07,
+	0xec, 0x07, 0x33, 0x1a, 0xbd, 0x07, 0x4d, 0xb7, 0x3b, 0x08, 0x4e, 0x30, 0x4f, 0x2b, 0xa5, 0xad,
+	0x0a, 0x32, 0xbc, 0xaa, 0xe8, 0xf1, 0xb1, 0x71, 0x0e, 0x37, 0x8b, 0x6d, 0x55, 0x53, 0x6c, 0x41,
 	0xb5, 0xe7, 0x30, 0xb7, 0x1b, 0x4f, 0x32, 0x6a, 0xa2, 0x45, 0x00, 0xf1, 0x69, 0x27, 0x2e, 0xe9,
 	0xba, 0xa0, 0xac, 0x3b, 0xcc, 0x41, 0xb7, 0xa1, 0x81, 0x83, 0x8e, 0x4d, 0x8e, 0x6c, 0x41, 0x53,
-	0xf0, 0x29, 0xe0, 0xa0, 0xb3, 0x77, 0xf4, 0x92, 0x53, 0xcc, 0xdf, 0x54, 0x60, 0x4a, 0x82, 0x8f,
+	0x50, 0x26, 0xe0, 0xa0, 0xb3, 0x77, 0xf4, 0x92, 0x53, 0xcc, 0xdf, 0x56, 0x60, 0x4a, 0x02, 0x81,
 	0xd1, 0x73, 0xbd, 0x12, 0x3f, 0xd7, 0xf9, 0x56, 0x15, 0xb7, 0xa9, 0x9c, 0xa9, 0xf8, 0x46, 0x3f,
-	0x82, 0x85, 0xf8, 0x9c, 0x24, 0xd4, 0xfb, 0x4a, 0x44, 0x9f, 0xdd, 0xc5, 0x4e, 0x07, 0x53, 0x75,
+	0x86, 0x85, 0xf8, 0x9c, 0x24, 0xd4, 0xfb, 0x4a, 0x44, 0x9f, 0xdd, 0xc5, 0x4e, 0x07, 0x53, 0x75,
 	0xf0, 0xcc, 0x47, 0xe7, 0x66, 0xdc, 0xbf, 0x2d, 0xba, 0xd1, 0x3b, 0x70, 0xa5, 0xe7, 0x51, 0x4a,
 	0xa8, 0x4d, 0xf1, 0x51, 0xcf, 0xe9, 0x87, 0xad, 0x09, 0xf1, 0xe2, 0xbb, 0x2c, 0xa9, 0x96, 0x24,
-	0x9a, 0xbf, 0xad, 0xc0, 0x75, 0x01, 0xfc, 0x6c, 0x1f, 0x1e, 0xee, 0x8f, 0x0a, 0x5a, 0xbe, 0x9f,
-	0x82, 0x96, 0xf3, 0xe8, 0x6c, 0x04, 0x35, 0x27, 0xb0, 0xe3, 0xf1, 0x14, 0x76, 0x6c, 0x2e, 0xc0,
-	0x7c, 0xce, 0x2a, 0xb5, 0x80, 0x9f, 0xc3, 0xe2, 0x16, 0x66, 0x7b, 0xed, 0x9f, 0x63, 0x97, 0xad,
-	0x7b, 0x14, 0xbb, 0xa3, 0x2b, 0x11, 0xfc, 0x0f, 0xdc, 0x2a, 0x13, 0x3d, 0xa4, 0x54, 0xf0, 0x87,
-	0x0a, 0xcc, 0xad, 0xf9, 0x24, 0xc0, 0xfc, 0x9a, 0xda, 0x27, 0xc4, 0x1f, 0x85, 0x03, 0x27, 0xfa,
-	0x3c, 0x5d, 0xc8, 0x64, 0xf6, 0xd2, 0x32, 0xa1, 0x42, 0xf4, 0x27, 0x1c, 0x3d, 0x3e, 0xcc, 0xd1,
-	0xe6, 0x3c, 0x5c, 0xcb, 0x58, 0xa8, 0x9c, 0xf9, 0xd7, 0x0a, 0xdc, 0x4c, 0xf5, 0xec, 0x04, 0x0c,
-	0xd3, 0xc0, 0xf9, 0x01, 0xe7, 0x50, 0x08, 0x69, 0x8c, 0xff, 0x1b, 0x90, 0xc6, 0x12, 0x2c, 0x96,
-	0x4c, 0x41, 0x23, 0xfc, 0xdc, 0x1f, 0xa7, 0xa3, 0x46, 0xf8, 0xf3, 0x42, 0x95, 0xc2, 0x37, 0x5c,
-	0x61, 0x20, 0x0e, 0xce, 0x91, 0x29, 0x14, 0x17, 0x25, 0xf6, 0x1d, 0xe6, 0x9d, 0x62, 0x79, 0x3b,
-	0xab, 0xc7, 0x49, 0x44, 0xe4, 0x77, 0x95, 0xb4, 0x2a, 0xab, 0x59, 0x59, 0xf5, 0xeb, 0x0a, 0xcf,
-	0xb1, 0xfa, 0xbe, 0xe7, 0x8e, 0xb6, 0xd8, 0x81, 0xde, 0x87, 0x29, 0xb9, 0x28, 0x43, 0x90, 0x28,
-	0xc5, 0x61, 0x2e, 0xc2, 0x8d, 0x42, 0x1b, 0xa4, 0x8d, 0x4f, 0xfe, 0xb1, 0x28, 0x6a, 0xae, 0x51,
-	0x95, 0x4e, 0x16, 0xa8, 0xd1, 0x17, 0xd0, 0xcc, 0xd6, 0x8b, 0xd1, 0x52, 0x5e, 0x49, 0xaa, 0x3c,
-	0x6d, 0xdc, 0x2e, 0x67, 0x50, 0x0e, 0x99, 0xfa, 0xe7, 0xb7, 0x0f, 0xc6, 0x6a, 0x63, 0xe8, 0xcb,
-	0xa8, 0xce, 0x9b, 0x28, 0x02, 0xa3, 0xe4, 0xf0, 0xc2, 0xaa, 0xb3, 0x71, 0x67, 0x08, 0x47, 0x4a,
-	0x43, 0x05, 0x3d, 0x07, 0xd0, 0x55, 0x5d, 0xb4, 0x90, 0x1e, 0x98, 0xa8, 0x2e, 0x1b, 0x46, 0x51,
-	0x57, 0x46, 0xd8, 0x67, 0x70, 0x25, 0x5d, 0x94, 0x45, 0x8b, 0xf1, 0x0b, 0xac, 0xa8, 0x48, 0x6c,
-	0xdc, 0x2a, 0xeb, 0xce, 0x0b, 0x4e, 0x57, 0x48, 0xb5, 0xe0, 0xc2, 0x62, 0xac, 0x16, 0x5c, 0x5c,
-	0x58, 0x8d, 0x05, 0xbb, 0x80, 0xf2, 0x95, 0x4d, 0x14, 0xfb, 0xaf, 0xb4, 0xd0, 0x6a, 0x98, 0xc3,
-	0x58, 0x32, 0x4a, 0x76, 0x61, 0x3a, 0x51, 0xde, 0x43, 0xb1, 0x27, 0xf3, 0x45, 0x53, 0xe3, 0x46,
-	0x61, 0x5f, 0x46, 0xde, 0x17, 0xd0, 0xcc, 0xe6, 0x21, 0x3a, 0xe8, 0x4a, 0x2a, 0x86, 0x3a, 0xe8,
-	0x4a, 0xab, 0x7f, 0x91, 0xf8, 0x97, 0x00, 0xba, 0xfa, 0xa5, 0x43, 0x22, 0x57, 0x7e, 0xd3, 0x21,
-	0x91, 0x2f, 0x96, 0x45, 0xc2, 0x1e, 0x0b, 0x6b, 0xb3, 0xd5, 0x2c, 0x6d, 0x6d, 0x49, 0xf1, 0x4c,
-	0x5b, 0x5b, 0x56, 0x08, 0x4b, 0x6e, 0x91, 0x5c, 0x79, 0x48, 0x6f, 0x91, 0xb2, 0xa2, 0x98, 0xde,
-	0x22, 0xa5, 0xb5, 0xa5, 0xd8, 0x1f, 0xff, 0x0f, 0x13, 0x9b, 0xa1, 0x7b, 0x82, 0x62, 0xc0, 0x3f,
-	0x51, 0x59, 0x32, 0xe6, 0xd2, 0xc4, 0xcc, 0xd0, 0x0d, 0xa8, 0x45, 0xe5, 0x04, 0x34, 0x1f, 0x71,
-	0x66, 0x0a, 0x45, 0x46, 0x2b, 0xdf, 0x91, 0xdf, 0xa4, 0xba, 0x2a, 0xa1, 0x57, 0x24, 0x57, 0x9c,
-	0xd1, 0x2b, 0x92, 0x2f, 0x62, 0xc4, 0xc2, 0x0e, 0xe1, 0x72, 0xaa, 0x4a, 0x80, 0x6e, 0xc6, 0x53,
-	0x28, 0x28, 0x56, 0x18, 0x8b, 0x25, 0xbd, 0x99, 0x65, 0x78, 0x0e, 0xa0, 0xd1, 0x7b, 0x6d, 0x62,
-	0xae, 0xc2, 0xa0, 0x4d, 0x2c, 0x00, 0xfb, 0x13, 0xbb, 0x32, 0x0f, 0xc0, 0xeb, 0x5d, 0x59, 0x5a,
-	0x10, 0xd0, 0xbb, 0xb2, 0x1c, 0xbf, 0x8f, 0x2d, 0x16, 0x4a, 0xb2, 0x90, 0x79, 0x52, 0x49, 0x09,
-	0x84, 0x9f, 0x54, 0x52, 0x86, 0xb8, 0xc7, 0x4a, 0x68, 0xbe, 0x84, 0xaf, 0xa0, 0x6e, 0x74, 0xbf,
-	0x6c, 0x43, 0xa6, 0x91, 0x77, 0xe3, 0xdd, 0xef, 0xe5, 0xcb, 0x78, 0xef, 0x00, 0x1a, 0x49, 0xa8,
-	0x1b, 0xdd, 0x48, 0x0b, 0x48, 0x61, 0x82, 0xc6, 0xcd, 0xe2, 0xce, 0xf4, 0x34, 0x1e, 0x57, 0xd0,
-	0x2f, 0xc1, 0x28, 0x47, 0xfb, 0xd0, 0x7b, 0xc3, 0x6c, 0x4c, 0x2b, 0x7c, 0xff, 0x6d, 0x58, 0xd3,
-	0x33, 0x7a, 0x50, 0x41, 0xdb, 0x50, 0x8f, 0x11, 0x68, 0xd4, 0x2a, 0xc3, 0xcf, 0x8d, 0x85, 0x82,
-	0x9e, 0x8c, 0x77, 0x3e, 0x81, 0x46, 0x12, 0x51, 0xd6, 0xde, 0x29, 0x00, 0xb3, 0xb5, 0x77, 0x0a,
-	0x41, 0xe8, 0xe4, 0xf9, 0xae, 0x31, 0xc9, 0xc4, 0xf9, 0x9e, 0x03, 0x3e, 0x13, 0xe7, 0x7b, 0x1e,
-	0xc4, 0x8c, 0x83, 0xa6, 0x2d, 0xfe, 0xc2, 0x48, 0x03, 0x89, 0x28, 0xf9, 0x1b, 0x44, 0x21, 0x72,
-	0xa9, 0x8f, 0xb4, 0x52, 0x14, 0x32, 0xb1, 0x9e, 0x5f, 0xc2, 0x4c, 0x0e, 0x19, 0xd4, 0x3a, 0xca,
-	0xa0, 0x48, 0xad, 0xa3, 0x14, 0x56, 0x8c, 0x67, 0xb1, 0x0a, 0x55, 0xf5, 0xef, 0x14, 0xba, 0x1e,
-	0x8f, 0x4a, 0xfd, 0x98, 0x65, 0xcc, 0xe7, 0xe8, 0x19, 0xcf, 0xee, 0xc3, 0x74, 0x02, 0x36, 0x44,
-	0xc9, 0x0b, 0x27, 0x03, 0x07, 0x6a, 0xcf, 0x16, 0xe0, 0x8c, 0x89, 0x79, 0xff, 0x8a, 0xa7, 0x15,
-	0x43, 0x40, 0x3c, 0xf4, 0xc1, 0xb0, 0xf8, 0xcc, 0x2a, 0x7d, 0xf8, 0x76, 0xcc, 0x99, 0x59, 0xfd,
-	0x0c, 0x2e, 0xa7, 0x00, 0x29, 0x7d, 0x02, 0x17, 0xa1, 0x86, 0xfa, 0x04, 0x2e, 0x44, 0xb1, 0x12,
-	0x73, 0x3b, 0x81, 0xb9, 0x22, 0x00, 0x01, 0xdd, 0xd5, 0xbb, 0xa2, 0x14, 0x0a, 0x31, 0xee, 0x0d,
-	0x67, 0xca, 0x29, 0x6b, 0xc3, 0x4c, 0x0e, 0x8d, 0xd1, 0x01, 0x54, 0x06, 0x13, 0xe9, 0x00, 0x2a,
-	0x85, 0x72, 0x12, 0x3a, 0x30, 0xa0, 0x7c, 0xe9, 0x05, 0x25, 0x5e, 0xb7, 0x25, 0x15, 0x20, 0x7d,
-	0x44, 0x0f, 0xa9, 0xdc, 0xe8, 0xc3, 0xa5, 0x0d, 0x33, 0xb9, 0x6a, 0x8b, 0x9e, 0x4a, 0x59, 0x79,
-	0x47, 0x4f, 0xa5, 0xb4, 0x54, 0x93, 0x98, 0xca, 0x2b, 0xb8, 0x9a, 0x81, 0x0d, 0xd0, 0xad, 0xd4,
-	0x13, 0x24, 0x87, 0x72, 0x18, 0x4b, 0xa5, 0xfd, 0x99, 0x78, 0x22, 0x70, 0xbd, 0x18, 0x1c, 0x40,
-	0xef, 0x24, 0x42, 0xa7, 0x1c, 0x97, 0x30, 0xee, 0x7f, 0x1f, 0x5b, 0x66, 0x6b, 0x1f, 0xc2, 0xe5,
-	0x54, 0x5e, 0xab, 0x03, 0xb8, 0x08, 0x6d, 0xd0, 0x01, 0x5c, 0x9c, 0xe9, 0x47, 0xd3, 0xf0, 0x33,
-	0x50, 0x40, 0x94, 0x2d, 0xa3, 0x7b, 0x85, 0xe3, 0x33, 0x78, 0x80, 0xf1, 0xce, 0xf7, 0x70, 0xe5,
-	0x1f, 0xd1, 0xd9, 0x2c, 0x39, 0x99, 0xb9, 0x15, 0x26, 0xe5, 0xc9, 0xcc, 0xad, 0x24, 0xc1, 0x4e,
-	0x89, 0x4f, 0xa7, 0xbb, 0x49, 0xf1, 0x85, 0x29, 0x78, 0x52, 0x7c, 0x49, 0xa6, 0x1c, 0x89, 0x3f,
-	0x82, 0xd9, 0x82, 0x64, 0x15, 0x25, 0xe2, 0xbe, 0x2c, 0x9b, 0x36, 0xee, 0x0e, 0xe5, 0x49, 0xeb,
-	0x59, 0x7d, 0xfc, 0x8a, 0x73, 0xfb, 0x4e, 0x7b, 0xd9, 0x25, 0xbd, 0x47, 0xf2, 0xf3, 0x43, 0x42,
-	0x8f, 0x1f, 0x49, 0x19, 0x8f, 0xc4, 0xaf, 0xd8, 0x8f, 0x8e, 0x89, 0x6a, 0xf7, 0xdb, 0xed, 0x29,
-	0x41, 0x7a, 0xfa, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf2, 0xbb, 0xb2, 0xb1, 0xcf, 0x2d, 0x00,
+	0x9a, 0xbf, 0xab, 0xc0, 0x75, 0x01, 0xc2, 0x6c, 0x1f, 0x1e, 0xee, 0x8f, 0x0a, 0xe6, 0xbd, 0x9f,
+	0x82, 0x79, 0xf3, 0x48, 0x69, 0x04, 0xfb, 0x26, 0x70, 0xdc, 0xf1, 0x14, 0x8e, 0x6b, 0x2e, 0xc0,
+	0x7c, 0xce, 0x2a, 0xb5, 0x80, 0x9f, 0xc3, 0xe2, 0x16, 0x66, 0x7b, 0xed, 0x5f, 0x60, 0x97, 0xad,
+	0x7b, 0x14, 0xbb, 0xa3, 0x83, 0xeb, 0xff, 0x0f, 0x6e, 0x95, 0x89, 0x1e, 0x02, 0xdb, 0xff, 0xb1,
+	0x02, 0x73, 0x6b, 0x3e, 0x09, 0x30, 0xbf, 0xa6, 0xf6, 0x09, 0xf1, 0x47, 0xe1, 0xc0, 0x89, 0x3e,
+	0x4f, 0x17, 0x32, 0x99, 0xbd, 0xb4, 0x4c, 0xa8, 0x10, 0xfd, 0x09, 0x47, 0x8f, 0x0f, 0x73, 0xb4,
+	0x39, 0x0f, 0xd7, 0x32, 0x16, 0x2a, 0x67, 0xfe, 0xbd, 0x02, 0x37, 0x53, 0x3d, 0x3b, 0x01, 0xc3,
+	0x34, 0x70, 0x7e, 0xc0, 0x39, 0x14, 0x42, 0x1a, 0xe3, 0xff, 0x01, 0xa4, 0xb1, 0x04, 0x8b, 0x25,
+	0x53, 0xd0, 0x68, 0x3b, 0xf7, 0xc7, 0xe9, 0xa8, 0xd1, 0xf6, 0xbc, 0x50, 0xa5, 0xf0, 0x0d, 0x57,
+	0x18, 0x88, 0x83, 0x73, 0x64, 0x0a, 0xc5, 0x45, 0x89, 0x7d, 0x87, 0x79, 0xa7, 0x58, 0xde, 0xce,
+	0xea, 0x71, 0x12, 0x11, 0xf9, 0x5d, 0x25, 0xad, 0xca, 0x6a, 0x56, 0x56, 0xfd, 0xa6, 0xc2, 0x73,
+	0xac, 0xbe, 0xef, 0xb9, 0xa3, 0x2d, 0x3c, 0xa0, 0xf7, 0x61, 0x4a, 0x2e, 0xca, 0x10, 0x24, 0x4a,
+	0x71, 0x98, 0x8b, 0x70, 0xa3, 0xd0, 0x06, 0x69, 0xe3, 0x93, 0x7f, 0x2e, 0x8a, 0xfa, 0x67, 0x54,
+	0x31, 0x93, 0xc5, 0x62, 0xf4, 0x05, 0x34, 0xb3, 0xb5, 0x5b, 0xb4, 0x94, 0x57, 0x92, 0x2a, 0x15,
+	0x1b, 0xb7, 0xcb, 0x19, 0x94, 0x43, 0xa6, 0xfe, 0xf5, 0xed, 0x83, 0xb1, 0xda, 0x18, 0xfa, 0x32,
+	0xaa, 0xb9, 0x26, 0x0a, 0xb2, 0x28, 0x39, 0xbc, 0xb0, 0x02, 0x6c, 0xdc, 0x19, 0xc2, 0x91, 0xd2,
+	0x50, 0x41, 0xcf, 0x01, 0x74, 0x85, 0x15, 0x2d, 0xa4, 0x07, 0x26, 0x2a, 0xbd, 0x86, 0x51, 0xd4,
+	0x95, 0x11, 0xf6, 0x19, 0x5c, 0x49, 0x17, 0x48, 0xd1, 0x62, 0xfc, 0x02, 0x2b, 0x2a, 0xd8, 0x1a,
+	0xb7, 0xca, 0xba, 0xf3, 0x82, 0xd3, 0xd5, 0x4a, 0x2d, 0xb8, 0xb0, 0x30, 0xaa, 0x05, 0x17, 0x17,
+	0x39, 0x63, 0xc1, 0x2e, 0xa0, 0x7c, 0x95, 0x11, 0xc5, 0xfe, 0x2b, 0x2d, 0x7a, 0x1a, 0xe6, 0x30,
+	0x96, 0x8c, 0x92, 0x5d, 0x98, 0x4e, 0x94, 0xda, 0x50, 0xec, 0xc9, 0x7c, 0x01, 0xd3, 0xb8, 0x51,
+	0xd8, 0x97, 0x91, 0xf7, 0x05, 0x34, 0xb3, 0x79, 0x88, 0x0e, 0xba, 0x92, 0xea, 0x9d, 0x0e, 0xba,
+	0xd2, 0x4a, 0x5c, 0x24, 0xfe, 0x25, 0x80, 0xae, 0x44, 0xe9, 0x90, 0xc8, 0x95, 0xc2, 0x74, 0x48,
+	0xe4, 0x0b, 0x57, 0x91, 0xb0, 0xc7, 0xc2, 0xda, 0x6c, 0x65, 0x49, 0x5b, 0x5b, 0x52, 0xc8, 0xd2,
+	0xd6, 0x96, 0x15, 0xa5, 0x92, 0x5b, 0x24, 0x57, 0xaa, 0xd1, 0x5b, 0xa4, 0xac, 0x40, 0xa5, 0xb7,
+	0x48, 0x69, 0x9d, 0x27, 0xf6, 0xc7, 0x8f, 0x60, 0x62, 0x33, 0x74, 0x4f, 0xd0, 0x6c, 0x3c, 0x44,
+	0x57, 0x79, 0x8c, 0xb9, 0x34, 0x31, 0x33, 0x74, 0x03, 0x6a, 0x51, 0x5d, 0x00, 0xcd, 0x47, 0x9c,
+	0x99, 0xa2, 0x8d, 0xd1, 0xca, 0x77, 0xe4, 0x37, 0xa9, 0x2e, 0x2f, 0xe8, 0x15, 0xc9, 0x15, 0x4a,
+	0xf4, 0x8a, 0x14, 0x54, 0x23, 0x22, 0x61, 0x87, 0x70, 0x39, 0x55, 0x25, 0x40, 0x37, 0xe3, 0x29,
+	0x14, 0x14, 0x2b, 0x8c, 0xc5, 0x92, 0xde, 0xcc, 0x32, 0x3c, 0x07, 0xd0, 0xe8, 0xbd, 0x36, 0x31,
+	0x57, 0x61, 0xd0, 0x26, 0x16, 0x80, 0xfd, 0x89, 0x5d, 0x99, 0x07, 0xe0, 0xf5, 0xae, 0x2c, 0x2d,
+	0x08, 0xe8, 0x5d, 0x59, 0x8e, 0xdf, 0xc7, 0x16, 0x0b, 0x25, 0x59, 0xc8, 0x3c, 0xa9, 0xa4, 0x04,
+	0xc2, 0x4f, 0x2a, 0x29, 0x43, 0xdc, 0x63, 0x25, 0x34, 0x5f, 0x4e, 0x57, 0x50, 0x37, 0xba, 0x5f,
+	0xb6, 0x21, 0xd3, 0xc8, 0xbb, 0xf1, 0xee, 0xf7, 0xf2, 0x65, 0xbc, 0x77, 0x00, 0x8d, 0x24, 0xd4,
+	0x8d, 0x6e, 0xa4, 0x05, 0xa4, 0x30, 0x41, 0xe3, 0x66, 0x71, 0x67, 0x7a, 0x1a, 0x8f, 0x2b, 0xe8,
+	0x57, 0x60, 0x94, 0xa3, 0x7d, 0xe8, 0xbd, 0x61, 0x36, 0xa6, 0x15, 0xbe, 0xff, 0x36, 0xac, 0xe9,
+	0x19, 0x3d, 0xa8, 0xa0, 0x6d, 0xa8, 0xc7, 0x08, 0x34, 0x6a, 0x95, 0xe1, 0xe7, 0xc6, 0x42, 0x41,
+	0x4f, 0xc6, 0x3b, 0x9f, 0x40, 0x23, 0x89, 0x28, 0x6b, 0xef, 0x14, 0x80, 0xd9, 0xda, 0x3b, 0x85,
+	0x20, 0x74, 0xf2, 0x7c, 0xd7, 0x98, 0x64, 0xe2, 0x7c, 0xcf, 0x01, 0x9f, 0x89, 0xf3, 0x3d, 0x0f,
+	0x62, 0xc6, 0x41, 0xd3, 0x16, 0x7f, 0x44, 0xa4, 0x81, 0x44, 0x94, 0xfc, 0x25, 0xa1, 0x10, 0xb9,
+	0xd4, 0x47, 0x5a, 0x29, 0x0a, 0x99, 0x58, 0xcf, 0x2f, 0x61, 0x26, 0x87, 0x0c, 0x6a, 0x1d, 0x65,
+	0x50, 0xa4, 0xd6, 0x51, 0x0a, 0x2b, 0xc6, 0xb3, 0x58, 0x85, 0xaa, 0xfa, 0x8f, 0x09, 0x5d, 0x8f,
+	0x47, 0xa5, 0x7e, 0x92, 0x32, 0xe6, 0x73, 0xf4, 0x8c, 0x67, 0xf7, 0x61, 0x3a, 0x01, 0x1b, 0xa2,
+	0xe4, 0x85, 0x93, 0x81, 0x03, 0xb5, 0x67, 0x0b, 0x70, 0xc6, 0xc4, 0xbc, 0x7f, 0xcd, 0xd3, 0x8a,
+	0x21, 0x20, 0x1e, 0xfa, 0x60, 0x58, 0x7c, 0x66, 0x95, 0x3e, 0x7c, 0x3b, 0xe6, 0xcc, 0xac, 0x7e,
+	0x0e, 0x97, 0x53, 0x80, 0x94, 0x3e, 0x81, 0x8b, 0x50, 0x43, 0x7d, 0x02, 0x17, 0xa2, 0x58, 0x89,
+	0xb9, 0x9d, 0xc0, 0x5c, 0x11, 0x80, 0x80, 0xee, 0xea, 0x5d, 0x51, 0x0a, 0x85, 0x18, 0xf7, 0x86,
+	0x33, 0xe5, 0x94, 0xb5, 0x61, 0x26, 0x87, 0xc6, 0xe8, 0x00, 0x2a, 0x83, 0x89, 0x74, 0x00, 0x95,
+	0x42, 0x39, 0x09, 0x1d, 0x18, 0x50, 0xbe, 0xf4, 0x82, 0x12, 0xaf, 0xdb, 0x92, 0x0a, 0x90, 0x3e,
+	0xa2, 0x87, 0x54, 0x6e, 0xf4, 0xe1, 0xd2, 0x86, 0x99, 0x5c, 0xb5, 0x45, 0x4f, 0xa5, 0xac, 0xbc,
+	0xa3, 0xa7, 0x52, 0x5a, 0xaa, 0x49, 0x4c, 0xe5, 0x15, 0x5c, 0xcd, 0xc0, 0x06, 0xe8, 0x56, 0xea,
+	0x09, 0x92, 0x43, 0x39, 0x8c, 0xa5, 0xd2, 0xfe, 0x4c, 0x3c, 0x11, 0xb8, 0x5e, 0x0c, 0x0e, 0xa0,
+	0x77, 0x12, 0xa1, 0x53, 0x8e, 0x4b, 0x18, 0xf7, 0xbf, 0x8f, 0x2d, 0xb3, 0xb5, 0x0f, 0xe1, 0x72,
+	0x2a, 0xaf, 0xd5, 0x01, 0x5c, 0x84, 0x36, 0xe8, 0x00, 0x2e, 0xce, 0xf4, 0xa3, 0x69, 0xf8, 0x19,
+	0x28, 0x20, 0xca, 0x96, 0xd1, 0xbd, 0xc2, 0xf1, 0x19, 0x3c, 0xc0, 0x78, 0xe7, 0x7b, 0xb8, 0xf2,
+	0x8f, 0xe8, 0x6c, 0x96, 0x9c, 0xcc, 0xdc, 0x0a, 0x93, 0xf2, 0x64, 0xe6, 0x56, 0x92, 0x60, 0xa7,
+	0xc4, 0xa7, 0xd3, 0xdd, 0xa4, 0xf8, 0xc2, 0x14, 0x3c, 0x29, 0xbe, 0x24, 0x53, 0x8e, 0xc4, 0x1f,
+	0xc1, 0x6c, 0x41, 0xb2, 0x8a, 0x12, 0x71, 0x5f, 0x96, 0x4d, 0x1b, 0x77, 0x87, 0xf2, 0xa4, 0xf5,
+	0xac, 0x3e, 0x7e, 0xc5, 0xb9, 0x7d, 0xa7, 0xbd, 0xec, 0x92, 0xde, 0x23, 0xf9, 0xf9, 0x21, 0xa1,
+	0xc7, 0x8f, 0xa4, 0x8c, 0x47, 0xe2, 0xb7, 0xe8, 0x47, 0xc7, 0x44, 0xb5, 0xfb, 0xed, 0xf6, 0x94,
+	0x20, 0x3d, 0xfd, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x04, 0x75, 0x81, 0x0d, 0x5b, 0x2d, 0x00,
 	0x00,
 }
 
diff --git a/ruby/proto/gitaly/repository-service_pb.rb b/ruby/proto/gitaly/repository-service_pb.rb
index 6d8741ace3..c1a5d00244 100644
--- a/ruby/proto/gitaly/repository-service_pb.rb
+++ b/ruby/proto/gitaly/repository-service_pb.rb
@@ -115,10 +115,8 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :revision, :bytes, 3
     optional :old_revision, :bytes, 4
     optional :force, :bool, 5
-    optional :transaction, :message, 7, "gitaly.Transaction"
   end
   add_message "gitaly.WriteRefTxResponse" do
-    optional :transaction, :message, 1, "gitaly.Transaction"
   end
   add_message "gitaly.FindMergeBaseRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
-- 
GitLab


From 6da6bc59fcc61e71aa96c4159549f5ca28bdf9e6 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Fri, 28 Feb 2020 14:26:06 -0800
Subject: [PATCH 7/8] some updates to transactions

---
 internal/git/repository/repository.go         | 112 +++++++++++-------
 .../repositoryhandler/transactions.go         |  19 ++-
 internal/praefect/coordinator.go              |  23 ++--
 internal/server/server.go                     |   8 +-
 internal/service/register.go                  |   4 +-
 internal/service/repository/server.go         |   4 +-
 internal/service/repository/write_ref_tx.go   |  34 ++++--
 7 files changed, 127 insertions(+), 77 deletions(-)

diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index 601cfd361f..c7b94184ca 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -2,11 +2,11 @@ package repository
 
 import (
 	"errors"
+	"os/exec"
 	"sync"
 	"time"
 
 	"github.com/sirupsen/logrus"
-	"gitlab.com/gitlab-org/gitaly/internal/command"
 	"gitlab.com/gitlab-org/gitaly/internal/log"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
@@ -19,25 +19,26 @@ type GitRepo interface {
 	GetGitAlternateObjectDirectories() []string
 }
 
-func NewTransactions() *Transactions {
-	return &Transactions{
+func NewTransactionManager() *TransactionManager {
+	return &TransactionManager{
 		transactions: make(map[string]*Transaction),
 		repositories: make(map[string]*sync.Mutex),
 		log:          log.Default(),
 	}
 }
 
-type Transactions struct {
+type TransactionManager struct {
 	txMutex, repoMutex sync.RWMutex
 	transactions       map[string]*Transaction
 	repositories       map[string]*sync.Mutex
 	log                *logrus.Entry
 }
 
-func (t *Transactions) NewTransaction(transactionID string, repo *gitalypb.Repository) {
+func (t *TransactionManager) NewTransaction(transactionID string, repo *gitalypb.Repository) {
 	logrus.WithField("transaction_id", transactionID).Info("creating new transaction")
 	tx := Transaction{
-		Repo: repo,
+		repo:     repo,
+		commitCh: make(chan error),
 	}
 
 	t.txMutex.Lock()
@@ -45,47 +46,47 @@ func (t *Transactions) NewTransaction(transactionID string, repo *gitalypb.Repos
 	t.transactions[transactionID] = &tx
 
 	t.repoMutex.Lock()
-
-	_, ok := t.repositories[repo.RelativePath]
+	_, ok := t.repositories[tx.repo.GetRelativePath()]
 	if !ok {
-		t.repositories[repo.RelativePath] = &sync.Mutex{}
+		t.repositories[tx.repo.GetRelativePath()] = &sync.Mutex{}
 	}
-
-	t.repositories[repo.RelativePath].Lock()
-
+	t.repositories[tx.repo.GetRelativePath()].Lock()
 	t.repoMutex.Unlock()
 }
 
-func (t *Transactions) Start(transactionID string) {
+func (t *TransactionManager) Begin(transactionID string) {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
-	_, ok := t.transactions[transactionID]
+	tx, ok := t.transactions[transactionID]
 	if !ok {
 		return
 	}
 
-	t.transactions[transactionID].inProgress = true
+	tx.inProgress = true
 
 	go func() {
-		<-time.NewTimer(1 * time.Second).C
+		<-time.NewTimer(2 * time.Second).C
 		t.txMutex.Lock()
+
 		tx, ok := t.transactions[transactionID]
 		if !ok {
+			t.txMutex.Unlock()
 			return
 		}
 		if tx.prepared {
 			t.log.WithField("transaction_id", transactionID).Info("transaction has already been prepared")
+			t.txMutex.Unlock()
 			return
 		}
-		t.txMutex.Unlock()
 
+		t.txMutex.Unlock()
 		t.log.WithField("transaction_id", transactionID).Info("transaction has not been prepared and is timing out")
-		t.Unlock(transactionID)
+		t.Release(transactionID)
 	}()
 }
 
-func (t *Transactions) PreCommit(transactionID string, c command.Cmd) {
+func (t *TransactionManager) PreCommit(transactionID string, c *exec.Cmd) {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
@@ -94,10 +95,13 @@ func (t *Transactions) PreCommit(transactionID string, c command.Cmd) {
 		return
 	}
 
-	go tx.PrepareCommitAndWait(c, 2*time.Second)
+	go func() {
+		tx.PrepareCommitAndWait(c, 2*time.Second)
+		t.Release(transactionID)
+	}()
 }
 
-func (t *Transactions) SetRollback(transactionID string, rollback command.Cmd) {
+func (t *TransactionManager) SetRollback(transactionID string, rollback *exec.Cmd) {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 	tx, ok := t.transactions[transactionID]
@@ -105,10 +109,10 @@ func (t *Transactions) SetRollback(transactionID string, rollback command.Cmd) {
 		return
 	}
 
-	tx.Rollback = rollback
+	tx.rollback = rollback
 }
 
-func (t *Transactions) Commit(transactionID string) error {
+func (t *TransactionManager) Commit(transactionID string) error {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
@@ -117,13 +121,12 @@ func (t *Transactions) Commit(transactionID string) error {
 		return errors.New("request_id not found")
 	}
 
-	tx.Commit()
-
 	t.log.WithField("transaction_id", transactionID).Info("commited")
-	return nil
+	return tx.Commit()
 }
 
-func (t *Transactions) Unlock(transactionID string) error {
+func (t *TransactionManager) Release(transactionID string) error {
+	t.log.WithField("transaction_id", transactionID).Info("unlocking")
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
@@ -136,7 +139,7 @@ func (t *Transactions) Unlock(transactionID string) error {
 		t.repoMutex.Lock()
 		defer t.repoMutex.Unlock()
 
-		repoLock, ok := t.repositories[tx.Repo.GetRelativePath()]
+		repoLock, ok := t.repositories[tx.repo.GetRelativePath()]
 		if !ok {
 			return nil
 		}
@@ -149,7 +152,7 @@ func (t *Transactions) Unlock(transactionID string) error {
 	return nil
 }
 
-func (t *Transactions) Rollback(transactionID string) error {
+func (t *TransactionManager) Rollback(transactionID string) error {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
@@ -158,14 +161,14 @@ func (t *Transactions) Rollback(transactionID string) error {
 		return errors.New("request_id not found")
 	}
 
-	if err := tx.Rollback.Wait(); err != nil {
+	if err := tx.rollback.Run(); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (t *Transactions) TransactionStarted(transactionID string) bool {
+func (t *TransactionManager) TransactionStarted(transactionID string) bool {
 	t.txMutex.Lock()
 	defer t.txMutex.Unlock()
 
@@ -174,26 +177,51 @@ func (t *Transactions) TransactionStarted(transactionID string) bool {
 	return ok
 }
 
-func (t *Transaction) PrepareCommitAndWait(c command.Cmd, d time.Duration) {
+func (t *Transaction) PrepareCommitAndWait(c *exec.Cmd, d time.Duration) {
+	logrus.WithError(t.commitErr).Info("precommit started")
 	t.prepared = true
+	t.commit = c
 
-	select {
-	case <-time.NewTimer(d).C:
-	case <-t.commitCh:
+	<-time.NewTimer(d).C
+	if !t.inProgress {
+		return
 	}
+	logrus.Info("timer went off...i'm doin it!")
+	t.Commit()
 
-	t.commitErr = c.Wait()
-	t.inProgress = false
+	logrus.WithError(t.commitErr).Info("precommit completed")
 }
 
-func (t *Transaction) Commit() {
-	close(t.commitCh)
+func (t *Transaction) Commit() error {
+	if t.commitErr != nil {
+		return t.commitErr
+	}
+	if !t.inProgress {
+		return nil
+	}
+
+	defer func() {
+		t.inProgress = false
+	}()
+
+	if t.commitErr = t.commit.Start(); t.commitErr != nil {
+		return t.commitErr
+	}
+
+	if t.commitErr = t.commit.Wait(); t.commitErr != nil {
+		return t.commitErr
+	}
+
+	logrus.WithError(t.commitErr).WithField("args", t.commit.Args).Info("Finished Commit")
+
+	return nil
 }
 
 type Transaction struct {
-	Repo                 GitRepo
-	Rollback             command.Cmd
+	repo                 GitRepo
+	commit               *exec.Cmd
+	rollback             *exec.Cmd
 	commitErr            error
-	commitCh             chan struct{}
+	commitCh             chan error
 	inProgress, prepared bool
 }
diff --git a/internal/middleware/repositoryhandler/transactions.go b/internal/middleware/repositoryhandler/transactions.go
index 8cfeb7ae6d..fe8e1ba91a 100644
--- a/internal/middleware/repositoryhandler/transactions.go
+++ b/internal/middleware/repositoryhandler/transactions.go
@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/google/uuid"
 	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
@@ -18,7 +20,7 @@ type RepositoryRequest interface {
 	GetRepository() *gitalypb.Repository
 }
 
-func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions, registry *protoregistry.Registry) grpc.UnaryServerInterceptor {
+func RepositoryTransactionUnaryInterceptor(transactions *repository.TransactionManager, registry *protoregistry.Registry) grpc.UnaryServerInterceptor {
 	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
 		mi, err := registry.LookupMethod(info.FullMethod)
 		if err != nil {
@@ -41,11 +43,14 @@ func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions
 					return nil, errors.New("not a repository request")
 				}
 				if repoReq.GetRepository() != nil {
+
+					logrus.WithField("repository", repoReq.GetRepository()).Info("trying to start new transaction")
 					transactions.NewTransaction(transactionID, repoReq.GetRepository())
+					logrus.WithField("repository", repoReq.GetRepository()).Info("started new transaction")
 				}
 			}
 
-			defer transactions.Unlock(transactionID)
+			defer transactions.Release(transactionID)
 
 			md.Set("transaction_id", transactionID)
 			ctx = metadata.NewIncomingContext(ctx, md)
@@ -57,7 +62,7 @@ func RepositoryTransactionUnaryInterceptor(transactions *repository.Transactions
 	}
 }
 
-func NewTransactionServerStream(ss grpc.ServerStream, methodInfo protoregistry.MethodInfo, transactions *repository.Transactions, transactionID string) TransactionServerStream {
+func NewTransactionServerStream(ss grpc.ServerStream, methodInfo protoregistry.MethodInfo, transactions *repository.TransactionManager, transactionID string) TransactionServerStream {
 	return TransactionServerStream{
 		transactionID: transactionID,
 		ss:            ss,
@@ -70,7 +75,7 @@ type TransactionServerStream struct {
 	transactionID string
 	ss            grpc.ServerStream
 	mi            protoregistry.MethodInfo
-	transactions  *repository.Transactions
+	transactions  *repository.TransactionManager
 }
 
 func (t TransactionServerStream) SetHeader(m metadata.MD) error {
@@ -98,7 +103,9 @@ func (t TransactionServerStream) RecvMsg(m interface{}) error {
 		fmt.Printf("Receiving Message: type=%s\n", reflect.TypeOf(m).String())
 		repoReq, ok := m.(RepositoryRequest)
 		if ok && repoReq.GetRepository() != nil {
+			logrus.WithField("repository", repoReq.GetRepository()).Info("trying to start new transaction")
 			t.transactions.NewTransaction(t.transactionID, repoReq.GetRepository())
+			logrus.WithField("repository", repoReq.GetRepository()).Info("started new transaction")
 		}
 	}
 
@@ -108,7 +115,7 @@ func (t TransactionServerStream) RecvMsg(m interface{}) error {
 }
 
 // StreamInterceptor returns a Stream Interceptor
-func RepositoryTransactionServerInterceptor(transactions *repository.Transactions, registry *protoregistry.Registry) grpc.StreamServerInterceptor {
+func RepositoryTransactionStreamInterceptor(transactions *repository.TransactionManager, registry *protoregistry.Registry) grpc.StreamServerInterceptor {
 	return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
 		mi, err := registry.LookupMethod(info.FullMethod)
 		if err != nil {
@@ -125,7 +132,7 @@ func RepositoryTransactionServerInterceptor(transactions *repository.Transaction
 				transactionID = uuid.New().String()
 			}
 
-			defer transactions.Unlock(transactionID)
+			defer transactions.Release(transactionID)
 
 			return handler(srv, NewTransactionServerStream(stream, mi, transactions, transactionID))
 		}
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 99b7d34fa1..09c4458c16 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -148,6 +148,7 @@ func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string,
 }
 
 func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
+	c.log.Info("I'm in Handle write rEFFFFFFFFFFFFFFFFFFFFFF!!!!!!!!!!!!!!")
 	var writeRefReq gitalypb.WriteRefRequest
 
 	if err := serverStream.RecvMsg(&writeRefReq); err != nil {
@@ -175,7 +176,8 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 	var errs []error
 	transactionIDs := make(map[string]nodes.Node)
 
-	// Prepare
+	c.log.Info("about to vote")
+	// vote
 	for _, node := range append(secondaries, primary) {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
 		targetRepo := &gitalypb.Repository{
@@ -184,9 +186,7 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		}
 		var trailer metadata.MD
 
-		metadata.AppendToOutgoingContext(ctx, "transaction_step", "prepare")
-
-		if _, err := client.WriteRefTx(ctx, &gitalypb.WriteRefTxRequest{
+		if _, err := client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "vote"), &gitalypb.WriteRefTxRequest{
 			Repository:  targetRepo,
 			Ref:         writeRefReq.Ref,
 			Revision:    writeRefReq.Revision,
@@ -208,16 +208,17 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		return errors.New("votes failed")
 	}
 
+	c.log.Info("about to precommit")
+
 	// PreCommit
-	for _, node := range transactionIDs {
+	for transactionID, node := range transactionIDs {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
 		targetRepo := &gitalypb.Repository{
 			StorageName:  node.GetStorage(),
 			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
 		}
 
-		metadata.AppendToOutgoingContext(ctx, "transaction_step", "precommit")
-		if _, err := client.WriteRefTx(ctx, &gitalypb.WriteRefTxRequest{
+		if _, err := client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "precommit", "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{
 			Repository:  targetRepo,
 			Ref:         writeRefReq.Ref,
 			Revision:    writeRefReq.Revision,
@@ -228,11 +229,12 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		}
 	}
 
+	c.log.Info("about to commit")
 	// Commit
 	if len(errs) == 0 {
-		for _, node := range transactionIDs {
+		for transactionID, node := range transactionIDs {
 			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "commit"), &gitalypb.WriteRefTxRequest{}); err != nil {
+			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "commit", "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{}); err != nil {
 				return err
 			}
 		}
@@ -244,7 +246,8 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		return nil
 	}
 
-	// Rollback
+	c.log.Info("about to rollback")
+	// rollback
 	for _, node := range transactionIDs {
 		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
 		if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "rollback"), &gitalypb.WriteRefTxRequest{}); err != nil {
diff --git a/internal/server/server.go b/internal/server/server.go
index e7fd93f83f..2e421d418d 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -79,7 +79,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 
 	lh := limithandler.New(concurrencyKeyFn)
 
-	transactions := repository.NewTransactions()
+	transactionMgr := repository.NewTransactionManager()
 	registry := protoregistry.New()
 	registry.RegisterFiles(protoregistry.GitalyProtoFileDescriptors...)
 
@@ -100,7 +100,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 			// Panic handler should remain last so that application panics will be
 			// converted to errors and logged
 			panichandler.StreamPanicHandler,
-			repositoryhandler.RepositoryTransactionServerInterceptor(transactions, registry),
+			repositoryhandler.RepositoryTransactionStreamInterceptor(transactionMgr, registry),
 		)),
 		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
 			grpc_ctxtags.UnaryServerInterceptor(ctxTagOpts...),
@@ -117,7 +117,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 			// Panic handler should remain last so that application panics will be
 			// converted to errors and logged
 			panichandler.UnaryPanicHandler,
-			repositoryhandler.RepositoryTransactionUnaryInterceptor(transactions, registry),
+			repositoryhandler.RepositoryTransactionUnaryInterceptor(transactionMgr, registry),
 		)),
 	}
 
@@ -133,7 +133,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 
 	server := grpc.NewServer(opts...)
 
-	service.RegisterAll(server, rubyServer, transactions)
+	service.RegisterAll(server, rubyServer, transactionMgr)
 	reflection.Register(server)
 
 	grpc_prometheus.Register(server)
diff --git a/internal/service/register.go b/internal/service/register.go
index 2db53735fd..597acf6109 100644
--- a/internal/service/register.go
+++ b/internal/service/register.go
@@ -27,7 +27,7 @@ import (
 
 // RegisterAll will register all the known grpc services with
 // the specified grpc service instance
-func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server, transactions *repo.Transactions) {
+func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server, transactionMgr *repo.TransactionManager) {
 	gitalypb.RegisterBlobServiceServer(grpcServer, blob.NewServer(rubyServer))
 	gitalypb.RegisterCleanupServiceServer(grpcServer, cleanup.NewServer())
 	gitalypb.RegisterCommitServiceServer(grpcServer, commit.NewServer())
@@ -35,7 +35,7 @@ func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server, transac
 	gitalypb.RegisterNamespaceServiceServer(grpcServer, namespace.NewServer())
 	gitalypb.RegisterOperationServiceServer(grpcServer, operations.NewServer(rubyServer))
 	gitalypb.RegisterRefServiceServer(grpcServer, ref.NewServer())
-	gitalypb.RegisterRepositoryServiceServer(grpcServer, repository.NewServer(transactions, rubyServer))
+	gitalypb.RegisterRepositoryServiceServer(grpcServer, repository.NewServer(transactionMgr, rubyServer))
 	gitalypb.RegisterSSHServiceServer(grpcServer, ssh.NewServer())
 	gitalypb.RegisterSmartHTTPServiceServer(grpcServer, smarthttp.NewServer())
 	gitalypb.RegisterWikiServiceServer(grpcServer, wiki.NewServer(rubyServer))
diff --git a/internal/service/repository/server.go b/internal/service/repository/server.go
index 9dc817d676..b833d59cfc 100644
--- a/internal/service/repository/server.go
+++ b/internal/service/repository/server.go
@@ -16,11 +16,11 @@ type server struct {
 	gitalypb.UnimplementedRepositoryServiceServer
 	connsByAddress map[string]*grpc.ClientConn
 	connsMtx       sync.RWMutex
-	transactions   *repository.Transactions
+	transactions   *repository.TransactionManager
 }
 
 // NewServer creates a new instance of a gRPC repo server
-func NewServer(transactions *repository.Transactions, rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
+func NewServer(transactions *repository.TransactionManager, rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
 	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn), transactions: transactions}
 }
 
diff --git a/internal/service/repository/write_ref_tx.go b/internal/service/repository/write_ref_tx.go
index 016adac269..457914e978 100644
--- a/internal/service/repository/write_ref_tx.go
+++ b/internal/service/repository/write_ref_tx.go
@@ -6,7 +6,8 @@ import (
 	"io/ioutil"
 	"os/exec"
 
-	"gitlab.com/gitlab-org/gitaly/internal/command"
+	"github.com/sirupsen/logrus"
+
 	"gitlab.com/gitlab-org/gitaly/internal/git"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/helper/text"
@@ -28,13 +29,18 @@ func (s *server) WriteRefTx(ctx context.Context, req *gitalypb.WriteRefTxRequest
 	}
 
 	transactionSteps := md.Get("transaction_step")
+
+	logrus.WithField("transaction_steps", transactionSteps).Info("got transaction steps")
 	if len(transactionSteps) == 0 {
 		return nil, nil
 	}
 
+	logrus.WithField("transaction_steps", transactionSteps).Info("got transaction steps")
+
 	transactionStep := transactionSteps[len(transactionSteps)-1]
 
 	if transactionStep == "precommit" {
+		logrus.WithField("relative_path", req.GetRepository().GetRelativePath()).WithField("ref", string(req.GetRef())).WithField("rev", string(req.GetRevision())).WithField("old_rev", string(req.GetOldRevision())).Info("WriteRefReqTx")
 		if err := validateWriteRefRequest(req); err != nil {
 			return nil, helper.ErrInvalidArgument(err)
 		}
@@ -57,14 +63,16 @@ func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteR
 	transactionID := md.Get("transaction_id")[0]
 
 	switch transactionStep {
-	case "prepare":
-		err := prepare(ctx, req)
+	case "vote":
+		logrus.WithField("transaction_step", "vote").Info("transaction!")
+
+		s.transactions.Begin(transactionID)
+		err := vote(ctx, req)
 		if err != nil {
 			return nil, err
 		}
-
-		s.transactions.Start(transactionID)
 	case "precommit":
+		logrus.WithField("transaction_step", "precommit").Info("transaction!")
 		rollback, err := rollbackRef(req)
 		if err != nil {
 			return nil, err
@@ -77,10 +85,12 @@ func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteR
 		s.transactions.SetRollback(transactionID, rollback)
 		s.transactions.PreCommit(transactionID, commit)
 	case "commit":
+		logrus.WithField("transaction_step", "commit").Info("transaction!")
 		if err := s.transactions.Commit(transactionID); err != nil {
 			return nil, err
 		}
 	case "rollback":
+		logrus.WithField("transaction_step", "rollback").Info("transaction!")
 		if err := s.transactions.Rollback(transactionID); err != nil {
 			return nil, err
 		}
@@ -91,7 +101,7 @@ func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteR
 	return &resp, nil
 }
 
-func prepare(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
+func vote(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
 	if req.GetOldRevision() == nil {
 		return nil
 	}
@@ -120,7 +130,7 @@ func prepare(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
 	return nil
 }
 
-func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
 	repoPath, err := helper.GetRepoPath(req.GetRepository())
 	if err != nil {
 		return nil, err
@@ -129,7 +139,7 @@ func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
 	return exec.Command("git", "-C", repoPath, "symoblic-ref", string(req.GetRef()), string(req.GetOldRevision())), nil
 }
 
-func rollbackRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+func rollbackRef(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
 	if string(req.Ref) == "HEAD" {
 		return rollbackSymbolicRef(req)
 	}
@@ -152,7 +162,7 @@ func rollbackRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
 	return c, nil
 }
 
-func preCommit(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+func preCommit(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
 	if string(req.Ref) == "HEAD" {
 		return preCommitSymbolicRef(req)
 	}
@@ -162,7 +172,7 @@ func preCommit(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
 		return nil, err
 	}
 
-	args := []string{"-C", repoPath, "update-ref", string(req.GetRevision())}
+	args := []string{"-C", repoPath, "update-ref", string(req.GetRef()), string(req.GetRevision())}
 
 	if req.GetOldRevision() != nil {
 		args = append(args, string(req.GetOldRevision()))
@@ -170,10 +180,12 @@ func preCommit(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
 
 	c := exec.Command("git", args...)
 
+	logrus.WithField("DA COMMAND ARGS!!!", args).Info("1234567")
+
 	return c, nil
 }
 
-func preCommitSymbolicRef(req *gitalypb.WriteRefTxRequest) (command.Cmd, error) {
+func preCommitSymbolicRef(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
 	repoPath, err := helper.GetRepoPath(req.GetRepository())
 	if err != nil {
 		return nil, err
-- 
GitLab


From 939b9c327ff85177f026ecaa8a44bfaaec5ed4e3 Mon Sep 17 00:00:00 2001
From: John Cai <jcai@gitlab.com>
Date: Fri, 28 Feb 2020 14:39:02 -0800
Subject: [PATCH 8/8] if commit fails, try to recover by replicating

---
 .../repositoryhandler/transactions.go         |  4 +-
 internal/praefect/coordinator.go              | 55 +++++++++++++------
 internal/praefect/helper_test.go              |  2 +-
 internal/praefect/replicator_test.go          |  2 +-
 .../service/repository/testhelper_test.go     |  2 +-
 internal/service/repository/write_ref_tx.go   |  1 -
 6 files changed, 43 insertions(+), 23 deletions(-)

diff --git a/internal/middleware/repositoryhandler/transactions.go b/internal/middleware/repositoryhandler/transactions.go
index fe8e1ba91a..273d7466c7 100644
--- a/internal/middleware/repositoryhandler/transactions.go
+++ b/internal/middleware/repositoryhandler/transactions.go
@@ -6,9 +6,8 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/sirupsen/logrus"
-
 	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
 	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
@@ -43,7 +42,6 @@ func RepositoryTransactionUnaryInterceptor(transactions *repository.TransactionM
 					return nil, errors.New("not a repository request")
 				}
 				if repoReq.GetRepository() != nil {
-
 					logrus.WithField("repository", repoReq.GetRepository()).Info("trying to start new transaction")
 					transactions.NewTransaction(transactionID, repoReq.GetRepository())
 					logrus.WithField("repository", repoReq.GetRepository()).Info("started new transaction")
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 09c4458c16..fd32185454 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -11,6 +11,7 @@ import (
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/protoc-gen-go/descriptor"
 	"github.com/sirupsen/logrus"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
@@ -37,8 +38,9 @@ type Coordinator struct {
 
 	datastore datastore.Datastore
 
-	registry *protoregistry.Registry
-	conf     config.Config
+	registry   *protoregistry.Registry
+	conf       config.Config
+	replicator Replicator
 }
 
 // NewCoordinator returns a new Coordinator that utilizes the provided logger
@@ -55,6 +57,10 @@ func NewCoordinator(l *logrus.Entry, ds datastore.Datastore, nodeMgr nodes.Manag
 	}
 }
 
+func (c *Coordinator) SetReplicator(replicator Replicator) {
+	c.replicator = replicator
+}
+
 // RegisterProtos allows coordinator to register new protos on the fly
 func (c *Coordinator) RegisterProtos(protos ...*descriptor.FileDescriptorProto) error {
 	return c.registry.RegisterFiles(protos...)
@@ -148,7 +154,6 @@ func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string,
 }
 
 func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
-	c.log.Info("I'm in Handle write rEFFFFFFFFFFFFFFFFFFFFFF!!!!!!!!!!!!!!")
 	var writeRefReq gitalypb.WriteRefRequest
 
 	if err := serverStream.RecvMsg(&writeRefReq); err != nil {
@@ -194,6 +199,7 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 			Force:       writeRefReq.Force,
 		}, grpc.Trailer(&trailer)); err != nil {
 			errs = append(errs, err)
+			continue
 		}
 
 		if len(trailer.Get("transaction_id")) == 0 {
@@ -235,26 +241,43 @@ func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerSt
 		for transactionID, node := range transactionIDs {
 			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
 			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "commit", "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{}); err != nil {
-				return err
+				if node == primary {
+					return errors.New("primary write failed")
+				}
+
+				injectedCtx, err := helper.InjectGitalyServers(metadata.AppendToOutgoingContext(ctx, "transaction_step", "recover", "transaction_id", transactionID), primary.GetStorage(), primary.GetAddress(), primary.GetToken())
+				if err != nil {
+					return err
+				}
+				client.ReplicateRepository(injectedCtx, &gitalypb.ReplicateRepositoryRequest{
+					Repository: &gitalypb.Repository{
+						StorageName:  node.GetStorage(),
+						RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+					},
+					Source: &gitalypb.Repository{
+						StorageName:  primary.GetStorage(),
+						RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+					},
+				})
 			}
 		}
-
-		return nil
 	}
+	/*
 
-	if len(errs) == 0 {
-		return nil
-	}
+		if len(errs) == 0 {
+			return nil
+		}
 
-	c.log.Info("about to rollback")
-	// rollback
-	for _, node := range transactionIDs {
-		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
-		if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "rollback"), &gitalypb.WriteRefTxRequest{}); err != nil {
-			return err
+		c.log.Info("about to rollback")
+		// rollback
+		for _, node := range transactionIDs {
+			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "rollback"), &gitalypb.WriteRefTxRequest{}); err != nil {
+				return err
+			}
 		}
-	}
 
+	*/
 	return nil
 }
 
diff --git a/internal/praefect/helper_test.go b/internal/praefect/helper_test.go
index e6b9551716..2c30be1d64 100644
--- a/internal/praefect/helper_test.go
+++ b/internal/praefect/helper_test.go
@@ -254,7 +254,7 @@ func runInternalGitalyServer(t *testing.T, token string) (*grpc.Server, string,
 	require.NoError(t, rubyServer.Start())
 
 	gitalypb.RegisterServerServiceServer(server, gitalyserver.NewServer())
-	gitalypb.RegisterRepositoryServiceServer(server, repository.NewServer(repo.NewTransactions(), rubyServer))
+	gitalypb.RegisterRepositoryServiceServer(server, repository.NewServer(repo.NewTransactionManager(), rubyServer))
 	healthpb.RegisterHealthServer(server, health.NewServer())
 
 	errQ := make(chan error)
diff --git a/internal/praefect/replicator_test.go b/internal/praefect/replicator_test.go
index f9b039248d..9f3d77be0f 100644
--- a/internal/praefect/replicator_test.go
+++ b/internal/praefect/replicator_test.go
@@ -450,7 +450,7 @@ func newReplicationService(tb testing.TB) (*grpc.Server, string) {
 
 	svr := testhelper.NewTestGrpcServer(tb, nil, nil)
 
-	gitalypb.RegisterRepositoryServiceServer(svr, repository.NewServer(repo.NewTransactions(), &rubyserver.Server{}))
+	gitalypb.RegisterRepositoryServiceServer(svr, repository.NewServer(repo.NewTransactionManager(), &rubyserver.Server{}))
 	gitalypb.RegisterObjectPoolServiceServer(svr, objectpoolservice.NewServer())
 	gitalypb.RegisterRemoteServiceServer(svr, remote.NewServer(&rubyserver.Server{}))
 	reflection.Register(svr)
diff --git a/internal/service/repository/testhelper_test.go b/internal/service/repository/testhelper_test.go
index 2c0b43c4cb..b2086aea43 100644
--- a/internal/service/repository/testhelper_test.go
+++ b/internal/service/repository/testhelper_test.go
@@ -85,7 +85,7 @@ func runRepoServer(t *testing.T) (*grpc.Server, string) {
 		t.Fatal(err)
 	}
 
-	gitalypb.RegisterRepositoryServiceServer(server, NewServer(repo.NewTransactions(), RubyServer))
+	gitalypb.RegisterRepositoryServiceServer(server, NewServer(repo.NewTransactionManager(), RubyServer))
 	reflection.Register(server)
 
 	go server.Serve(listener)
diff --git a/internal/service/repository/write_ref_tx.go b/internal/service/repository/write_ref_tx.go
index 457914e978..f146e92aa5 100644
--- a/internal/service/repository/write_ref_tx.go
+++ b/internal/service/repository/write_ref_tx.go
@@ -7,7 +7,6 @@ import (
 	"os/exec"
 
 	"github.com/sirupsen/logrus"
-
 	"gitlab.com/gitlab-org/gitaly/internal/git"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/helper/text"
-- 
GitLab