Merge branch 'smh-restrict-node-interface-in-coordinator' into 'master'

Restrict node interface in coordinator

See merge request gitlab-org/gitaly!2730

32 files changed, 1248 insertions, 423 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 06bc63f64..693835b48 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Gitaly changelog
 
+## 13.5.3 (2020-11-03)
+
+- No changes.
+
 ## 13.5.2 (2020-11-02)
 
 ### Security (1 change)
@@ -61,6 +65,10 @@
 - Upgrade Rubocop to 0.86.0. !2634
 
 
+## 13.4.6 (2020-11-03)
+
+- No changes.
+
 ## 13.4.5 (2020-11-02)
 
 ### Security (1 change)
diff --git a/Makefile b/Makefile
index c644d303d..be4ba9063 100644
--- a/Makefile
+++ b/Makefile
@@ -190,7 +190,7 @@ assemble-ruby:
 	${Q}rm -rf ${GITALY_RUBY_DIR}/tmp
 	${Q}mkdir -p ${ASSEMBLY_ROOT}/ruby/
 	rsync -a --delete  ${GITALY_RUBY_DIR}/ ${ASSEMBLY_ROOT}/ruby/
-	${Q}rm -rf ${ASSEMBLY_ROOT}/ruby/spec 
+	${Q}rm -rf ${ASSEMBLY_ROOT}/ruby/spec
 
 .PHONY: binaries
 binaries: assemble
@@ -429,7 +429,7 @@ ${GITALYFMT}: | ${BUILD_DIR}/bin
 	${Q}go build -o $@ ${SOURCE_DIR}/internal/cmd/gitalyfmt
 
 ${GO_LICENSES}: ${BUILD_DIR}/Makefile.sha256 ${BUILD_DIR}/go.mod
-	${Q}cd ${BUILD_DIR} && go get github.com/google/go-licenses@0fa8c766a59182ce9fd94169ddb52abe568b7f4e
+	${Q}cd ${BUILD_DIR} && go get github.com/google/go-licenses@73411c8fa237ccc6a75af79d0a5bc021c9487aad
 
 ${PROTOC_GEN_GO}: ${BUILD_DIR}/Makefile.sha256 ${BUILD_DIR}/go.mod
 	${Q}cd ${BUILD_DIR} && go get github.com/golang/protobuf/protoc-gen-go@v${PROTOC_GEN_GO_VERSION}
diff --git a/NOTICE b/NOTICE
index 203d7be3c..60f13e863 100644
--- a/NOTICE
+++ b/NOTICE
@@ -473,34 +473,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-LICENSE - github.com/git-lfs/go-ntlm/ntlm
-Copyright (c) 2011-2017 GitLab B.V.
-
-With regard to the GitLab Software:
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-For all third party components incorporated into the GitLab Software, those
-components are licensed under the original license provided by the owner of the
-applicable component.
-
+License - github.com/git-lfs/go-ntlm/ntlm
+Copyright (c) 2013, Thomson Reuters Global Resources
+All rights reserved.
 
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. All advertising materials mentioning features or use of this software
+   must display the following acknowledgement:
+   This product includes software developed by the Thomson Reuters Global Resources.
+4. Neither the name of the Thomson Reuters Global Resources nor the
+   names of its contributors may be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY Thomson Reuters Global Resources ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Thomson Reuters Global Resources BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 LICENSE - github.com/git-lfs/go-ntlm/ntlm/md4
 Copyright (c) 2009 The Go Authors. All rights reserved.
diff --git a/REVIEWING.md b/REVIEWING.md
index 0fe454bc6..9b23711a3 100644
--- a/REVIEWING.md
+++ b/REVIEWING.md
@@ -24,20 +24,20 @@ outage, because causing an outage is not the right thing to do.
 
 ### Tips for the Contributor
 
-As the contributor you have a dual role. You are driving the change in the MR, but you 
+As the contributor you have a dual role. You are driving the change in the MR, but you
 are also the **first reviewer** of the MR. Below you will find some tips for reviewing
 your own MR. Doing this costs time, but it should also save time for the other
 reviewers and thereby speed up the acceptance of your MR.
 
 #### Use the GitLab MR page to put on your "reviewer hat"
 
-It is sometimes hard to switch from being the contributor, to being a reviewer 
+It is sometimes hard to switch from being the contributor, to being a reviewer
 of your own work. Looking at your work in the GitLab UI (the merge request page)
 helps to get in the reviewer mindset.
 
 #### Reconsider the title of your MR after you reviewed it
 
-When you are in the contributor mindset, you don't always know 
+When you are in the contributor mindset, you don't always know
 what you are doing, or why. You discover this as you go along. The title you wrote for
 your MR when you first pushed it is often not the best title for what is really
 going on.
@@ -64,7 +64,7 @@ It may feel funny to literally talk to yourself but it works. If
 thoughts occur to you as you read your MR, use the comment function
 and just write them down.
 
-You probably want to address some or most of your comments before you send your 
+You probably want to address some or most of your comments before you send your
 MR to another reviewer.
 
 #### Your MR should pass your own review before it goes to a "real" reviewer
@@ -83,7 +83,7 @@ MR to another reviewer.
 
 #### Use the "Start/Submit Review" feature of GitLab
 
-The "Start/Submit Review" lets you write comments on a MR that are initially 
+The "Start/Submit Review" lets you write comments on a MR that are initially
 only visible to you. Until you submit the review as a whole, you can still add,
 change and remove comments.
 
@@ -105,7 +105,7 @@ You finished a review round and you are about to submit your review with the
 "Submit Review" feature. Look at your comments. Do some of them point at a major
 problem in the MR?
 
-For example: 
+For example:
 - the MR is solving the wrong problem
 - the MR is making a backwards incompatible change
 - the MR has a test that does not test the right thing
@@ -154,6 +154,10 @@ this" is a very important signal. Put it into words, write a comment.
 Think out loud about why you don't understand the thing that gives you
 this feeling.
 
+For example, if you do not understand what an RPC is supposed to do or
+why it exists, ask the reviewer to
+[add comments to the interface](proto/README.md#documentation).
+
 Maybe now is the time to spend 15-30 minutes brushing up your
 knowledge on this subject. Or to ask a colleague if they know more
 about this. Or to bring in another reviewer who knows more about this.
diff --git a/changelogs/unreleased/3260-remove-fetch-http-remote.yml b/changelogs/unreleased/3260-remove-fetch-http-remote.yml
new file mode 100644
index 000000000..f520b1426
--- /dev/null
+++ b/changelogs/unreleased/3260-remove-fetch-http-remote.yml
@@ -0,0 +1,5 @@
+---
+title: Remove the RepositoryService.FetchHTTPRemote RPC
+merge_request: 2744
+author:
+type: other
diff --git a/changelogs/unreleased/pks-git2go-merge-precondition-failed.yml b/changelogs/unreleased/pks-git2go-merge-precondition-failed.yml
new file mode 100644
index 000000000..7e23eeb2c
--- /dev/null
+++ b/changelogs/unreleased/pks-git2go-merge-precondition-failed.yml
@@ -0,0 +1,5 @@
+---
+title: 'operations: Return correct error code when merge fails'
+merge_request: 2690
+author:
+type: fixed
diff --git a/changelogs/unreleased/pks-hook-test-race.yml b/changelogs/unreleased/pks-hook-test-race.yml
new file mode 100644
index 000000000..a94217d5c
--- /dev/null
+++ b/changelogs/unreleased/pks-hook-test-race.yml
@@ -0,0 +1,5 @@
+---
+title: 'hooks: Always consume stdin for reference transaction hook'
+merge_request: 2719
+author:
+type: fixed
diff --git a/changelogs/unreleased/po-port-resolve-conflicts.yml b/changelogs/unreleased/po-port-resolve-conflicts.yml
new file mode 100644
index 000000000..279a73fdd
--- /dev/null
+++ b/changelogs/unreleased/po-port-resolve-conflicts.yml
@@ -0,0 +1,5 @@
+---
+title: Port ResolveConflicts from Ruby to Go
+merge_request: 2693
+author:
+type: performance
diff --git a/cmd/gitaly-git2go/main.go b/cmd/gitaly-git2go/main.go
index cfe5e5cde..68c9a8a0b 100644
--- a/cmd/gitaly-git2go/main.go
+++ b/cmd/gitaly-git2go/main.go
@@ -20,6 +20,7 @@ var subcommands = map[string]subcmd{
 	"commit":    commitSubcommand{},
 	"merge":     &mergeSubcommand{},
 	"revert":    &revertSubcommand{},
+	"resolve":   &resolveSubcommand{},
 }
 
 const programName = "gitaly-git2go"
diff --git a/cmd/gitaly-git2go/resolve_conflicts.go b/cmd/gitaly-git2go/resolve_conflicts.go
new file mode 100644
index 000000000..7500fae8f
--- /dev/null
+++ b/cmd/gitaly-git2go/resolve_conflicts.go
@@ -0,0 +1,233 @@
+// +build static,system_libgit2
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	git "github.com/libgit2/git2go/v30"
+	"gitlab.com/gitlab-org/gitaly/internal/git/conflict"
+	"gitlab.com/gitlab-org/gitaly/internal/git2go"
+)
+
+type resolveSubcommand struct {
+	request string
+}
+
+func (cmd *resolveSubcommand) Flags() *flag.FlagSet {
+	flags := flag.NewFlagSet("resolve", flag.ExitOnError)
+	flags.StringVar(&cmd.request, "request", "", "git2go.ResolveCommand")
+	return flags
+}
+
+func (cmd resolveSubcommand) Run(context.Context, io.Reader, io.Writer) error {
+	request, err := git2go.ResolveCommandFromSerialized(cmd.request)
+	if err != nil {
+		return err
+	}
+
+	if request.AuthorDate.IsZero() {
+		request.AuthorDate = time.Now()
+	}
+
+	repo, err := git.OpenRepository(request.Repository)
+	if err != nil {
+		return fmt.Errorf("could not open repository: %w", err)
+	}
+
+	ours, err := lookupCommit(repo, request.Ours)
+	if err != nil {
+		return fmt.Errorf("could not lookup commit %q: %w", request.Ours, err)
+	}
+
+	theirs, err := lookupCommit(repo, request.Theirs)
+	if err != nil {
+		return fmt.Errorf("could not lookup commit %q: %w", request.Theirs, err)
+	}
+
+	index, err := repo.MergeCommits(ours, theirs, nil)
+	if err != nil {
+		return fmt.Errorf("could not merge commits: %w", err)
+	}
+
+	ci, err := index.ConflictIterator()
+	if err != nil {
+		return err
+	}
+
+	type paths struct {
+		theirs, ours string
+	}
+	conflicts := map[paths]git.IndexConflict{}
+
+	for {
+		c, err := ci.Next()
+		if git.IsErrorCode(err, git.ErrIterOver) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		if c.Our.Path == "" || c.Their.Path == "" {
+			return errors.New("conflict side missing")
+		}
+
+		k := paths{
+			theirs: c.Their.Path,
+			ours:   c.Our.Path,
+		}
+		conflicts[k] = c
+	}
+
+	odb, err := repo.Odb()
+	if err != nil {
+		return err
+	}
+
+	for _, r := range request.Resolutions {
+		c, ok := conflicts[paths{
+			theirs: r.OldPath,
+			ours:   r.NewPath,
+		}]
+		if !ok {
+			// Note: this emulates the Ruby error that occurs when
+			// there are no conflicts for a resolution
+			return errors.New("NoMethodError: undefined method `resolve_lines' for nil:NilClass") //nolint
+		}
+
+		mfr, err := mergeFileResult(odb, c)
+		if err != nil {
+			return fmt.Errorf("merge file result for %q: %w", r.NewPath, err)
+		}
+
+		conflictFile, err := conflict.Parse(
+			bytes.NewReader(mfr.Contents),
+			c.Our.Path,
+			c.Their.Path,
+			c.Ancestor.Path,
+		)
+		if err != nil {
+			return fmt.Errorf("parse conflict for %q: %w", c.Ancestor.Path, err)
+		}
+
+		resolvedBlob, err := conflictFile.Resolve(r)
+		if err != nil {
+			return err // do not decorate this error to satisfy old test
+		}
+
+		resolvedBlobOID, err := odb.Write(resolvedBlob, git.ObjectBlob)
+		if err != nil {
+			return fmt.Errorf("write object for %q: %w", c.Ancestor.Path, err)
+		}
+
+		ourResolvedEntry := *c.Our // copy by value
+		ourResolvedEntry.Id = resolvedBlobOID
+		if err := index.Add(&ourResolvedEntry); err != nil {
+			return fmt.Errorf("add index for %q: %w", c.Ancestor.Path, err)
+		}
+
+		if err := index.RemoveConflict(ourResolvedEntry.Path); err != nil {
+			return fmt.Errorf("remove conflict from index for %q: %w", c.Ancestor.Path, err)
+		}
+	}
+
+	if index.HasConflicts() {
+		ci, err := index.ConflictIterator()
+		if err != nil {
+			return fmt.Errorf("iterating unresolved conflicts: %w", err)
+		}
+
+		var conflictPaths []string
+		for {
+			c, err := ci.Next()
+			if git.IsErrorCode(err, git.ErrIterOver) {
+				break
+			}
+			if err != nil {
+				return fmt.Errorf("next unresolved conflict: %w", err)
+			}
+			conflictPaths = append(conflictPaths, c.Ancestor.Path)
+		}
+
+		return fmt.Errorf("Missing resolutions for the following files: %s", strings.Join(conflictPaths, ", ")) //nolint
+	}
+
+	tree, err := index.WriteTreeTo(repo)
+	if err != nil {
+		return fmt.Errorf("write tree to repo: %w", err)
+	}
+
+	signature := git2go.NewSignature(request.AuthorName, request.AuthorMail, request.AuthorDate)
+	committer := &git.Signature{
+		Name:  signature.Name,
+		Email: signature.Email,
+		When:  request.AuthorDate,
+	}
+
+	commit, err := repo.CreateCommitFromIds("", committer, committer, request.Message, tree, ours.Id(), theirs.Id())
+	if err != nil {
+		return fmt.Errorf("could not create resolve conflict commit: %w", err)
+	}
+
+	response := git2go.ResolveResult{
+		git2go.MergeResult{
+			CommitID: commit.String(),
+		},
+	}
+
+	if err := response.SerializeTo(os.Stdout); err != nil {
+		return fmt.Errorf("serializing response: %w", err)
+	}
+
+	return nil
+}
+
+func mergeFileResult(odb *git.Odb, c git.IndexConflict) (*git.MergeFileResult, error) {
+	ancestorBlob, err := odb.Read(c.Ancestor.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	ourBlob, err := odb.Read(c.Our.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	theirBlob, err := odb.Read(c.Their.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	mfr, err := git.MergeFile(
+		git.MergeFileInput{
+			Path:     c.Ancestor.Path,
+			Mode:     uint(c.Ancestor.Mode),
+			Contents: ancestorBlob.Data(),
+		},
+		git.MergeFileInput{
+			Path:     c.Our.Path,
+			Mode:     uint(c.Our.Mode),
+			Contents: ourBlob.Data(),
+		},
+		git.MergeFileInput{
+			Path:     c.Their.Path,
+			Mode:     uint(c.Their.Mode),
+			Contents: theirBlob.Data(),
+		},
+		nil,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return mfr, nil
+}
diff --git a/internal/git/conflict/parser.go b/internal/git/conflict/parser.go
new file mode 100644
index 000000000..aba1385be
--- /dev/null
+++ b/internal/git/conflict/parser.go
@@ -0,0 +1,227 @@
+package conflict
+
+// This file is a direct port of Ruby source previously hosted at
+// ruby/lib/gitlab/git/conflict/parser.rb (git show fb5717dd5567082)
+// ruby/lib/gitlab/git/conflict/file.rb (git show 6f787458251b5f)
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/sha1"
+	"errors"
+	"fmt"
+	"io"
+)
+
+// Errors that can occur during parsing of a merge conflict file
+var (
+	ErrUnmergeableFile     = errors.New("merging is not supported for file")
+	ErrUnexpectedDelimiter = errors.New("unexpected conflict delimiter")
+	ErrMissingEndDelimiter = errors.New("missing last delimiter")
+)
+
+type section uint
+
+const (
+	sectionNone = section(iota)
+	sectionOld
+	sectionNew
+	sectionNoNewline
+)
+
+const fileLimit = 200 * (1 << 10) // 200k
+
+type line struct {
+	objIndex uint // where are we in the object?
+	oldIndex uint // where are we in the old file?
+	newIndex uint // where are we in the new file?
+
+	payload string // actual line contents (minus the newline)
+	section section
+}
+
+// File contains an ordered list of lines with metadata about potential
+// conflicts.
+type File struct {
+	path  string
+	lines []line
+}
+
+func (f File) sectionID(l line) string {
+	pathSHA1 := sha1.Sum([]byte(f.path))
+	return fmt.Sprintf("%x_%d_%d", pathSHA1, l.oldIndex, l.newIndex)
+}
+
+// Resolution indicates how to resolve a conflict
+type Resolution struct {
+	OldPath string `json:"old_path"`
+	NewPath string `json:"new_path"`
+
+	// key is a sectionID, value is "head" or "origin"
+	Sections map[string]string `json:"sections"`
+
+	// Content is used when no sections are defined
+	Content string `json:"content"`
+}
+
+const (
+	head   = "head"
+	origin = "origin"
+)
+
+// Resolve will iterate through each conflict line and replace it with the
+// specified resolution
+func (f File) Resolve(resolution Resolution) ([]byte, error) {
+	var sectionID string
+	b := bytes.NewBuffer(nil)
+
+	if len(resolution.Sections) == 0 {
+		return []byte(resolution.Content), nil
+	}
+
+	for _, l := range f.lines {
+		if l.section == sectionNone {
+			sectionID = ""
+			if _, err := b.WriteString(l.payload + "\n"); err != nil {
+				return nil, err
+			}
+			continue
+		}
+
+		if sectionID == "" {
+			sectionID = f.sectionID(l)
+		}
+
+		r, ok := resolution.Sections[sectionID]
+		if !ok {
+			return nil, fmt.Errorf("Missing resolution for section ID: %s", sectionID) //nolint
+		}
+
+		switch r {
+		case head:
+			if l.section != sectionNew {
+				continue
+			}
+		case origin:
+			if l.section != sectionOld {
+				continue
+			}
+		default:
+			return nil, fmt.Errorf("Missing resolution for section ID: %s", sectionID) //nolint
+		}
+
+		if _, err := b.WriteString(l.payload); err != nil {
+			return nil, err
+		}
+
+		if l.section == sectionNoNewline {
+			continue
+		}
+		if _, err := b.WriteString("\n"); err != nil {
+			return nil, err
+		}
+	}
+
+	return b.Bytes(), nil
+}
+
+// Parse will read each line and maintain which conflict section it belongs to
+func Parse(src io.Reader, ourPath, theirPath, parentPath string) (File, error) {
+	var (
+		// conflict markers
+		start  = "<<<<<<< " + ourPath
+		middle = "======="
+		end    = ">>>>>>> " + theirPath
+
+		f                                 = File{path: parentPath}
+		objIndex, oldIndex, newIndex uint = 0, 1, 1
+		currentSection               section
+		bytesRead                    int
+
+		s = bufio.NewScanner(src)
+	)
+
+	s.Buffer(make([]byte, 4096), fileLimit) // allow for line scanning up to the file limit
+
+	s.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		bytesRead += len(data)
+		if bytesRead >= fileLimit {
+			return 0, nil, ErrUnmergeableFile
+		}
+
+		// The remaining function is a modified version of
+		// bufio.ScanLines that does not consume carriage returns
+		if atEOF && len(data) == 0 {
+			return 0, nil, nil
+		}
+		if i := bytes.IndexByte(data, '\n'); i >= 0 {
+			// We have a full newline-terminated line.
+			return i + 1, data[0:i], nil
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+	})
+
+	for s.Scan() {
+		switch l := s.Text(); l {
+		case start:
+			if currentSection != sectionNone {
+				return File{}, ErrUnexpectedDelimiter
+			}
+			currentSection = sectionNew
+		case middle:
+			if currentSection != sectionNew {
+				return File{}, ErrUnexpectedDelimiter
+			}
+			currentSection = sectionOld
+		case end:
+			if currentSection != sectionOld {
+				return File{}, ErrUnexpectedDelimiter
+			}
+			currentSection = sectionNone
+		default:
+			if len(l) > 0 && l[0] == '\\' {
+				currentSection = sectionNoNewline
+				f.lines = append(f.lines, line{
+					objIndex: objIndex,
+					oldIndex: oldIndex,
+					newIndex: newIndex,
+					payload:  l,
+					section:  currentSection,
+				})
+				continue
+			}
+			f.lines = append(f.lines, line{
+				objIndex: objIndex,
+				oldIndex: oldIndex,
+				newIndex: newIndex,
+				payload:  l,
+				section:  currentSection,
+			})
+
+			objIndex++
+			if currentSection != sectionNew {
+				oldIndex++
+			}
+			if currentSection != sectionOld {
+				newIndex++
+			}
+		}
+	}
+
+	if err := s.Err(); err != nil {
+		return File{}, err
+	}
+
+	if currentSection == sectionOld || currentSection == sectionNew {
+		return File{}, ErrMissingEndDelimiter
+	}
+
+	if bytesRead == 0 {
+		return File{}, ErrUnmergeableFile // typically a binary file
+	}
+
+	return f, nil
+}
diff --git a/internal/git/conflict/parser_test.go b/internal/git/conflict/parser_test.go
new file mode 100644
index 000000000..b15cc84cc
--- /dev/null
+++ b/internal/git/conflict/parser_test.go
@@ -0,0 +1,127 @@
+package conflict
+
+import (
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFile_Resolve(t *testing.T) {
+	for _, tt := range []struct {
+		name                           string
+		ourPath, theirPath, parentPath string
+		conflictFile                   io.Reader
+		parseErr                       error
+		resolution                     Resolution
+		resolveErr                     error
+		expect                         string
+	}{
+		{
+			name:       "ours",
+			ourPath:    "conflict.txt",
+			theirPath:  "conflict.txt",
+			parentPath: "conflict.txt",
+			conflictFile: strings.NewReader(`# this file is very conflicted
+<<<<<<< conflict.txt
+we want this line
+=======
+but they want this line
+>>>>>>> conflict.txt
+we can both agree on this line though
+`),
+			resolution: Resolution{
+				NewPath: "conflict.txt",
+				OldPath: "conflict.txt",
+				Sections: map[string]string{
+					"dc1c302824bab8da29f7c06fec1c77cf16b975e6_2_2": "head",
+				},
+			},
+			expect: `# this file is very conflicted
+we want this line
+we can both agree on this line though
+`,
+		},
+		{
+			name:       "theirs",
+			ourPath:    "conflict.txt",
+			theirPath:  "conflict.txt",
+			parentPath: "conflict.txt",
+			conflictFile: strings.NewReader(`# this file is very conflicted
+<<<<<<< conflict.txt
+we want this line
+=======
+but they want this line
+>>>>>>> conflict.txt
+we can both agree on this line though
+`),
+			resolution: Resolution{
+				NewPath: "conflict.txt",
+				OldPath: "conflict.txt",
+				Sections: map[string]string{
+					"dc1c302824bab8da29f7c06fec1c77cf16b975e6_2_2": "origin",
+				},
+			},
+			expect: `# this file is very conflicted
+but they want this line
+we can both agree on this line though
+`,
+		},
+		{
+			name:       "UnexpectedDelimiter",
+			ourPath:    "conflict.txt",
+			theirPath:  "conflict.txt",
+			parentPath: "conflict.txt",
+			conflictFile: strings.NewReader(`# this file is very conflicted
+<<<<<<< conflict.txt
+we want this line
+<<<<<<< conflict.txt
+=======
+but they want this line
+>>>>>>> conflict.txt
+we can both agree on this line though
+`),
+			parseErr: ErrUnexpectedDelimiter,
+		},
+		{
+			name:       "ErrMissingEndDelimiter",
+			ourPath:    "conflict.txt",
+			theirPath:  "conflict.txt",
+			parentPath: "conflict.txt",
+			conflictFile: strings.NewReader(`# this file is very conflicted
+<<<<<<< conflict.txt
+we want this line
+=======
+but they want this line
+we can both agree on this line though
+`),
+			parseErr: ErrMissingEndDelimiter,
+		},
+		{
+			name:         "ErrUnmergeableFile over file limit",
+			ourPath:      "conflict.txt",
+			theirPath:    "conflict.txt",
+			parentPath:   "conflict.txt",
+			conflictFile: strings.NewReader(strings.Repeat("x", fileLimit+1)),
+			parseErr:     ErrUnmergeableFile,
+		},
+		{
+			name:         "ErrUnmergeableFile empty file",
+			ourPath:      "conflict.txt",
+			theirPath:    "conflict.txt",
+			parentPath:   "conflict.txt",
+			conflictFile: strings.NewReader(""),
+			parseErr:     ErrUnmergeableFile,
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			f, err := Parse(tt.conflictFile, tt.ourPath, tt.ourPath, tt.ourPath)
+			require.Equal(t, tt.parseErr, err)
+
+			actual, err := f.Resolve(tt.resolution)
+			require.Equal(t, tt.resolveErr, err)
+			require.Equal(t, tt.expect, string(actual))
+		})
+	}
+}
diff --git a/internal/git/uploadpack.go b/internal/git/uploadpack.go
index f09481c56..7eab25d3f 100644
--- a/internal/git/uploadpack.go
+++ b/internal/git/uploadpack.go
@@ -1,10 +1,12 @@
 package git
 
+import "gitlab.com/gitlab-org/gitaly/internal/gitalyssh"
+
 // UploadPackFilterConfig confines config options that are required to allow
 // partial-clone filters.
 func UploadPackFilterConfig() []Option {
 	return []Option{
 		ValueFlag{"-c", "uploadpack.allowFilter=true"},
-		ValueFlag{"-c", "uploadpack.allowAnySHA1InWant=true"},
+		ValueFlag{"-c", gitalyssh.EnvVarUploadPackAllowAnySHA1InWant},
 	}
 }
diff --git a/internal/git2go/resolve_conflicts.go b/internal/git2go/resolve_conflicts.go
new file mode 100644
index 000000000..42d9bf642
--- /dev/null
+++ b/internal/git2go/resolve_conflicts.go
@@ -0,0 +1,66 @@
+package git2go
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"gitlab.com/gitlab-org/gitaly/internal/git/conflict"
+	"gitlab.com/gitlab-org/gitaly/internal/gitaly/config"
+)
+
+// ResolveCommand contains arguments to perform a merge commit and resolve any
+// conflicts produced from that merge commit
+type ResolveCommand struct {
+	MergeCommand `json:"merge_command"`
+	Resolutions  []conflict.Resolution `json:"conflict_files"`
+}
+
+// ResolveResult returns information about the successful merge and resolution
+type ResolveResult struct {
+	MergeResult `json:"merge_result"`
+}
+
+// ResolveResolveCommandFromSerialized deserializes a ResolveCommand and
+// verifies the arguments are valid
+func ResolveCommandFromSerialized(serialized string) (ResolveCommand, error) {
+	var request ResolveCommand
+	if err := deserialize(serialized, &request); err != nil {
+		return ResolveCommand{}, err
+	}
+
+	if err := request.verify(); err != nil {
+		return ResolveCommand{}, fmt.Errorf("resolve: %w: %s", ErrInvalidArgument, err.Error())
+	}
+
+	return request, nil
+}
+
+// Run will attempt merging and resolving conflicts for the provided request
+func (r ResolveCommand) Run(ctx context.Context, cfg config.Cfg) (ResolveResult, error) {
+	if err := r.verify(); err != nil {
+		return ResolveResult{}, fmt.Errorf("resolve: %w: %s", ErrInvalidArgument, err.Error())
+	}
+
+	serialized, err := serialize(r)
+	if err != nil {
+		return ResolveResult{}, err
+	}
+
+	stdout, err := run(ctx, binaryPathFromCfg(cfg), nil, "resolve", "-request", serialized)
+	if err != nil {
+		return ResolveResult{}, err
+	}
+
+	var response ResolveResult
+	if err := deserialize(stdout.String(), &response); err != nil {
+		return ResolveResult{}, err
+	}
+
+	return response, nil
+}
+
+// SerializeTo serializes the resolve conflict and writes it to the writer
+func (r ResolveResult) SerializeTo(w io.Writer) error {
+	return serializeTo(w, r)
+}
diff --git a/internal/gitaly/hook/referencetransaction.go b/internal/gitaly/hook/referencetransaction.go
index 0b899d21c..20c7a7143 100644
--- a/internal/gitaly/hook/referencetransaction.go
+++ b/internal/gitaly/hook/referencetransaction.go
@@ -10,6 +10,11 @@ import (
 )
 
 func (m *GitLabHookManager) ReferenceTransactionHook(ctx context.Context, state ReferenceTransactionState, env []string, stdin io.Reader) error {
+	changes, err := ioutil.ReadAll(stdin)
+	if err != nil {
+		return helper.ErrInternalf("reading stdin from request: %w", err)
+	}
+
 	// We're only voting in prepared state as this is the only stage in
 	// Git's reference transaction which allows us to abort the
 	// transaction.
@@ -17,10 +22,6 @@ func (m *GitLabHookManager) ReferenceTransactionHook(ctx context.Context, state
 		return nil
 	}
 
-	changes, err := ioutil.ReadAll(stdin)
-	if err != nil {
-		return helper.ErrInternalf("reading stdin from request: %w", err)
-	}
 	hash := sha1.Sum(changes)
 
 	if err := m.voteOnTransaction(ctx, hash[:], env); err != nil {
diff --git a/internal/gitaly/service/conflicts/resolve_conflicts.go b/internal/gitaly/service/conflicts/resolve_conflicts.go
index d8734ef8d..d4d6474ac 100644
--- a/internal/gitaly/service/conflicts/resolve_conflicts.go
+++ b/internal/gitaly/service/conflicts/resolve_conflicts.go
@@ -1,9 +1,23 @@
 package conflicts
 
 import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
+	"sort"
+	"strings"
 
+	"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus/ctxlogrus"
+	"gitlab.com/gitlab-org/gitaly/internal/git"
+	"gitlab.com/gitlab-org/gitaly/internal/git/conflict"
+	"gitlab.com/gitlab-org/gitaly/internal/git2go"
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/rubyserver"
+	"gitlab.com/gitlab-org/gitaly/internal/gitalyssh"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/internal/metadata/featureflag"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -24,6 +38,11 @@ func (s *server) ResolveConflicts(stream gitalypb.ConflictsService_ResolveConfli
 		return status.Errorf(codes.InvalidArgument, "ResolveConflicts: %v", err)
 	}
 
+	if featureflag.IsEnabled(stream.Context(), featureflag.GoResolveConflicts) {
+		err := s.resolveConflicts(header, stream)
+		return handleResolveConflictsErr(err, stream)
+	}
+
 	ctx := stream.Context()
 	client, err := s.ruby.ConflictsServiceClient(ctx)
 	if err != nil {
@@ -64,6 +83,37 @@ func (s *server) ResolveConflicts(stream gitalypb.ConflictsService_ResolveConfli
 	return stream.SendAndClose(response)
 }
 
+func handleResolveConflictsErr(err error, stream gitalypb.ConflictsService_ResolveConflictsServer) error {
+	var errStr string // normalized error message
+	if err != nil {
+		errStr = strings.TrimPrefix(err.Error(), "resolve: ") // remove subcommand artifact
+		errStr = strings.TrimSpace(errStr)                    // remove newline artifacts
+
+		// only send back resolution errors that match expected pattern
+		for _, p := range []string{
+			"Missing resolution for section ID:",
+			"Resolved content has no changes for file",
+			"Missing resolutions for the following files:",
+		} {
+			if strings.HasPrefix(errStr, p) {
+				// log the error since the interceptor won't catch this
+				// error due to the unique way the RPC is defined to
+				// handle resolution errors
+				ctxlogrus.
+					Extract(stream.Context()).
+					WithError(err).
+					Error("ResolveConflicts: unable to resolve conflict")
+				return stream.SendAndClose(&gitalypb.ResolveConflictsResponse{
+					ResolutionError: errStr,
+				})
+			}
+		}
+
+		return err
+	}
+	return stream.SendAndClose(&gitalypb.ResolveConflictsResponse{})
+}
+
 func validateResolveConflictsHeader(header *gitalypb.ResolveConflictsRequestHeader) error {
 	if header.GetOurCommitOid() == "" {
 		return fmt.Errorf("empty OurCommitOid")
@@ -89,3 +139,172 @@ func validateResolveConflictsHeader(header *gitalypb.ResolveConflictsRequestHead
 
 	return nil
 }
+
+func (s *server) resolveConflicts(header *gitalypb.ResolveConflictsRequestHeader, stream gitalypb.ConflictsService_ResolveConflictsServer) error {
+	b := bytes.NewBuffer(nil)
+	for {
+		req, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		if _, err := b.Write(req.GetFilesJson()); err != nil {
+			return err
+		}
+	}
+
+	var checkKeys []map[string]interface{}
+	if err := json.Unmarshal(b.Bytes(), &checkKeys); err != nil {
+		return err
+	}
+
+	for _, ck := range checkKeys {
+		_, sectionExists := ck["sections"]
+		_, contentExists := ck["content"]
+		if !sectionExists && !contentExists {
+			return helper.ErrInvalidArgumentf("missing sections or content for a resolution")
+		}
+	}
+
+	var resolutions []conflict.Resolution
+	if err := json.Unmarshal(b.Bytes(), &resolutions); err != nil {
+		return err
+	}
+
+	err := s.repoWithBranchCommit(
+		stream.Context(),
+		header.GetRepository(),
+		header.GetTargetRepository(),
+		header.SourceBranch,
+		header.TargetBranch,
+	)
+	if err != nil {
+		return err
+	}
+
+	repoPath, err := s.locator.GetRepoPath(header.GetRepository())
+	if err != nil {
+		return err
+	}
+
+	result, err := git2go.ResolveCommand{
+		MergeCommand: git2go.MergeCommand{
+			Repository: repoPath,
+			AuthorName: string(header.User.Name),
+			AuthorMail: string(header.User.Email),
+			Message:    string(header.CommitMessage),
+			Ours:       header.GetOurCommitOid(),
+			Theirs:     header.GetTheirCommitOid(),
+		},
+		Resolutions: resolutions,
+	}.Run(stream.Context(), s.cfg)
+	if err != nil {
+		if errors.Is(err, git2go.ErrInvalidArgument) {
+			return helper.ErrInvalidArgument(err)
+		}
+		return err
+	}
+
+	if err := git.NewRepository(header.GetRepository()).UpdateRef(
+		stream.Context(),
+		"refs/heads/"+string(header.GetSourceBranch()),
+		result.CommitID,
+		"",
+	); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func sameRepo(left, right *gitalypb.Repository) bool {
+	lgaod := left.GetGitAlternateObjectDirectories()
+	rgaod := right.GetGitAlternateObjectDirectories()
+	if len(lgaod) != len(rgaod) {
+		return false
+	}
+	sort.Strings(lgaod)
+	sort.Strings(rgaod)
+	for i := 0; i < len(lgaod); i++ {
+		if lgaod[i] != rgaod[i] {
+			return false
+		}
+	}
+	if left.GetGitObjectDirectory() != right.GetGitObjectDirectory() {
+		return false
+	}
+	if left.GetRelativePath() != right.GetRelativePath() {
+		return false
+	}
+	if left.GetStorageName() != right.GetStorageName() {
+		return false
+	}
+	return true
+}
+
+// repoWithCommit ensures that the source repo contains the same commit we
+// hope to merge with from the target branch, else it will be fetched from the
+// target repo. This is necessary since all merge/resolve logic occurs on the
+// same filesystem
+func (s *server) repoWithBranchCommit(ctx context.Context, srcRepo, targetRepo *gitalypb.Repository, srcBranch, targetBranch []byte) error {
+	const peelCommit = "^{commit}"
+
+	src := git.NewRepository(srcRepo)
+	if sameRepo(srcRepo, targetRepo) {
+		_, err := src.ResolveRefish(ctx, string(targetBranch)+peelCommit)
+		return err
+	}
+
+	target, err := git.NewRemoteRepository(ctx, targetRepo, s.pool)
+	if err != nil {
+		return err
+	}
+
+	oid, err := target.ResolveRefish(ctx, string(targetBranch)+peelCommit)
+	if err != nil {
+		return err
+	}
+
+	ok, err := src.ContainsRef(ctx, oid)
+	if err != nil {
+		return err
+	}
+	if ok {
+		// target branch commit already exists in source repo; nothing
+		// to do
+		return nil
+	}
+
+	env, err := gitalyssh.UploadPackEnv(ctx, &gitalypb.SSHUploadPackRequest{Repository: targetRepo})
+	if err != nil {
+		return err
+	}
+	// to enable fetching a specific SHA:
+	env = append(env, gitalyssh.EnvVarUploadPackAllowAnySHA1InWant)
+
+	srcRepoPath, err := s.locator.GetRepoPath(srcRepo)
+	if err != nil {
+		return err
+	}
+
+	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{}, env,
+		[]git.Option{git.ValueFlag{"--git-dir", srcRepoPath}},
+		git.SubCmd{
+			Name:  "fetch",
+			Flags: []git.Option{git.Flag{Name: "--no-tags"}},
+			Args:  []string{gitalyssh.GitalyInternalURL, oid},
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/internal/gitaly/service/conflicts/resolve_conflicts_test.go b/internal/gitaly/service/conflicts/resolve_conflicts_test.go
index 9dfc240aa..81218423c 100644
--- a/internal/gitaly/service/conflicts/resolve_conflicts_test.go
+++ b/internal/gitaly/service/conflicts/resolve_conflicts_test.go
@@ -1,6 +1,7 @@
 package conflicts_test
 
 import (
+	"context"
 	"encoding/json"
 	"net"
 	"testing"
@@ -11,6 +12,7 @@ import (
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/config"
 	serverPkg "gitlab.com/gitlab-org/gitaly/internal/gitaly/server"
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/service/conflicts"
+	"gitlab.com/gitlab-org/gitaly/internal/metadata/featureflag"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 	"google.golang.org/grpc/codes"
@@ -27,6 +29,22 @@ var (
 )
 
 func TestSuccessfulResolveConflictsRequest(t *testing.T) {
+	featureSets, err := testhelper.NewFeatureSets([]featureflag.FeatureFlag{featureflag.GoResolveConflicts})
+	require.NoError(t, err)
+	for _, featureSet := range featureSets {
+		t.Run("disabled "+featureSet.String(), func(t *testing.T) {
+			ctx, cancel := testhelper.Context()
+			defer cancel()
+
+			ctx = featureSet.Disable(ctx)
+			require.True(t, featureflag.IsEnabled(ctx, featureflag.GoResolveConflicts))
+
+			testSuccessfulResolveConflictsRequest(t, ctx)
+		})
+	}
+}
+
+func testSuccessfulResolveConflictsRequest(t *testing.T, ctx context.Context) {
 	serverSocketPath, clean := runFullServer(t)
 	defer clean()
 
@@ -39,8 +57,9 @@ func TestSuccessfulResolveConflictsRequest(t *testing.T) {
 	ctxOuter, cancel := testhelper.Context()
 	defer cancel()
 
-	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
-	ctx := metadata.NewOutgoingContext(ctxOuter, md)
+	mdGS := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	mdFF, _ := metadata.FromOutgoingContext(ctx)
+	ctx = metadata.NewOutgoingContext(ctx, metadata.Join(mdGS, mdFF))
 
 	files := []map[string]interface{}{
 		{
@@ -109,6 +128,22 @@ func TestSuccessfulResolveConflictsRequest(t *testing.T) {
 }
 
 func TestFailedResolveConflictsRequestDueToResolutionError(t *testing.T) {
+	featureSets, err := testhelper.NewFeatureSets([]featureflag.FeatureFlag{featureflag.GoResolveConflicts})
+	require.NoError(t, err)
+	for _, featureSet := range featureSets {
+		t.Run("disabled "+featureSet.String(), func(t *testing.T) {
+			ctx, cancel := testhelper.Context()
+			defer cancel()
+
+			ctx = featureSet.Disable(ctx)
+			require.True(t, featureflag.IsEnabled(ctx, featureflag.GoResolveConflicts))
+
+			testFailedResolveConflictsRequestDueToResolutionError(t, ctx)
+		})
+	}
+}
+
+func testFailedResolveConflictsRequestDueToResolutionError(t *testing.T, ctx context.Context) {
 	serverSocketPath, clean := runFullServer(t)
 	defer clean()
 
@@ -118,11 +153,9 @@ func TestFailedResolveConflictsRequestDueToResolutionError(t *testing.T) {
 	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
 	defer cleanupFn()
 
-	ctxOuter, cancel := testhelper.Context()
-	defer cancel()
-
-	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
-	ctx := metadata.NewOutgoingContext(ctxOuter, md)
+	mdGS := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	mdFF, _ := metadata.FromOutgoingContext(ctx)
+	ctx = metadata.NewOutgoingContext(ctx, metadata.Join(mdGS, mdFF))
 
 	files := []map[string]interface{}{
 		{
@@ -172,6 +205,22 @@ func TestFailedResolveConflictsRequestDueToResolutionError(t *testing.T) {
 }
 
 func TestFailedResolveConflictsRequestDueToValidation(t *testing.T) {
+	featureSets, err := testhelper.NewFeatureSets([]featureflag.FeatureFlag{featureflag.GoResolveConflicts})
+	require.NoError(t, err)
+	for _, featureSet := range featureSets {
+		t.Run("disabled "+featureSet.String(), func(t *testing.T) {
+			ctx, cancel := testhelper.Context()
+			defer cancel()
+
+			ctx = featureSet.Disable(ctx)
+			require.True(t, featureflag.IsEnabled(ctx, featureflag.GoResolveConflicts))
+
+			testFailedResolveConflictsRequestDueToValidation(t, ctx)
+		})
+	}
+}
+
+func testFailedResolveConflictsRequestDueToValidation(t *testing.T, ctx context.Context) {
 	serverSocketPath, clean := runFullServer(t)
 	defer clean()
 
@@ -181,7 +230,7 @@ func TestFailedResolveConflictsRequestDueToValidation(t *testing.T) {
 	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
 	defer cleanupFn()
 
-	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	mdGS := testhelper.GitalyServersMetadata(t, serverSocketPath)
 	ourCommitOid := "1450cd639e0bc6721eb02800169e464f212cde06"
 	theirCommitOid := "824be604a34828eb682305f0d963056cfac87b2d"
 	commitMsg := []byte(conflictResolutionCommitMessage)
@@ -288,10 +337,9 @@ func TestFailedResolveConflictsRequestDueToValidation(t *testing.T) {
 
 	for _, testCase := range testCases {
 		t.Run(testCase.desc, func(t *testing.T) {
-			ctxOuter, cancel := testhelper.Context()
-			defer cancel()
+			mdFF, _ := metadata.FromOutgoingContext(ctx)
+			ctx = metadata.NewOutgoingContext(ctx, metadata.Join(mdGS, mdFF))
 
-			ctx := metadata.NewOutgoingContext(ctxOuter, md)
 			stream, err := client.ResolveConflicts(ctx)
 			require.NoError(t, err)
 
diff --git a/internal/gitaly/service/conflicts/server.go b/internal/gitaly/service/conflicts/server.go
index 91bd935d3..36e9c9a6b 100644
--- a/internal/gitaly/service/conflicts/server.go
+++ b/internal/gitaly/service/conflicts/server.go
@@ -1,6 +1,7 @@
 package conflicts
 
 import (
+	"gitlab.com/gitlab-org/gitaly/client"
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/config"
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/internal/storage"
@@ -11,6 +12,7 @@ type server struct {
 	ruby    *rubyserver.Server
 	cfg     config.Cfg
 	locator storage.Locator
+	pool    *client.Pool
 }
 
 // NewServer creates a new instance of a grpc ConflictsServer
@@ -19,5 +21,6 @@ func NewServer(rs *rubyserver.Server, cfg config.Cfg, locator storage.Locator) g
 		ruby:    rs,
 		cfg:     cfg,
 		locator: locator,
+		pool:    client.NewPool(),
 	}
 }
diff --git a/internal/gitaly/service/operations/merge.go b/internal/gitaly/service/operations/merge.go
index f186a33e9..6d2f2b3e5 100644
--- a/internal/gitaly/service/operations/merge.go
+++ b/internal/gitaly/service/operations/merge.go
@@ -437,7 +437,7 @@ func (s *server) userMergeToRef(ctx context.Context, request *gitalypb.UserMerge
 			return nil, helper.ErrInvalidArgument(err)
 		}
 		//nolint:stylecheck
-		return nil, fmt.Errorf("Failed to create merge commit for source_sha %s and target_sha %s at %s", sourceRef, string(request.TargetRef), refName)
+		return nil, helper.ErrPreconditionFailed(fmt.Errorf("Failed to create merge commit for source_sha %s and target_sha %s at %s", sourceRef, string(request.TargetRef), refName))
 	}
 
 	// ... and move branch from target ref to the merge commit. The Ruby
diff --git a/internal/gitaly/service/operations/merge_test.go b/internal/gitaly/service/operations/merge_test.go
index d165c6f27..19d9b6c04 100644
--- a/internal/gitaly/service/operations/merge_test.go
+++ b/internal/gitaly/service/operations/merge_test.go
@@ -681,6 +681,7 @@ func testConflictsOnUserMergeToRefRequest(t *testing.T, ctx context.Context) {
 
 		_, err := client.UserMergeToRef(ctx, request)
 		require.Error(t, err)
+		testhelper.RequireGrpcError(t, err, codes.FailedPrecondition)
 	})
 }
 
diff --git a/internal/gitaly/service/remote/fetch_internal_remote.go b/internal/gitaly/service/remote/fetch_internal_remote.go
index eba82e680..fe0d7bdd5 100644
--- a/internal/gitaly/service/remote/fetch_internal_remote.go
+++ b/internal/gitaly/service/remote/fetch_internal_remote.go
@@ -17,8 +17,7 @@ import (
 )
 
 const (
-	gitalyInternalURL = "ssh://gitaly/internal.git"
-	mirrorRefSpec     = "+refs/*:refs/*"
+	mirrorRefSpec = "+refs/*:refs/*"
 )
 
 // FetchInternalRemote fetches another Gitaly repository set as a remote
@@ -36,7 +35,7 @@ func (s *server) FetchInternalRemote(ctx context.Context, req *gitalypb.FetchInt
 		git.SubCmd{
 			Name:  "fetch",
 			Flags: []git.Option{git.Flag{Name: "--prune"}},
-			Args:  []string{gitalyInternalURL, mirrorRefSpec},
+			Args:  []string{gitalyssh.GitalyInternalURL, mirrorRefSpec},
 		},
 	)
 	if err != nil {
diff --git a/internal/gitaly/service/repository/fetch.go b/internal/gitaly/service/repository/fetch.go
index deaf60b5f..6a7eb653e 100644
--- a/internal/gitaly/service/repository/fetch.go
+++ b/internal/gitaly/service/repository/fetch.go
@@ -38,7 +38,7 @@ func (s *server) FetchSourceBranch(ctx context.Context, req *gitalypb.FetchSourc
 	if helper.RepoPathEqual(req.GetRepository(), req.GetSourceRepository()) {
 		remote = "file://" + repoPath
 	} else {
-		remote = gitalyInternalURL
+		remote = gitalyssh.GitalyInternalURL
 		env, err = gitalyssh.UploadPackEnv(ctx, &gitalypb.SSHUploadPackRequest{Repository: req.SourceRepository})
 		if err != nil {
 			return nil, err
diff --git a/internal/gitaly/service/repository/fork.go b/internal/gitaly/service/repository/fork.go
index 2ec3abd98..7d46acc66 100644
--- a/internal/gitaly/service/repository/fork.go
+++ b/internal/gitaly/service/repository/fork.go
@@ -12,8 +12,6 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-const gitalyInternalURL = "ssh://gitaly/internal.git"
-
 func (s *server) CreateFork(ctx context.Context, req *gitalypb.CreateForkRequest) (*gitalypb.CreateForkResponse, error) {
 	targetRepository := req.Repository
 	sourceRepository := req.SourceRepository
@@ -47,7 +45,7 @@ func (s *server) CreateFork(ctx context.Context, req *gitalypb.CreateForkRequest
 		Name:  "clone",
 		Flags: []git.Option{git.Flag{Name: "--bare"}, git.Flag{Name: "--no-local"}},
 		PostSepArgs: []string{
-			fmt.Sprintf("%s:%s", gitalyInternalURL, sourceRepository.RelativePath),
+			fmt.Sprintf("%s:%s", gitalyssh.GitalyInternalURL, sourceRepository.RelativePath),
 			targetRepositoryFullPath,
 		},
 	})
diff --git a/internal/gitaly/service/repository/server.go b/internal/gitaly/service/repository/server.go
index cd0a4f4a5..020f37b8f 100644
--- a/internal/gitaly/service/repository/server.go
+++ b/internal/gitaly/service/repository/server.go
@@ -1,12 +1,9 @@
 package repository
 
 import (
-	"context"
-
 	"gitlab.com/gitlab-org/gitaly/client"
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/config"
 	"gitlab.com/gitlab-org/gitaly/internal/gitaly/rubyserver"
-	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/storage"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
@@ -31,7 +28,3 @@ func NewServer(cfg config.Cfg, rs *rubyserver.Server, locator storage.Locator, i
 		binDir:               cfg.BinDir,
 	}
 }
-
-func (*server) FetchHTTPRemote(context.Context, *gitalypb.FetchHTTPRemoteRequest) (*gitalypb.FetchHTTPRemoteResponse, error) {
-	return nil, helper.Unimplemented
-}
diff --git a/internal/gitalyssh/gitalyssh.go b/internal/gitalyssh/gitalyssh.go
index bc533f52e..9d78bc422 100644
--- a/internal/gitalyssh/gitalyssh.go
+++ b/internal/gitalyssh/gitalyssh.go
@@ -22,6 +22,18 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+const (
+	// GitalyInternalURL is a special URL that indicates Gitaly wants to
+	// push or fetch to another Gitaly instance
+	GitalyInternalURL = "ssh://gitaly/internal.git"
+)
+
+const (
+	// EnvVarUploadPackAllowAnySHA1InWant enables the capability to request
+	// individual SHA1's from the remote repo
+	EnvVarUploadPackAllowAnySHA1InWant = "uploadpack.allowAnySHA1InWant=true"
+)
+
 var (
 	envInjector       = tracing.NewEnvInjector()
 	correlationIDRand = rand.New(rand.NewSource(time.Now().UnixNano()))
diff --git a/internal/metadata/featureflag/feature_flags.go b/internal/metadata/featureflag/feature_flags.go
index 6ebb59a35..94ecf25f4 100644
--- a/internal/metadata/featureflag/feature_flags.go
+++ b/internal/metadata/featureflag/feature_flags.go
@@ -34,6 +34,8 @@ var (
 	GoListConflictFiles = FeatureFlag{Name: "go_list_conflict_files", OnByDefault: false}
 	// GoUserCommitFiles enables the Go implementation of UserCommitFiles
 	GoUserCommitFiles = FeatureFlag{Name: "go_user_commit_files", OnByDefault: false}
+	// GoResolveConflicts enables the Go implementation of ResolveConflicts
+	GoResolveConflicts = FeatureFlag{Name: "go_resolve_conflicts", OnByDefault: false}
 )
 
 // All includes all feature flags.
@@ -49,6 +51,7 @@ var All = []FeatureFlag{
 	GoUserSquash,
 	GoListConflictFiles,
 	GoUserCommitFiles,
+	GoResolveConflicts,
 }
 
 const (
diff --git a/internal/praefect/protoregistry/protoregistry_test.go b/internal/praefect/protoregistry/protoregistry_test.go
index 00ecb31f7..8c5c56e2e 100644
--- a/internal/praefect/protoregistry/protoregistry_test.go
+++ b/internal/praefect/protoregistry/protoregistry_test.go
@@ -149,7 +149,6 @@ func TestNewProtoRegistry(t *testing.T) {
 			"SearchFilesByName":            protoregistry.OpAccessor,
 			"RestoreCustomHooks":           protoregistry.OpMutator,
 			"BackupCustomHooks":            protoregistry.OpAccessor,
-			"FetchHTTPRemote":              protoregistry.OpMutator,
 		},
 		"SmartHTTPService": map[string]protoregistry.OpType{
 			"InfoRefsUploadPack":  protoregistry.OpAccessor,
diff --git a/proto/README.md b/proto/README.md
index 99fef6b6f..4216c18a4 100644
--- a/proto/README.md
+++ b/proto/README.md
@@ -273,6 +273,16 @@ you forget to add a `go_package` option, you may receive an error similar to:
 
 `blob.proto is missing the go_package option`
 
+### Documentation
+
+New or updated RPCs and message types should be accompanied by comment strings.
+Good comment strings will explain why the RPC exists and how it behaves. Good
+message type comments will explain what the message is communicating. Each updated
+message field should have a comment.
+
+Refer to official protobuf documentation for
+[how to add comments](https://developers.google.com/protocol-buffers/docs/proto#adding_comments).
+
 ## Contributing
 
 The CI at https://gitlab.com/gitlab-org/gitaly-proto regenerates the
diff --git a/proto/go/gitalypb/repository-service.pb.go b/proto/go/gitalypb/repository-service.pb.go
index 50ea46957..02f3a323b 100644
--- a/proto/go/gitalypb/repository-service.pb.go
+++ b/proto/go/gitalypb/repository-service.pb.go
@@ -3367,92 +3367,6 @@ func (m *Remote) GetMirrorRefmaps() []string {
 	return nil
 }
 
-type FetchHTTPRemoteRequest struct {
-	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	Remote               *Remote     `protobuf:"bytes,2,opt,name=remote,proto3" json:"remote,omitempty"`
-	Timeout              int32       `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
-}
-
-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{71}
-}
-
-func (m *FetchHTTPRemoteRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FetchHTTPRemoteRequest.Unmarshal(m, b)
-}
-func (m *FetchHTTPRemoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FetchHTTPRemoteRequest.Marshal(b, m, deterministic)
-}
-func (m *FetchHTTPRemoteRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FetchHTTPRemoteRequest.Merge(m, src)
-}
-func (m *FetchHTTPRemoteRequest) XXX_Size() int {
-	return xxx_messageInfo_FetchHTTPRemoteRequest.Size(m)
-}
-func (m *FetchHTTPRemoteRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_FetchHTTPRemoteRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FetchHTTPRemoteRequest proto.InternalMessageInfo
-
-func (m *FetchHTTPRemoteRequest) GetRepository() *Repository {
-	if m != nil {
-		return m.Repository
-	}
-	return nil
-}
-
-func (m *FetchHTTPRemoteRequest) GetRemote() *Remote {
-	if m != nil {
-		return m.Remote
-	}
-	return nil
-}
-
-func (m *FetchHTTPRemoteRequest) GetTimeout() int32 {
-	if m != nil {
-		return m.Timeout
-	}
-	return 0
-}
-
-type FetchHTTPRemoteResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-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{72}
-}
-
-func (m *FetchHTTPRemoteResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FetchHTTPRemoteResponse.Unmarshal(m, b)
-}
-func (m *FetchHTTPRemoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FetchHTTPRemoteResponse.Marshal(b, m, deterministic)
-}
-func (m *FetchHTTPRemoteResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FetchHTTPRemoteResponse.Merge(m, src)
-}
-func (m *FetchHTTPRemoteResponse) XXX_Size() int {
-	return xxx_messageInfo_FetchHTTPRemoteResponse.Size(m)
-}
-func (m *FetchHTTPRemoteResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_FetchHTTPRemoteResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FetchHTTPRemoteResponse proto.InternalMessageInfo
-
 type GetObjectDirectorySizeRequest struct {
 	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
@@ -3464,7 +3378,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{73}
+	return fileDescriptor_e9b1768cf174c79b, []int{71}
 }
 
 func (m *GetObjectDirectorySizeRequest) XXX_Unmarshal(b []byte) error {
@@ -3504,7 +3418,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{74}
+	return fileDescriptor_e9b1768cf174c79b, []int{72}
 }
 
 func (m *GetObjectDirectorySizeResponse) XXX_Unmarshal(b []byte) error {
@@ -3545,7 +3459,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{75}
+	return fileDescriptor_e9b1768cf174c79b, []int{73}
 }
 
 func (m *CloneFromPoolRequest) XXX_Unmarshal(b []byte) error {
@@ -3597,7 +3511,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{76}
+	return fileDescriptor_e9b1768cf174c79b, []int{74}
 }
 
 func (m *CloneFromPoolResponse) XXX_Unmarshal(b []byte) error {
@@ -3631,7 +3545,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{77}
+	return fileDescriptor_e9b1768cf174c79b, []int{75}
 }
 
 func (m *CloneFromPoolInternalRequest) XXX_Unmarshal(b []byte) error {
@@ -3683,7 +3597,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{78}
+	return fileDescriptor_e9b1768cf174c79b, []int{76}
 }
 
 func (m *CloneFromPoolInternalResponse) XXX_Unmarshal(b []byte) error {
@@ -3715,7 +3629,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{79}
+	return fileDescriptor_e9b1768cf174c79b, []int{77}
 }
 
 func (m *RemoveRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3753,7 +3667,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{80}
+	return fileDescriptor_e9b1768cf174c79b, []int{78}
 }
 
 func (m *RemoveRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3786,7 +3700,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{81}
+	return fileDescriptor_e9b1768cf174c79b, []int{79}
 }
 
 func (m *RenameRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3831,7 +3745,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{82}
+	return fileDescriptor_e9b1768cf174c79b, []int{80}
 }
 
 func (m *RenameRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3864,7 +3778,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{83}
+	return fileDescriptor_e9b1768cf174c79b, []int{81}
 }
 
 func (m *ReplicateRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3909,7 +3823,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{84}
+	return fileDescriptor_e9b1768cf174c79b, []int{82}
 }
 
 func (m *ReplicateRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3941,7 +3855,7 @@ func (m *OptimizeRepositoryRequest) Reset()         { *m = OptimizeRepositoryReq
 func (m *OptimizeRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*OptimizeRepositoryRequest) ProtoMessage()    {}
 func (*OptimizeRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{85}
+	return fileDescriptor_e9b1768cf174c79b, []int{83}
 }
 
 func (m *OptimizeRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3979,7 +3893,7 @@ func (m *OptimizeRepositoryResponse) Reset()         { *m = OptimizeRepositoryRe
 func (m *OptimizeRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*OptimizeRepositoryResponse) ProtoMessage()    {}
 func (*OptimizeRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{86}
+	return fileDescriptor_e9b1768cf174c79b, []int{84}
 }
 
 func (m *OptimizeRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -4076,8 +3990,6 @@ func init() {
 	proto.RegisterType((*SearchFilesByContentRequest)(nil), "gitaly.SearchFilesByContentRequest")
 	proto.RegisterType((*SearchFilesByContentResponse)(nil), "gitaly.SearchFilesByContentResponse")
 	proto.RegisterType((*Remote)(nil), "gitaly.Remote")
-	proto.RegisterType((*FetchHTTPRemoteRequest)(nil), "gitaly.FetchHTTPRemoteRequest")
-	proto.RegisterType((*FetchHTTPRemoteResponse)(nil), "gitaly.FetchHTTPRemoteResponse")
 	proto.RegisterType((*GetObjectDirectorySizeRequest)(nil), "gitaly.GetObjectDirectorySizeRequest")
 	proto.RegisterType((*GetObjectDirectorySizeResponse)(nil), "gitaly.GetObjectDirectorySizeResponse")
 	proto.RegisterType((*CloneFromPoolRequest)(nil), "gitaly.CloneFromPoolRequest")
@@ -4097,201 +4009,199 @@ func init() {
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor_e9b1768cf174c79b) }
 
 var fileDescriptor_e9b1768cf174c79b = []byte{
-	// 3104 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4b, 0x6f, 0x1c, 0xc7,
-	0xf1, 0xd7, 0xf2, 0xb1, 0x8f, 0xe2, 0x4a, 0x5a, 0x36, 0x29, 0x72, 0x39, 0x22, 0x45, 0x69, 0x24,
-	0xcb, 0xb2, 0x2c, 0x53, 0xb6, 0xf4, 0x07, 0xfe, 0x4e, 0x82, 0x20, 0xe0, 0xf2, 0x2d, 0x89, 0x0f,
-	0x0f, 0xa9, 0x18, 0x16, 0x60, 0x8c, 0x67, 0x67, 0x7b, 0xb9, 0x13, 0xce, 0xce, 0xac, 0x7a, 0x7a,
-	0x45, 0xd1, 0x40, 0x0e, 0x09, 0x90, 0x5b, 0x60, 0x20, 0x40, 0x10, 0xe7, 0x98, 0x73, 0xbe, 0x40,
-	0x72, 0x09, 0x82, 0x5c, 0xf2, 0x1d, 0xfc, 0x15, 0xf2, 0x11, 0x72, 0x0a, 0xfa, 0x31, 0xd3, 0xf3,
-	0x5c, 0x2b, 0xe0, 0xc2, 0xb9, 0x4d, 0x57, 0x77, 0x57, 0x55, 0x57, 0x57, 0x75, 0x77, 0xfd, 0x6a,
-	0xa0, 0x49, 0xf0, 0xc0, 0x0f, 0x1c, 0xea, 0x93, 0x8b, 0x8f, 0x02, 0x4c, 0xde, 0x38, 0x36, 0x5e,
-	0x1b, 0x10, 0x9f, 0xfa, 0xa8, 0x7c, 0xea, 0x50, 0xcb, 0xbd, 0xd0, 0xc0, 0x75, 0x3c, 0x2a, 0x68,
-	0x5a, 0x3d, 0xe8, 0x59, 0x04, 0x77, 0x44, 0x4b, 0x3f, 0x86, 0x45, 0x23, 0x9a, 0xbd, 0xf5, 0xd6,
-	0x09, 0x68, 0x60, 0xe0, 0xd7, 0x43, 0x1c, 0x50, 0xf4, 0x29, 0x80, 0x62, 0xdc, 0x2c, 0xdd, 0x2e,
-	0x3d, 0x98, 0x79, 0x82, 0xd6, 0x04, 0xc7, 0x35, 0x35, 0xa9, 0x35, 0xf5, 0xc7, 0x7f, 0x3e, 0x2a,
-	0x19, 0xb1, 0xb1, 0xfa, 0x13, 0x68, 0x66, 0x99, 0x06, 0x03, 0xdf, 0x0b, 0x30, 0x5a, 0x80, 0x32,
-	0xe6, 0x14, 0xce, 0xb1, 0x6a, 0xc8, 0x96, 0x7e, 0xc2, 0xe7, 0x58, 0xf6, 0xd9, 0x9e, 0x67, 0x13,
-	0xdc, 0xc7, 0x1e, 0xb5, 0xdc, 0xcb, 0x6b, 0x72, 0x13, 0x96, 0x72, 0xb8, 0x0a, 0x55, 0x74, 0x02,
-	0xb3, 0xa2, 0x73, 0x7b, 0xe8, 0x5e, 0x5e, 0x16, 0xba, 0x0b, 0x57, 0x6d, 0x82, 0x2d, 0x8a, 0xcd,
-	0xb6, 0x43, 0xfb, 0xd6, 0xa0, 0x39, 0xc1, 0x17, 0x58, 0x17, 0xc4, 0x16, 0xa7, 0xe9, 0xf3, 0x80,
-	0xe2, 0x32, 0xa5, 0x26, 0xfb, 0x30, 0xbb, 0xef, 0x74, 0xde, 0x8a, 0x9e, 0xcb, 0xaf, 0x7a, 0x1e,
-	0x50, 0x9c, 0x9d, 0x14, 0xf2, 0xdb, 0x12, 0xdc, 0xd8, 0xb1, 0x48, 0xdb, 0x3a, 0xc5, 0x1b, 0xbe,
-	0xeb, 0x62, 0x9b, 0xfe, 0x30, 0x6b, 0x46, 0xf3, 0x30, 0x3d, 0x20, 0x43, 0x0f, 0x37, 0x27, 0x79,
-	0xa7, 0x68, 0xe8, 0x4d, 0x58, 0x48, 0x6b, 0x23, 0x15, 0x3d, 0x86, 0xc5, 0xcf, 0x89, 0x43, 0xf1,
-	0x86, 0xdf, 0xef, 0x3b, 0x74, 0x87, 0x58, 0x83, 0xde, 0xe5, 0x6d, 0xa2, 0x41, 0x33, 0xcb, 0x54,
-	0x0a, 0x7c, 0x06, 0xd7, 0x36, 0x5c, 0x6c, 0x79, 0xc3, 0xc1, 0xe5, 0xe5, 0xcc, 0xc2, 0xf5, 0x88,
-	0x97, 0x64, 0xff, 0x19, 0xdc, 0x50, 0x53, 0x8e, 0x9d, 0xaf, 0xf1, 0xe5, 0xa5, 0x3c, 0x82, 0x85,
-	0x34, 0x4b, 0x19, 0x5f, 0x08, 0xa6, 0x02, 0xe7, 0x6b, 0xcc, 0xb9, 0x4d, 0x1a, 0xfc, 0x5b, 0x7f,
-	0x0d, 0x4b, 0xeb, 0x83, 0x81, 0x7b, 0xb1, 0xe3, 0x50, 0x8b, 0x52, 0xe2, 0xb4, 0x87, 0x14, 0x5f,
-	0x3e, 0xcc, 0x91, 0x06, 0x55, 0x82, 0xdf, 0x38, 0x81, 0xe3, 0x7b, 0x7c, 0xdf, 0xeb, 0x46, 0xd4,
-	0xd6, 0x97, 0x41, 0xcb, 0x13, 0x29, 0x2d, 0xf2, 0xf7, 0x09, 0x40, 0xdb, 0x98, 0xda, 0x3d, 0x03,
-	0xf7, 0x7d, 0x7a, 0x79, 0x7b, 0xb0, 0x53, 0x85, 0x70, 0x56, 0x5c, 0x91, 0x9a, 0x21, 0x5b, 0xcc,
-	0xf5, 0xba, 0x3e, 0xb1, 0x23, 0xd7, 0xe3, 0x0d, 0xb4, 0x08, 0x15, 0xcf, 0x37, 0xa9, 0x75, 0x1a,
-	0x34, 0xa7, 0xc4, 0x21, 0xe4, 0xf9, 0x27, 0xd6, 0x69, 0x80, 0x9a, 0x50, 0xa1, 0x4e, 0x1f, 0xfb,
-	0x43, 0xda, 0x9c, 0xbe, 0x5d, 0x7a, 0x30, 0x6d, 0x84, 0x4d, 0x36, 0x25, 0x08, 0x7a, 0xe6, 0x19,
-	0xbe, 0x68, 0x96, 0x85, 0x84, 0x20, 0xe8, 0x3d, 0xc7, 0x17, 0x68, 0x15, 0x66, 0xce, 0x3c, 0xff,
-	0xdc, 0x33, 0x7b, 0x3e, 0x3b, 0xd4, 0x2a, 0xbc, 0x13, 0x38, 0x69, 0x97, 0x51, 0xd0, 0x12, 0x54,
-	0x3d, 0xdf, 0x14, 0x01, 0x50, 0xe3, 0xd2, 0x2a, 0x9e, 0x7f, 0xc4, 0x9a, 0xe8, 0x29, 0x5c, 0x15,
-	0x7a, 0x9a, 0x03, 0x8b, 0x58, 0xfd, 0xa0, 0x09, 0x7c, 0xc9, 0xd7, 0xd4, 0x92, 0xb9, 0x75, 0xea,
-	0x62, 0xd0, 0x11, 0x1f, 0xf3, 0x6c, 0xaa, 0x5a, 0x6d, 0xd4, 0xf4, 0x1b, 0x30, 0x97, 0x30, 0xa0,
-	0x0a, 0x9d, 0x0d, 0x1e, 0x7a, 0xca, 0x5a, 0x63, 0x09, 0x9d, 0x2c, 0x53, 0x29, 0xf0, 0x5f, 0x13,
-	0x30, 0xbb, 0x83, 0xe9, 0x3a, 0xb1, 0x7b, 0xce, 0x9b, 0x31, 0x6c, 0xe4, 0x4d, 0xa8, 0xd9, 0x3c,
-	0x42, 0x4d, 0xa7, 0x23, 0xf7, 0xb2, 0x2a, 0x08, 0x7b, 0x1d, 0xb6, 0xcb, 0x03, 0x82, 0xbb, 0xce,
-	0x5b, 0xbe, 0x9d, 0x35, 0x43, 0xb6, 0xd0, 0xa7, 0x50, 0xee, 0xfa, 0xa4, 0x6f, 0x51, 0xbe, 0x9d,
-	0xd7, 0x9e, 0xdc, 0x0e, 0x45, 0x65, 0x34, 0x5b, 0xdb, 0xe6, 0xe3, 0x0c, 0x39, 0x9e, 0x45, 0xcb,
-	0xc0, 0xa2, 0x3d, 0xbe, 0xdb, 0x75, 0x83, 0x7f, 0x33, 0x27, 0xc0, 0x6f, 0x6d, 0x77, 0xd8, 0xc1,
-	0xcd, 0xf2, 0xed, 0xc9, 0x07, 0x75, 0x23, 0x6c, 0xa2, 0x15, 0x00, 0xec, 0x3a, 0x1d, 0xb6, 0x5d,
-	0xb4, 0xc7, 0xb7, 0xba, 0x6a, 0xd4, 0x38, 0xe5, 0x88, 0x4d, 0x7c, 0x08, 0xb3, 0x8e, 0xc7, 0x47,
-	0x9a, 0x6e, 0x37, 0x30, 0xdb, 0xae, 0xdf, 0x0e, 0x9a, 0x55, 0x3e, 0xea, 0xba, 0xec, 0x78, 0xd1,
-	0x0d, 0x5a, 0x8c, 0xac, 0x3f, 0x85, 0xb2, 0x50, 0x05, 0x55, 0x60, 0xf2, 0xd5, 0xde, 0x51, 0xe3,
-	0x0a, 0xfb, 0x38, 0x59, 0x37, 0x1a, 0x25, 0x04, 0x50, 0x3e, 0x59, 0x37, 0xcc, 0x9d, 0x57, 0x8d,
-	0x09, 0x34, 0x03, 0x15, 0xf6, 0xdd, 0x7a, 0xf5, 0xa4, 0x31, 0xa9, 0x3f, 0x00, 0x14, 0x5f, 0x91,
-	0x8a, 0xf8, 0x8e, 0x45, 0x2d, 0x6e, 0xe6, 0xba, 0xc1, 0xbf, 0x99, 0x1f, 0xec, 0x5a, 0xc1, 0x0b,
-	0xdf, 0xb6, 0xdc, 0x16, 0xb1, 0x3c, 0xbb, 0x37, 0x86, 0x78, 0xd7, 0x3f, 0x86, 0x66, 0x96, 0xa9,
-	0x54, 0x62, 0x1e, 0xa6, 0xdf, 0x58, 0xee, 0x10, 0xcb, 0x5b, 0x5d, 0x34, 0xf4, 0xef, 0x4a, 0xd0,
-	0xe4, 0x6e, 0x7a, 0xec, 0x0f, 0x89, 0x8d, 0xc5, 0xac, 0xcb, 0x3b, 0xc9, 0xcf, 0x60, 0x36, 0xe0,
-	0x0c, 0xcd, 0x18, 0x83, 0x89, 0x22, 0x06, 0x46, 0x43, 0x0c, 0x36, 0x12, 0xd7, 0x96, 0x64, 0xd0,
-	0xe6, 0x2a, 0x71, 0x7f, 0xaa, 0x1b, 0xf5, 0x20, 0xa6, 0x26, 0xdb, 0x6d, 0x6a, 0x91, 0x53, 0x4c,
-	0x4d, 0x82, 0xbb, 0xdc, 0xb3, 0xea, 0x46, 0x4d, 0x50, 0x0c, 0xdc, 0xd5, 0x9f, 0xc2, 0x52, 0xce,
-	0xd2, 0xd4, 0x2b, 0x87, 0xe0, 0x60, 0xe8, 0xd2, 0xf0, 0x95, 0x23, 0x5a, 0xfa, 0x0e, 0xcc, 0x6c,
-	0x07, 0xe3, 0xb8, 0xe2, 0xef, 0x41, 0x5d, 0x30, 0x52, 0xf6, 0xc7, 0x84, 0xf8, 0x44, 0x7a, 0x81,
-	0x68, 0xe8, 0x7f, 0x2d, 0xc1, 0x75, 0x7e, 0xeb, 0x19, 0xb8, 0x7b, 0x79, 0xb3, 0x37, 0x60, 0x92,
-	0x59, 0x42, 0x1c, 0xf5, 0xec, 0x33, 0x71, 0x03, 0x4c, 0x26, 0x6f, 0x00, 0x74, 0x07, 0xea, 0xbe,
-	0xdb, 0x31, 0xa3, 0x7e, 0x61, 0xc0, 0x19, 0xdf, 0xed, 0x18, 0xe1, 0x90, 0xe8, 0x74, 0x9e, 0x8e,
-	0x9d, 0xce, 0xcf, 0xa6, 0xaa, 0xe5, 0x46, 0x45, 0x6f, 0x42, 0x43, 0x69, 0x2e, 0x16, 0xf9, 0x6c,
-	0xaa, 0x5a, 0x6a, 0x4c, 0xe8, 0x1e, 0xcc, 0x6f, 0x3b, 0x5e, 0x67, 0x1f, 0x93, 0x53, 0xdc, 0xb2,
-	0x82, 0x31, 0x1c, 0x3a, 0xcb, 0x50, 0x0b, 0xd5, 0x0c, 0x9a, 0x13, 0x3c, 0xe6, 0x15, 0x41, 0xff,
-	0x10, 0x6e, 0xa4, 0xe4, 0xa9, 0xc0, 0x6b, 0x5b, 0x81, 0x70, 0xf9, 0x9a, 0xc1, 0xbf, 0xf5, 0x6f,
-	0x4a, 0x30, 0x2b, 0x0e, 0xcb, 0x6d, 0x9f, 0x9c, 0xfd, 0xef, 0x5d, 0x9d, 0xbd, 0x05, 0xe3, 0xfa,
-	0x44, 0x4f, 0xdf, 0xa5, 0xbd, 0xc0, 0xc0, 0x4c, 0xe5, 0x3d, 0xef, 0x88, 0xf8, 0xa7, 0x04, 0x07,
-	0xc1, 0x58, 0x4e, 0x6f, 0xc2, 0x99, 0xc6, 0x4e, 0x6f, 0x41, 0xd8, 0xeb, 0xe8, 0x3f, 0x05, 0x2d,
-	0x4f, 0xa6, 0x34, 0xe6, 0x2a, 0xcc, 0x38, 0x9e, 0x39, 0x90, 0x64, 0x19, 0x36, 0xe0, 0x44, 0x03,
-	0x85, 0xca, 0xc7, 0xaf, 0x87, 0x56, 0xd0, 0x1b, 0xb3, 0xca, 0x01, 0x67, 0x1a, 0x53, 0x59, 0x10,
-	0x42, 0x95, 0xb3, 0x32, 0xdf, 0x55, 0x65, 0x17, 0x6e, 0xa5, 0x2f, 0xce, 0x6d, 0xe2, 0xf7, 0x5f,
-	0x1a, 0x2f, 0xc6, 0x12, 0x8c, 0x43, 0xe2, 0x4a, 0x8d, 0xd9, 0xa7, 0x7e, 0x07, 0x56, 0x0b, 0xa5,
-	0xc9, 0x6d, 0x3f, 0x84, 0x39, 0x31, 0xa4, 0x35, 0xf4, 0x3a, 0xee, 0x18, 0xde, 0xa1, 0x0f, 0x61,
-	0x3e, 0xc9, 0x70, 0xc4, 0x9d, 0xf4, 0xcd, 0x04, 0x34, 0x8e, 0x31, 0xdd, 0xf0, 0xbd, 0xae, 0x73,
-	0x7a, 0x79, 0x03, 0x7c, 0x0a, 0x15, 0xec, 0x51, 0xe2, 0x60, 0x11, 0xb2, 0x33, 0x4f, 0x6e, 0x85,
-	0xd3, 0xd2, 0x42, 0xd6, 0xb6, 0x3c, 0x4a, 0x2e, 0x8c, 0x70, 0xb8, 0xf6, 0x9b, 0x12, 0x4c, 0x73,
-	0x12, 0x33, 0x22, 0x7b, 0xd1, 0x89, 0x00, 0x66, 0x9f, 0x68, 0x05, 0x6a, 0xfc, 0xea, 0x32, 0x03,
-	0x4a, 0x84, 0x71, 0x77, 0xaf, 0x18, 0x55, 0x4e, 0x3a, 0xa6, 0x04, 0xdd, 0x81, 0x19, 0xd1, 0xed,
-	0x78, 0xf4, 0xe9, 0x13, 0x7e, 0xe6, 0x4d, 0xef, 0x5e, 0x31, 0x80, 0x13, 0xf7, 0x18, 0x0d, 0xad,
-	0x82, 0x68, 0x99, 0x6d, 0xdf, 0x77, 0xc5, 0xfb, 0x72, 0xf7, 0x8a, 0x21, 0xb8, 0xb6, 0x7c, 0xdf,
-	0x6d, 0x55, 0xe4, 0x55, 0xa9, 0xcf, 0xc1, 0x6c, 0x4c, 0x55, 0xb9, 0x45, 0x36, 0xcc, 0x6d, 0x62,
-	0x17, 0xb3, 0x44, 0x65, 0x3c, 0x76, 0x42, 0x30, 0x75, 0x86, 0x2f, 0x84, 0x91, 0x6a, 0x06, 0xff,
-	0xd6, 0x17, 0x60, 0x3e, 0x29, 0x44, 0x0a, 0x77, 0x58, 0xba, 0x1c, 0x50, 0x9f, 0xe0, 0x8d, 0x61,
-	0x40, 0xfd, 0xfe, 0xae, 0xef, 0x9f, 0x05, 0x63, 0x51, 0x81, 0x7b, 0xc3, 0x44, 0xcc, 0x1b, 0x96,
-	0x41, 0xcb, 0x13, 0x25, 0x15, 0x39, 0x81, 0x66, 0xcb, 0xb2, 0xcf, 0x86, 0x83, 0x71, 0xea, 0xa1,
-	0x3f, 0x86, 0xa5, 0x1c, 0xae, 0x23, 0x5c, 0xf6, 0x35, 0xdc, 0xc9, 0x0b, 0xa9, 0x31, 0x45, 0x4f,
-	0xae, 0x5d, 0xee, 0x81, 0x3e, 0x4a, 0xa4, 0xb4, 0xcf, 0x01, 0x20, 0x76, 0x27, 0xbd, 0x70, 0x6c,
-	0xec, 0x8d, 0xe1, 0x06, 0xd4, 0x37, 0x60, 0x2e, 0xc1, 0x4f, 0xda, 0xe4, 0x11, 0x20, 0x57, 0x90,
-	0xcc, 0xa0, 0xe7, 0x13, 0x6a, 0x7a, 0x56, 0x3f, 0xbc, 0xef, 0x1a, 0xb2, 0xe7, 0x98, 0x75, 0x1c,
-	0x58, 0x7d, 0xbe, 0x69, 0x3b, 0x98, 0xee, 0x79, 0x5d, 0x7f, 0x7d, 0x7c, 0x59, 0xa6, 0xfe, 0x13,
-	0x58, 0xca, 0xe1, 0x2a, 0x15, 0xbc, 0x05, 0xa0, 0xd2, 0x4b, 0xb9, 0x75, 0x31, 0x0a, 0x53, 0x69,
-	0xc3, 0x72, 0xed, 0xa1, 0x6b, 0x51, 0xbc, 0xd1, 0xc3, 0xf6, 0x59, 0x30, 0xec, 0x5f, 0x5e, 0xa5,
-	0xff, 0x87, 0xa5, 0x1c, 0xae, 0x52, 0x25, 0x0d, 0xaa, 0xb6, 0xa4, 0x49, 0x4b, 0x45, 0x6d, 0xb6,
-	0x6d, 0x3b, 0x98, 0x1e, 0x7b, 0xd6, 0x20, 0xe8, 0xf9, 0x97, 0x87, 0x5f, 0xf4, 0x0f, 0x60, 0x2e,
-	0xc1, 0x6f, 0x84, 0x2b, 0x7f, 0x5b, 0x82, 0xbb, 0x79, 0x8e, 0x35, 0x36, 0x65, 0x58, 0xa2, 0xdb,
-	0xa3, 0x74, 0x60, 0xaa, 0x6b, 0xa9, 0xc2, 0xda, 0x2f, 0x89, 0xcb, 0x2e, 0x59, 0xde, 0x65, 0x0d,
-	0x69, 0x4f, 0xe6, 0x6e, 0x7c, 0xec, 0xfa, 0x90, 0xf6, 0xf4, 0xfb, 0x70, 0x6f, 0xb4, 0x62, 0xd2,
-	0xe7, 0xff, 0x50, 0x82, 0xf9, 0x1d, 0x4c, 0x0d, 0xeb, 0x7c, 0xa3, 0x67, 0x79, 0xa7, 0xe3, 0x40,
-	0x30, 0xee, 0xc2, 0xd5, 0x2e, 0xf1, 0xfb, 0x66, 0x02, 0xc6, 0xa8, 0x19, 0x75, 0x46, 0x8c, 0x5e,
-	0xa9, 0xab, 0x30, 0x43, 0x7d, 0x33, 0xf1, 0xce, 0xad, 0x19, 0x40, 0xfd, 0x70, 0x80, 0xfe, 0xb7,
-	0x29, 0xb8, 0x91, 0x52, 0x4c, 0x6e, 0xc4, 0x2e, 0xcc, 0x10, 0xeb, 0xdc, 0xb4, 0x05, 0xb9, 0x59,
-	0xe2, 0xf7, 0xd4, 0xfb, 0xb1, 0xec, 0x34, 0x3b, 0x67, 0x2d, 0x22, 0x19, 0x40, 0xa2, 0x5e, 0xed,
-	0xbb, 0x49, 0xa8, 0x45, 0x3d, 0x68, 0x11, 0x2a, 0x2c, 0xbb, 0x64, 0x4f, 0x16, 0xe1, 0x62, 0x65,
-	0xd6, 0xdc, 0xeb, 0x44, 0xe8, 0xcf, 0x84, 0x42, 0x7f, 0xd0, 0x0a, 0x54, 0x3d, 0x7c, 0x2e, 0x72,
-	0x56, 0xae, 0x7c, 0x6b, 0xa2, 0x59, 0x32, 0x2a, 0x1e, 0x3e, 0xe7, 0x59, 0xeb, 0x0a, 0x54, 0xd9,
-	0x3b, 0x9d, 0x77, 0x4f, 0xa9, 0x6e, 0xdf, 0xed, 0xf0, 0xee, 0x43, 0xa8, 0xf9, 0x03, 0x4c, 0x2c,
-	0xca, 0xd6, 0x3e, 0xcd, 0xd3, 0xeb, 0x4f, 0xde, 0x71, 0x01, 0x6b, 0x87, 0xe1, 0x44, 0x43, 0xf1,
-	0x60, 0x36, 0x67, 0x36, 0x51, 0x4c, 0x05, 0x9e, 0x52, 0x27, 0xd6, 0x79, 0x34, 0x9e, 0xf9, 0x12,
-	0x53, 0xaa, 0xef, 0x77, 0x30, 0xcf, 0xb3, 0xa7, 0xb9, 0x42, 0xfb, 0x7e, 0x07, 0x73, 0x3c, 0x05,
-	0x9f, 0x8b, 0xae, 0xaa, 0xe8, 0xf2, 0xf0, 0x39, 0xef, 0xba, 0x07, 0xd7, 0xc2, 0x95, 0x9a, 0xed,
-	0x0b, 0x76, 0x22, 0xd4, 0x44, 0x5e, 0x27, 0xd7, 0xda, 0x62, 0x34, 0x36, 0x2a, 0x5c, 0xb0, 0x1c,
-	0x05, 0x62, 0x94, 0x5c, 0x32, 0x1f, 0xa5, 0x3b, 0x50, 0x53, 0xea, 0xcc, 0x40, 0xe5, 0xe5, 0xc1,
-	0xf3, 0x83, 0xc3, 0xcf, 0x0f, 0x1a, 0x57, 0x50, 0x0d, 0xa6, 0xd7, 0x37, 0x37, 0xb7, 0x36, 0x45,
-	0xa6, 0xbe, 0x71, 0x78, 0xb4, 0xb7, 0xb5, 0x29, 0x32, 0xf5, 0xcd, 0xad, 0x17, 0x5b, 0x27, 0x5b,
-	0x9b, 0x8d, 0x49, 0x54, 0x87, 0xea, 0xfe, 0xe1, 0xe6, 0xde, 0x36, 0xeb, 0x9a, 0x62, 0x5d, 0xc6,
-	0xd6, 0xc1, 0xfa, 0xfe, 0xd6, 0x66, 0x63, 0x1a, 0x35, 0xa0, 0x7e, 0xf2, 0xc5, 0xd1, 0x96, 0xb9,
-	0xb1, 0xbb, 0x7e, 0xb0, 0xb3, 0xb5, 0xd9, 0x28, 0xeb, 0xbf, 0x2f, 0x41, 0xf3, 0x18, 0x5b, 0xc4,
-	0xee, 0x6d, 0x3b, 0x2e, 0x0e, 0x5a, 0x17, 0xec, 0x34, 0xbd, 0xbc, 0x73, 0xcf, 0xc3, 0xf4, 0xeb,
-	0x21, 0x96, 0xe9, 0x42, 0xcd, 0x10, 0x8d, 0x30, 0x89, 0x9b, 0x54, 0x49, 0xdc, 0x02, 0x94, 0xbb,
-	0x8e, 0x4b, 0x31, 0x11, 0xdb, 0x6f, 0xc8, 0x96, 0xfe, 0x09, 0x2c, 0xe5, 0x68, 0xa5, 0xf2, 0xcd,
-	0x2e, 0x23, 0x73, 0x9f, 0xae, 0x1b, 0xa2, 0xa1, 0xff, 0xb9, 0x04, 0x37, 0x13, 0x73, 0x36, 0x7c,
-	0x8f, 0x62, 0x8f, 0xfe, 0x70, 0x8b, 0xf9, 0x00, 0x1a, 0x76, 0x6f, 0xe8, 0x9d, 0x61, 0x96, 0x79,
-	0x0a, 0x5d, 0x25, 0xc6, 0x77, 0x5d, 0xd2, 0xa3, 0xf3, 0xe4, 0x02, 0x96, 0xf3, 0x75, 0x95, 0x4b,
-	0x6c, 0x42, 0xa5, 0x6f, 0x51, 0xbb, 0x17, 0x2d, 0x32, 0x6c, 0xa2, 0x15, 0x00, 0xfe, 0x69, 0xc6,
-	0x6e, 0xef, 0x1a, 0xa7, 0x6c, 0x5a, 0xd4, 0x42, 0xb7, 0xa1, 0x8e, 0xbd, 0x8e, 0xe9, 0x77, 0x4d,
-	0x4e, 0x93, 0xd8, 0x23, 0x60, 0xaf, 0x73, 0xd8, 0xdd, 0x67, 0x14, 0xfd, 0x77, 0x25, 0x28, 0x0b,
-	0xe4, 0x2e, 0x7c, 0xc7, 0x97, 0xa2, 0x77, 0x3c, 0x8b, 0x61, 0x7e, 0xcd, 0x8a, 0x95, 0xf2, 0x6f,
-	0xf4, 0x63, 0x58, 0x8a, 0x0e, 0x50, 0x9f, 0x38, 0x5f, 0x73, 0xb7, 0x34, 0x7b, 0xd8, 0xea, 0x60,
-	0x22, 0x4f, 0xa4, 0xc5, 0xf0, 0x40, 0x8d, 0xfa, 0x77, 0x79, 0x37, 0x7a, 0x0f, 0xae, 0xf5, 0x1d,
-	0x42, 0x7c, 0x62, 0x12, 0xdc, 0xed, 0x5b, 0x83, 0xa0, 0x39, 0xc5, 0x9f, 0x82, 0x57, 0x05, 0xd5,
-	0x10, 0x44, 0xe6, 0x85, 0x0b, 0x1c, 0xd0, 0xd8, 0x3d, 0x39, 0x39, 0x1a, 0x17, 0x2e, 0x7b, 0x3f,
-	0x81, 0xcb, 0x66, 0xa1, 0xcd, 0x10, 0xa7, 0x8d, 0x01, 0xaf, 0x93, 0x09, 0xe0, 0x55, 0x5f, 0x82,
-	0xc5, 0x8c, 0x56, 0x72, 0x03, 0xbf, 0x80, 0x95, 0x1d, 0x4c, 0x0f, 0xdb, 0xbf, 0xc0, 0x36, 0xdd,
-	0x74, 0x08, 0xb6, 0xc7, 0x87, 0xaf, 0xff, 0x1f, 0xdc, 0x2a, 0x62, 0x3d, 0x02, 0x67, 0xff, 0x53,
-	0x09, 0xe6, 0x37, 0x5c, 0xdf, 0xc3, 0xec, 0xfe, 0x3a, 0xf2, 0x7d, 0x77, 0x1c, 0x06, 0x9c, 0x1a,
-	0xb0, 0x3c, 0x22, 0x95, 0xf2, 0x0b, 0xcd, 0xb8, 0x08, 0xde, 0x1f, 0x33, 0xf4, 0xe4, 0x28, 0x43,
-	0xeb, 0x8b, 0x70, 0x23, 0xa5, 0xa1, 0x34, 0xe6, 0x3f, 0x4a, 0xb0, 0x9c, 0xe8, 0xd9, 0xf3, 0x28,
-	0x26, 0x9e, 0xf5, 0x03, 0xae, 0x21, 0x17, 0xeb, 0x98, 0xfc, 0x2f, 0xb0, 0x8e, 0x55, 0x58, 0x29,
-	0x58, 0x82, 0x82, 0xc7, 0x99, 0x3d, 0xde, 0x8c, 0x1b, 0x1e, 0xcf, 0x32, 0x95, 0x02, 0xdf, 0x32,
-	0x81, 0x1e, 0x3f, 0x38, 0xc7, 0x26, 0x90, 0xdf, 0xa0, 0xd8, 0xb5, 0xa8, 0xf3, 0x46, 0x22, 0xd1,
-	0xf2, 0xd5, 0x12, 0x12, 0xd9, 0x25, 0x26, 0xb4, 0x4a, 0x4b, 0x96, 0x5a, 0xfd, 0xba, 0xc4, 0x92,
-	0xaf, 0x81, 0xeb, 0xd8, 0xe3, 0xad, 0x14, 0xa0, 0x87, 0x50, 0x16, 0x9b, 0x32, 0x02, 0xa2, 0x92,
-	0x23, 0xf4, 0x15, 0xb8, 0x99, 0xab, 0x83, 0xd4, 0xf1, 0x25, 0x2c, 0x1d, 0x0e, 0xa8, 0xd3, 0xe7,
-	0x31, 0x37, 0xbe, 0xcd, 0x5a, 0x06, 0x2d, 0x8f, 0xad, 0x10, 0xfa, 0xe4, 0x2f, 0xab, 0xbc, 0x24,
-	0x1c, 0xd6, 0xd5, 0x44, 0x2d, 0x1d, 0x7d, 0x09, 0x8d, 0x74, 0x39, 0x1b, 0xad, 0x66, 0xa5, 0x25,
-	0xaa, 0xe7, 0xda, 0xed, 0xe2, 0x01, 0x72, 0x85, 0xe5, 0x7f, 0x7f, 0xfb, 0x60, 0xa2, 0x3a, 0x81,
-	0xbe, 0x0a, 0xcb, 0xd0, 0xb1, 0x1a, 0x35, 0x8a, 0x4f, 0xcf, 0x2d, 0x8a, 0x6b, 0x77, 0x46, 0x8c,
-	0x48, 0x48, 0x28, 0xa1, 0xe7, 0x00, 0xaa, 0xe8, 0x8c, 0x96, 0x92, 0x13, 0x63, 0xc5, 0x6f, 0x4d,
-	0xcb, 0xeb, 0xca, 0x32, 0x53, 0xc5, 0x65, 0xc5, 0x2c, 0x53, 0xbf, 0x56, 0xcc, 0x72, 0x6a, 0xd1,
-	0x21, 0xb3, 0xcf, 0xe1, 0x5a, 0xb2, 0x08, 0x8c, 0x56, 0xa2, 0xc7, 0x65, 0x5e, 0xa9, 0x5a, 0xbb,
-	0x55, 0xd4, 0x9d, 0x62, 0xfc, 0xa5, 0x84, 0x8f, 0x63, 0xe5, 0x5e, 0xb5, 0x67, 0x05, 0xd5, 0x65,
-	0xb5, 0x67, 0x85, 0x95, 0xe2, 0x98, 0xde, 0xc9, 0xfa, 0xab, 0xd2, 0x3b, 0xb7, 0xd4, 0xab, 0xf4,
-	0xce, 0x2f, 0xdb, 0x46, 0xce, 0x60, 0x03, 0xca, 0xd6, 0x4d, 0x51, 0xb4, 0xd7, 0x85, 0x65, 0x5c,
-	0x4d, 0x1f, 0x35, 0x24, 0xa5, 0xfd, 0x01, 0xcc, 0xc4, 0x8a, 0x87, 0x28, 0xda, 0xa8, 0x6c, 0x49,
-	0x56, 0xbb, 0x99, 0xdb, 0x97, 0x35, 0x76, 0x3a, 0x83, 0x53, 0xc6, 0x2e, 0xa8, 0x47, 0x2a, 0x63,
-	0x17, 0xd6, 0x16, 0x43, 0xf6, 0xfb, 0x00, 0xaa, 0xec, 0xa5, 0x3c, 0x2e, 0x53, 0xdc, 0x53, 0x1e,
-	0x97, 0xad, 0x92, 0x85, 0x06, 0xfe, 0x98, 0x6b, 0x9b, 0x2e, 0x63, 0x29, 0x6d, 0x0b, 0xaa, 0x66,
-	0x4a, 0xdb, 0xa2, 0x0a, 0x58, 0x3c, 0x9c, 0x33, 0x75, 0x21, 0x15, 0xce, 0x45, 0xd5, 0x30, 0x15,
-	0xce, 0x85, 0x45, 0xa5, 0xc8, 0x1e, 0x3f, 0x82, 0xa9, 0xed, 0xc0, 0x3e, 0x43, 0x73, 0xd1, 0x14,
-	0x55, 0x52, 0xd2, 0xe6, 0x93, 0xc4, 0xd4, 0xd4, 0x2d, 0xa8, 0x86, 0x55, 0x15, 0xb4, 0x98, 0xf0,
-	0x76, 0x55, 0x21, 0xd2, 0x9a, 0xd9, 0x8e, 0x14, 0x9b, 0x13, 0xb8, 0x9a, 0x28, 0x89, 0xa0, 0xe5,
-	0x48, 0x6a, 0x4e, 0x65, 0x46, 0x5b, 0x29, 0xe8, 0x4d, 0x59, 0xee, 0x39, 0x80, 0x2a, 0x55, 0xa8,
-	0x7d, 0xce, 0x94, 0x53, 0xd4, 0x3e, 0xe7, 0x54, 0x36, 0x42, 0x15, 0x6d, 0x40, 0xd9, 0x6a, 0x83,
-	0x0a, 0xa4, 0xc2, 0xea, 0x87, 0x0a, 0xa4, 0xe2, 0x62, 0x45, 0x3c, 0x5a, 0xb3, 0xf5, 0x81, 0xb8,
-	0x90, 0x82, 0x7a, 0x45, 0x5c, 0x48, 0x51, 0x79, 0x21, 0x12, 0x42, 0xb2, 0x35, 0x7d, 0x89, 0xeb,
-	0xa3, 0xfb, 0x45, 0x31, 0x94, 0x2c, 0x33, 0x68, 0xef, 0x7f, 0xef, 0xb8, 0x94, 0xf5, 0x8e, 0xa1,
-	0x1e, 0xc7, 0xf5, 0xd1, 0xcd, 0x24, 0x83, 0x04, 0x00, 0xaa, 0x2d, 0xe7, 0x77, 0x66, 0x02, 0xef,
-	0x97, 0xa0, 0x15, 0x43, 0x9b, 0xe8, 0x83, 0x51, 0x3a, 0x26, 0x05, 0x3e, 0x7c, 0x97, 0xa1, 0xc9,
-	0x15, 0x3d, 0x28, 0xa1, 0x5d, 0xa8, 0x45, 0x70, 0x3b, 0x6a, 0x16, 0x15, 0x0b, 0xb4, 0xa5, 0x9c,
-	0x9e, 0x94, 0x75, 0x3e, 0x83, 0x7a, 0x1c, 0x3e, 0x57, 0xd6, 0xc9, 0x41, 0xee, 0x95, 0x75, 0x72,
-	0x11, 0xf7, 0xf8, 0x91, 0xac, 0x00, 0xd8, 0xd8, 0x91, 0x9c, 0x41, 0x79, 0x63, 0x47, 0x72, 0x16,
-	0xb1, 0x8d, 0x9c, 0xa6, 0xcd, 0x7f, 0xcb, 0x48, 0xa2, 0xa6, 0x28, 0xfe, 0x5f, 0x44, 0x2e, 0x4c,
-	0xab, 0x4e, 0xa1, 0x42, 0xc8, 0x35, 0xb6, 0x9f, 0x5f, 0xc1, 0x6c, 0x06, 0x06, 0x55, 0x32, 0x8a,
-	0x70, 0x57, 0x25, 0xa3, 0x10, 0x43, 0x8d, 0x56, 0xd1, 0x82, 0x8a, 0xfc, 0x99, 0x0a, 0x2d, 0x44,
-	0xb3, 0x12, 0x7f, 0x6a, 0x69, 0x8b, 0x19, 0x7a, 0xca, 0xb2, 0x47, 0x30, 0x13, 0xc3, 0x48, 0x51,
-	0xfc, 0x8e, 0x48, 0x61, 0x9f, 0xca, 0xb2, 0x39, 0xa0, 0x6a, 0x6c, 0xdd, 0xbf, 0x62, 0xa9, 0xd2,
-	0x08, 0xc4, 0x12, 0x7d, 0x38, 0xca, 0x3f, 0xd3, 0x42, 0x1f, 0xbd, 0xdb, 0xe0, 0xd4, 0xaa, 0x7e,
-	0x0e, 0x57, 0x13, 0xe8, 0x9b, 0x3a, 0x81, 0xf3, 0x20, 0x52, 0x75, 0x02, 0xe7, 0x42, 0x76, 0xb1,
-	0xb5, 0x9d, 0xc1, 0x7c, 0x1e, 0x28, 0x82, 0xee, 0xaa, 0xa8, 0x28, 0x84, 0x77, 0xb4, 0x7b, 0xa3,
-	0x07, 0x65, 0x84, 0xb5, 0x61, 0x36, 0x83, 0x30, 0x29, 0x07, 0x2a, 0x82, 0xc4, 0x94, 0x03, 0x15,
-	0xc2, 0x53, 0x31, 0x19, 0x18, 0x50, 0xb6, 0xce, 0x84, 0x62, 0x8f, 0xe7, 0x82, 0x72, 0x97, 0x3a,
-	0xa2, 0x47, 0x94, 0xa9, 0xd4, 0xe1, 0xd2, 0x86, 0xd9, 0x4c, 0x69, 0x49, 0x2d, 0xa5, 0xa8, 0x96,
-	0xa5, 0x96, 0x52, 0x58, 0x97, 0x8a, 0x2d, 0xe5, 0x15, 0x5c, 0x4f, 0x41, 0x21, 0xe8, 0x56, 0xe2,
-	0xd5, 0x90, 0x41, 0x6e, 0xb4, 0xd5, 0xc2, 0xfe, 0x94, 0x3f, 0xf9, 0xb0, 0x90, 0x0f, 0x78, 0xa0,
-	0xf7, 0x62, 0xae, 0x53, 0x8c, 0xb5, 0x68, 0xf7, 0xbf, 0x6f, 0x58, 0x2a, 0xb4, 0x4f, 0xe0, 0x6a,
-	0x22, 0x57, 0x57, 0x0e, 0x9c, 0x87, 0xa0, 0x28, 0x07, 0xce, 0x47, 0x2f, 0xc2, 0x65, 0xb8, 0x29,
-	0x78, 0x23, 0x44, 0x00, 0xd0, 0xbd, 0xdc, 0xf9, 0x29, 0x8c, 0x43, 0x7b, 0xef, 0x7b, 0x46, 0x65,
-	0xdf, 0xbd, 0xe9, 0xcc, 0x3f, 0x9e, 0x18, 0xe6, 0x02, 0x0d, 0xf1, 0xc4, 0xb0, 0x00, 0x34, 0x48,
-	0xb0, 0x4f, 0xa6, 0xf0, 0x71, 0xf6, 0xb9, 0xb0, 0x42, 0x9c, 0x7d, 0x41, 0xf6, 0x1f, 0xb2, 0xef,
-	0xc2, 0x5c, 0x4e, 0x02, 0x8e, 0x62, 0x7e, 0x5f, 0x84, 0x10, 0x68, 0x77, 0x47, 0x8e, 0xc9, 0xbe,
-	0xc4, 0xb2, 0x29, 0xb7, 0x8a, 0xc0, 0xc2, 0x2c, 0x5f, 0x45, 0x60, 0x71, 0xc6, 0x1e, 0x0a, 0x69,
-	0x7d, 0xfc, 0x8a, 0x0d, 0x76, 0xad, 0xf6, 0x9a, 0xed, 0xf7, 0x1f, 0x8b, 0xcf, 0x8f, 0x7c, 0x72,
-	0xfa, 0x58, 0xb0, 0x78, 0xcc, 0xff, 0x76, 0x7f, 0x7c, 0xea, 0xcb, 0xf6, 0xa0, 0xdd, 0x2e, 0x73,
-	0xd2, 0xd3, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x88, 0xee, 0x9b, 0x7e, 0x3e, 0x2f, 0x00, 0x00,
+	// 3057 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x6f, 0xdc, 0xc6,
+	0xf5, 0xf7, 0xea, 0xb6, 0xbb, 0x47, 0x6b, 0x7b, 0x35, 0x92, 0xad, 0x15, 0x2d, 0xf9, 0x42, 0x3b,
+	0x8e, 0xe3, 0x38, 0x72, 0x62, 0xff, 0x81, 0x7f, 0xda, 0xa2, 0x28, 0xb4, 0xba, 0xdb, 0xd6, 0x25,
+	0x94, 0xdc, 0x20, 0x06, 0x02, 0x86, 0xcb, 0x9d, 0xd5, 0xb2, 0xe2, 0x72, 0xd6, 0xc3, 0x59, 0xcb,
+	0x0a, 0xd0, 0x87, 0x16, 0xe8, 0x5b, 0x11, 0xa0, 0x40, 0xd1, 0xf4, 0xb1, 0xcf, 0xfd, 0x04, 0x7d,
+	0x29, 0x8a, 0xbe, 0xf4, 0x3b, 0x04, 0xfd, 0x06, 0xfd, 0x08, 0x7d, 0x2a, 0xe6, 0x42, 0x0e, 0xb9,
+	0x24, 0x37, 0x2e, 0xb4, 0x48, 0xdf, 0x38, 0x67, 0x66, 0xce, 0x39, 0x73, 0xe6, 0x9c, 0x99, 0x39,
+	0xbf, 0x43, 0x68, 0x50, 0xdc, 0x27, 0xa1, 0xc7, 0x08, 0x3d, 0xff, 0x28, 0xc4, 0xf4, 0x8d, 0xe7,
+	0xe2, 0xd5, 0x3e, 0x25, 0x8c, 0xa0, 0x99, 0x13, 0x8f, 0x39, 0xfe, 0xb9, 0x01, 0xbe, 0x17, 0x30,
+	0x49, 0x33, 0x6a, 0x61, 0xd7, 0xa1, 0xb8, 0x2d, 0x5b, 0xe6, 0x11, 0x2c, 0x5a, 0xf1, 0xec, 0xcd,
+	0xb7, 0x5e, 0xc8, 0x42, 0x0b, 0xbf, 0x1e, 0xe0, 0x90, 0xa1, 0x4f, 0x01, 0x34, 0xe3, 0x46, 0xe9,
+	0x76, 0xe9, 0xc1, 0xec, 0x13, 0xb4, 0x2a, 0x39, 0xae, 0xea, 0x49, 0xcd, 0xa9, 0x3f, 0xfe, 0xe3,
+	0x51, 0xc9, 0x4a, 0x8c, 0x35, 0x9f, 0x40, 0x23, 0xcb, 0x34, 0xec, 0x93, 0x20, 0xc4, 0xe8, 0x3a,
+	0xcc, 0x60, 0x41, 0x11, 0x1c, 0x2b, 0x96, 0x6a, 0x99, 0xc7, 0x62, 0x8e, 0xe3, 0x9e, 0xee, 0x06,
+	0x2e, 0xc5, 0x3d, 0x1c, 0x30, 0xc7, 0xbf, 0xb8, 0x26, 0x37, 0x60, 0x29, 0x87, 0xab, 0x54, 0xc5,
+	0xa4, 0x30, 0x27, 0x3b, 0xb7, 0x06, 0xfe, 0xc5, 0x65, 0xa1, 0xbb, 0x70, 0xd9, 0xa5, 0xd8, 0x61,
+	0xd8, 0x6e, 0x79, 0xac, 0xe7, 0xf4, 0x1b, 0x13, 0x62, 0x81, 0x35, 0x49, 0x6c, 0x0a, 0x9a, 0xb9,
+	0x00, 0x28, 0x29, 0x53, 0x69, 0xb2, 0x07, 0x73, 0x7b, 0x5e, 0xfb, 0xad, 0xec, 0xb9, 0xf8, 0xaa,
+	0x17, 0x00, 0x25, 0xd9, 0x29, 0x21, 0xbf, 0x2d, 0xc1, 0xb5, 0x6d, 0x87, 0xb6, 0x9c, 0x13, 0xbc,
+	0x4e, 0x7c, 0x1f, 0xbb, 0xec, 0x87, 0x59, 0x33, 0x5a, 0x80, 0xe9, 0x3e, 0x1d, 0x04, 0xb8, 0x31,
+	0x29, 0x3a, 0x65, 0xc3, 0x6c, 0xc0, 0xf5, 0x61, 0x6d, 0x94, 0xa2, 0x47, 0xb0, 0xf8, 0x39, 0xf5,
+	0x18, 0x5e, 0x27, 0xbd, 0x9e, 0xc7, 0xb6, 0xa9, 0xd3, 0xef, 0x5e, 0xdc, 0x26, 0x06, 0x34, 0xb2,
+	0x4c, 0x95, 0xc0, 0x67, 0x70, 0x65, 0xdd, 0xc7, 0x4e, 0x30, 0xe8, 0x5f, 0x5c, 0xce, 0x1c, 0x5c,
+	0x8d, 0x79, 0x29, 0xf6, 0x9f, 0xc1, 0x35, 0x3d, 0xe5, 0xc8, 0xfb, 0x1a, 0x5f, 0x5c, 0xca, 0x23,
+	0xb8, 0x3e, 0xcc, 0x52, 0xc5, 0x17, 0x82, 0xa9, 0xd0, 0xfb, 0x1a, 0x0b, 0x6e, 0x93, 0x96, 0xf8,
+	0x36, 0x5f, 0xc3, 0xd2, 0x5a, 0xbf, 0xef, 0x9f, 0x6f, 0x7b, 0xcc, 0x61, 0x8c, 0x7a, 0xad, 0x01,
+	0xc3, 0x17, 0x0f, 0x73, 0x64, 0x40, 0x85, 0xe2, 0x37, 0x5e, 0xe8, 0x91, 0x40, 0xec, 0x7b, 0xcd,
+	0x8a, 0xdb, 0xe6, 0x32, 0x18, 0x79, 0x22, 0x95, 0x45, 0xfe, 0x36, 0x01, 0x68, 0x0b, 0x33, 0xb7,
+	0x6b, 0xe1, 0x1e, 0x61, 0x17, 0xb7, 0x07, 0x3f, 0x55, 0xa8, 0x60, 0x25, 0x14, 0xa9, 0x5a, 0xaa,
+	0xc5, 0x5d, 0xaf, 0x43, 0xa8, 0x1b, 0xbb, 0x9e, 0x68, 0xa0, 0x45, 0x28, 0x07, 0xc4, 0x66, 0xce,
+	0x49, 0xd8, 0x98, 0x92, 0x87, 0x50, 0x40, 0x8e, 0x9d, 0x93, 0x10, 0x35, 0xa0, 0xcc, 0xbc, 0x1e,
+	0x26, 0x03, 0xd6, 0x98, 0xbe, 0x5d, 0x7a, 0x30, 0x6d, 0x45, 0x4d, 0x3e, 0x25, 0x0c, 0xbb, 0xf6,
+	0x29, 0x3e, 0x6f, 0xcc, 0x48, 0x09, 0x61, 0xd8, 0x7d, 0x8e, 0xcf, 0xd1, 0x2d, 0x98, 0x3d, 0x0d,
+	0xc8, 0x59, 0x60, 0x77, 0x09, 0x3f, 0xd4, 0xca, 0xa2, 0x13, 0x04, 0x69, 0x87, 0x53, 0xd0, 0x12,
+	0x54, 0x02, 0x62, 0xcb, 0x00, 0xa8, 0x0a, 0x69, 0xe5, 0x80, 0x1c, 0xf2, 0x26, 0x7a, 0x0a, 0x97,
+	0xa5, 0x9e, 0x76, 0xdf, 0xa1, 0x4e, 0x2f, 0x6c, 0x80, 0x58, 0xf2, 0x15, 0xbd, 0x64, 0x61, 0x9d,
+	0x9a, 0x1c, 0x74, 0x28, 0xc6, 0x3c, 0x9b, 0xaa, 0x54, 0xea, 0x55, 0xf3, 0x1a, 0xcc, 0xa7, 0x0c,
+	0xa8, 0x43, 0x67, 0x5d, 0x84, 0x9e, 0xb6, 0xd6, 0x58, 0x42, 0x27, 0xcb, 0x54, 0x09, 0xfc, 0xd7,
+	0x04, 0xcc, 0x6d, 0x63, 0xb6, 0x46, 0xdd, 0xae, 0xf7, 0x66, 0x0c, 0x1b, 0x79, 0x03, 0xaa, 0xae,
+	0x88, 0x50, 0xdb, 0x6b, 0xab, 0xbd, 0xac, 0x48, 0xc2, 0x6e, 0x9b, 0xef, 0x72, 0x9f, 0xe2, 0x8e,
+	0xf7, 0x56, 0x6c, 0x67, 0xd5, 0x52, 0x2d, 0xf4, 0x29, 0xcc, 0x74, 0x08, 0xed, 0x39, 0x4c, 0x6c,
+	0xe7, 0x95, 0x27, 0xb7, 0x23, 0x51, 0x19, 0xcd, 0x56, 0xb7, 0xc4, 0x38, 0x4b, 0x8d, 0xe7, 0xd1,
+	0xd2, 0x77, 0x58, 0x57, 0xec, 0x76, 0xcd, 0x12, 0xdf, 0xdc, 0x09, 0xf0, 0x5b, 0xd7, 0x1f, 0xb4,
+	0x71, 0x63, 0xe6, 0xf6, 0xe4, 0x83, 0x9a, 0x15, 0x35, 0xd1, 0x0a, 0x00, 0xf6, 0xbd, 0x36, 0xdf,
+	0x2e, 0xd6, 0x15, 0x5b, 0x5d, 0xb1, 0xaa, 0x82, 0x72, 0xc8, 0x27, 0x3e, 0x84, 0x39, 0x2f, 0x10,
+	0x23, 0x6d, 0xbf, 0x13, 0xda, 0x2d, 0x9f, 0xb4, 0xc2, 0x46, 0x45, 0x8c, 0xba, 0xaa, 0x3a, 0x5e,
+	0x74, 0xc2, 0x26, 0x27, 0x9b, 0x4f, 0x61, 0x46, 0xaa, 0x82, 0xca, 0x30, 0xf9, 0x6a, 0xf7, 0xb0,
+	0x7e, 0x89, 0x7f, 0x1c, 0xaf, 0x59, 0xf5, 0x12, 0x02, 0x98, 0x39, 0x5e, 0xb3, 0xec, 0xed, 0x57,
+	0xf5, 0x09, 0x34, 0x0b, 0x65, 0xfe, 0xdd, 0x7c, 0xf5, 0xa4, 0x3e, 0x69, 0x3e, 0x00, 0x94, 0x5c,
+	0x91, 0x8e, 0xf8, 0xb6, 0xc3, 0x1c, 0x61, 0xe6, 0x9a, 0x25, 0xbe, 0xb9, 0x1f, 0xec, 0x38, 0xe1,
+	0x0b, 0xe2, 0x3a, 0x7e, 0x93, 0x3a, 0x81, 0xdb, 0x1d, 0x43, 0xbc, 0x9b, 0x1f, 0x43, 0x23, 0xcb,
+	0x54, 0x29, 0xb1, 0x00, 0xd3, 0x6f, 0x1c, 0x7f, 0x80, 0xd5, 0xad, 0x2e, 0x1b, 0xe6, 0x77, 0x25,
+	0x68, 0x08, 0x37, 0x3d, 0x22, 0x03, 0xea, 0x62, 0x39, 0xeb, 0xe2, 0x4e, 0xf2, 0x33, 0x98, 0x0b,
+	0x05, 0x43, 0x3b, 0xc1, 0x60, 0xa2, 0x88, 0x81, 0x55, 0x97, 0x83, 0xad, 0xd4, 0xb5, 0xa5, 0x18,
+	0xb4, 0x84, 0x4a, 0xc2, 0x9f, 0x6a, 0x56, 0x2d, 0x4c, 0xa8, 0xc9, 0x77, 0x9b, 0x39, 0xf4, 0x04,
+	0x33, 0x9b, 0xe2, 0x8e, 0xf0, 0xac, 0x9a, 0x55, 0x95, 0x14, 0x0b, 0x77, 0xcc, 0xa7, 0xb0, 0x94,
+	0xb3, 0x34, 0xfd, 0xca, 0xa1, 0x38, 0x1c, 0xf8, 0x2c, 0x7a, 0xe5, 0xc8, 0x96, 0xb9, 0x0d, 0xb3,
+	0x5b, 0xe1, 0x38, 0xae, 0xf8, 0x7b, 0x50, 0x93, 0x8c, 0xb4, 0xfd, 0x31, 0xa5, 0x84, 0x2a, 0x2f,
+	0x90, 0x0d, 0xf3, 0x2f, 0x25, 0xb8, 0x2a, 0x6e, 0x3d, 0x0b, 0x77, 0x2e, 0x6e, 0xf6, 0x3a, 0x4c,
+	0x72, 0x4b, 0xc8, 0xa3, 0x9e, 0x7f, 0xa6, 0x6e, 0x80, 0xc9, 0xf4, 0x0d, 0x80, 0xee, 0x40, 0x8d,
+	0xf8, 0x6d, 0x3b, 0xee, 0x97, 0x06, 0x9c, 0x25, 0x7e, 0xdb, 0x8a, 0x86, 0xc4, 0xa7, 0xf3, 0x74,
+	0xe2, 0x74, 0x7e, 0x36, 0x55, 0x99, 0xa9, 0x97, 0xcd, 0x06, 0xd4, 0xb5, 0xe6, 0x72, 0x91, 0xcf,
+	0xa6, 0x2a, 0xa5, 0xfa, 0x84, 0x19, 0xc0, 0xc2, 0x96, 0x17, 0xb4, 0xf7, 0x30, 0x3d, 0xc1, 0x4d,
+	0x27, 0x1c, 0xc3, 0xa1, 0xb3, 0x0c, 0xd5, 0x48, 0xcd, 0xb0, 0x31, 0x21, 0x62, 0x5e, 0x13, 0xcc,
+	0x0f, 0xe1, 0xda, 0x90, 0x3c, 0x1d, 0x78, 0x2d, 0x27, 0x94, 0x2e, 0x5f, 0xb5, 0xc4, 0xb7, 0xf9,
+	0x4d, 0x09, 0xe6, 0xe4, 0x61, 0xb9, 0x45, 0xe8, 0xe9, 0xff, 0xde, 0xd5, 0xf9, 0x5b, 0x30, 0xa9,
+	0x4f, 0xfc, 0xf4, 0x5d, 0xda, 0x0d, 0x2d, 0xcc, 0x55, 0xde, 0x0d, 0x0e, 0x29, 0x39, 0xa1, 0x38,
+	0x0c, 0xc7, 0x72, 0x7a, 0x53, 0xc1, 0x34, 0x71, 0x7a, 0x4b, 0xc2, 0x6e, 0xdb, 0xfc, 0x29, 0x18,
+	0x79, 0x32, 0x95, 0x31, 0x6f, 0xc1, 0xac, 0x17, 0xd8, 0x7d, 0x45, 0x56, 0x61, 0x03, 0x5e, 0x3c,
+	0x50, 0xaa, 0x7c, 0xf4, 0x7a, 0xe0, 0x84, 0xdd, 0x31, 0xab, 0x1c, 0x0a, 0xa6, 0x09, 0x95, 0x25,
+	0x21, 0x52, 0x39, 0x2b, 0xf3, 0x5d, 0x55, 0xf6, 0xe1, 0xe6, 0xf0, 0xc5, 0xb9, 0x45, 0x49, 0xef,
+	0xa5, 0xf5, 0x62, 0x2c, 0xc1, 0x38, 0xa0, 0xbe, 0xd2, 0x98, 0x7f, 0x9a, 0x77, 0xe0, 0x56, 0xa1,
+	0x34, 0xb5, 0xed, 0x07, 0x30, 0x2f, 0x87, 0x34, 0x07, 0x41, 0xdb, 0x1f, 0xc3, 0x3b, 0xf4, 0x21,
+	0x2c, 0xa4, 0x19, 0x8e, 0xb8, 0x93, 0xbe, 0x99, 0x80, 0xfa, 0x11, 0x66, 0xeb, 0x24, 0xe8, 0x78,
+	0x27, 0x17, 0x37, 0xc0, 0xa7, 0x50, 0xc6, 0x01, 0xa3, 0x1e, 0x96, 0x21, 0x3b, 0xfb, 0xe4, 0x66,
+	0x34, 0x6d, 0x58, 0xc8, 0xea, 0x66, 0xc0, 0xe8, 0xb9, 0x15, 0x0d, 0x37, 0x7e, 0x53, 0x82, 0x69,
+	0x41, 0xe2, 0x46, 0xe4, 0x2f, 0x3a, 0x19, 0xc0, 0xfc, 0x13, 0xad, 0x40, 0x55, 0x5c, 0x5d, 0x76,
+	0xc8, 0xa8, 0x34, 0xee, 0xce, 0x25, 0xab, 0x22, 0x48, 0x47, 0x8c, 0xa2, 0x3b, 0x30, 0x2b, 0xbb,
+	0xbd, 0x80, 0x3d, 0x7d, 0x22, 0xce, 0xbc, 0xe9, 0x9d, 0x4b, 0x16, 0x08, 0xe2, 0x2e, 0xa7, 0xa1,
+	0x5b, 0x20, 0x5b, 0x76, 0x8b, 0x10, 0x5f, 0xbe, 0x2f, 0x77, 0x2e, 0x59, 0x92, 0x6b, 0x93, 0x10,
+	0xbf, 0x59, 0x56, 0x57, 0xa5, 0x39, 0x0f, 0x73, 0x09, 0x55, 0xd5, 0x16, 0xb9, 0x30, 0xbf, 0x81,
+	0x7d, 0xcc, 0x13, 0x95, 0xf1, 0xd8, 0x09, 0xc1, 0xd4, 0x29, 0x3e, 0x97, 0x46, 0xaa, 0x5a, 0xe2,
+	0xdb, 0xbc, 0x0e, 0x0b, 0x69, 0x21, 0x4a, 0xb8, 0xc7, 0xd3, 0xe5, 0x90, 0x11, 0x8a, 0xd7, 0x07,
+	0x21, 0x23, 0xbd, 0x1d, 0x42, 0x4e, 0xc3, 0xb1, 0xa8, 0x20, 0xbc, 0x61, 0x22, 0xe1, 0x0d, 0xcb,
+	0x60, 0xe4, 0x89, 0x52, 0x8a, 0x1c, 0x43, 0xa3, 0xe9, 0xb8, 0xa7, 0x83, 0xfe, 0x38, 0xf5, 0x30,
+	0x1f, 0xc3, 0x52, 0x0e, 0xd7, 0x11, 0x2e, 0xfb, 0x1a, 0xee, 0xe4, 0x85, 0xd4, 0x98, 0xa2, 0x27,
+	0xd7, 0x2e, 0xf7, 0xc0, 0x1c, 0x25, 0x52, 0xd9, 0x67, 0x1f, 0x10, 0xbf, 0x93, 0x5e, 0x78, 0x2e,
+	0x0e, 0xc6, 0x70, 0x03, 0x9a, 0xeb, 0x30, 0x9f, 0xe2, 0xa7, 0x6c, 0xf2, 0x08, 0x90, 0x2f, 0x49,
+	0x76, 0xd8, 0x25, 0x94, 0xd9, 0x81, 0xd3, 0x8b, 0xee, 0xbb, 0xba, 0xea, 0x39, 0xe2, 0x1d, 0xfb,
+	0x4e, 0x4f, 0x6c, 0xda, 0x36, 0x66, 0xbb, 0x41, 0x87, 0xac, 0x8d, 0x2f, 0xcb, 0x34, 0x7f, 0x02,
+	0x4b, 0x39, 0x5c, 0x95, 0x82, 0x37, 0x01, 0x74, 0x7a, 0xa9, 0xb6, 0x2e, 0x41, 0xe1, 0x2a, 0xad,
+	0x3b, 0xbe, 0x3b, 0xf0, 0x1d, 0x86, 0xd7, 0xbb, 0xd8, 0x3d, 0x0d, 0x07, 0xbd, 0x8b, 0xab, 0xf4,
+	0xff, 0xb0, 0x94, 0xc3, 0x55, 0xa9, 0x64, 0x40, 0xc5, 0x55, 0x34, 0x65, 0xa9, 0xb8, 0xcd, 0xb7,
+	0x6d, 0x1b, 0xb3, 0xa3, 0xc0, 0xe9, 0x87, 0x5d, 0x72, 0x71, 0xf8, 0xc5, 0xfc, 0x00, 0xe6, 0x53,
+	0xfc, 0x46, 0xb8, 0xf2, 0xb7, 0x25, 0xb8, 0x9b, 0xe7, 0x58, 0x63, 0x53, 0x86, 0x27, 0xba, 0x5d,
+	0xc6, 0xfa, 0xb6, 0xbe, 0x96, 0xca, 0xbc, 0xfd, 0x92, 0xfa, 0xfc, 0x92, 0x15, 0x5d, 0xce, 0x80,
+	0x75, 0x55, 0xee, 0x26, 0xc6, 0xae, 0x0d, 0x58, 0xd7, 0xbc, 0x0f, 0xf7, 0x46, 0x2b, 0xa6, 0x7c,
+	0xfe, 0x0f, 0x25, 0x58, 0xd8, 0xc6, 0xcc, 0x72, 0xce, 0xd6, 0xbb, 0x4e, 0x70, 0x32, 0x0e, 0x04,
+	0xe3, 0x2e, 0x5c, 0xee, 0x50, 0xd2, 0xb3, 0x53, 0x30, 0x46, 0xd5, 0xaa, 0x71, 0x62, 0xfc, 0x4a,
+	0xbd, 0x05, 0xb3, 0x8c, 0xd8, 0xa9, 0x77, 0x6e, 0xd5, 0x02, 0x46, 0xa2, 0x01, 0xe6, 0x5f, 0xa7,
+	0xe0, 0xda, 0x90, 0x62, 0x6a, 0x23, 0x76, 0x60, 0x96, 0x3a, 0x67, 0xb6, 0x2b, 0xc9, 0x8d, 0x92,
+	0xb8, 0xa7, 0xde, 0x4f, 0x64, 0xa7, 0xd9, 0x39, 0xab, 0x31, 0xc9, 0x02, 0x1a, 0xf7, 0x1a, 0xdf,
+	0x4d, 0x42, 0x35, 0xee, 0x41, 0x8b, 0x50, 0xe6, 0xd9, 0x25, 0x7f, 0xb2, 0x48, 0x17, 0x9b, 0xe1,
+	0xcd, 0xdd, 0x76, 0x8c, 0xfe, 0x4c, 0x68, 0xf4, 0x07, 0xad, 0x40, 0x25, 0xc0, 0x67, 0x32, 0x67,
+	0x15, 0xca, 0x37, 0x27, 0x1a, 0x25, 0xab, 0x1c, 0xe0, 0x33, 0x91, 0xb5, 0xae, 0x40, 0x85, 0xbf,
+	0xd3, 0x45, 0xf7, 0x94, 0xee, 0x26, 0x7e, 0x5b, 0x74, 0x1f, 0x40, 0x95, 0xf4, 0x31, 0x75, 0x18,
+	0x5f, 0xfb, 0xb4, 0x48, 0xaf, 0x3f, 0x79, 0xc7, 0x05, 0xac, 0x1e, 0x44, 0x13, 0x2d, 0xcd, 0x83,
+	0xdb, 0x9c, 0xdb, 0x44, 0x33, 0x95, 0x78, 0x4a, 0x8d, 0x3a, 0x67, 0xf1, 0x78, 0xee, 0x4b, 0x5c,
+	0xa9, 0x1e, 0x69, 0x63, 0x91, 0x67, 0x4f, 0x0b, 0x85, 0xf6, 0x48, 0x1b, 0x0b, 0x3c, 0x05, 0x9f,
+	0xc9, 0xae, 0x8a, 0xec, 0x0a, 0xf0, 0x99, 0xe8, 0xba, 0x07, 0x57, 0xa2, 0x95, 0xda, 0xad, 0x73,
+	0x7e, 0x22, 0x54, 0x65, 0x5e, 0xa7, 0xd6, 0xda, 0xe4, 0x34, 0x3e, 0x2a, 0x5a, 0xb0, 0x1a, 0x05,
+	0x72, 0x94, 0x5a, 0xb2, 0x18, 0x65, 0x7a, 0x50, 0xd5, 0xea, 0xcc, 0x42, 0xf9, 0xe5, 0xfe, 0xf3,
+	0xfd, 0x83, 0xcf, 0xf7, 0xeb, 0x97, 0x50, 0x15, 0xa6, 0xd7, 0x36, 0x36, 0x36, 0x37, 0x64, 0xa6,
+	0xbe, 0x7e, 0x70, 0xb8, 0xbb, 0xb9, 0x21, 0x33, 0xf5, 0x8d, 0xcd, 0x17, 0x9b, 0xc7, 0x9b, 0x1b,
+	0xf5, 0x49, 0x54, 0x83, 0xca, 0xde, 0xc1, 0xc6, 0xee, 0x16, 0xef, 0x9a, 0xe2, 0x5d, 0xd6, 0xe6,
+	0xfe, 0xda, 0xde, 0xe6, 0x46, 0x7d, 0x1a, 0xd5, 0xa1, 0x76, 0xfc, 0xc5, 0xe1, 0xa6, 0xbd, 0xbe,
+	0xb3, 0xb6, 0xbf, 0xbd, 0xb9, 0x51, 0x9f, 0x31, 0x7f, 0x5f, 0x82, 0xc6, 0x11, 0x76, 0xa8, 0xdb,
+	0xdd, 0xf2, 0x7c, 0x1c, 0x36, 0xcf, 0xf9, 0x69, 0x7a, 0x71, 0xe7, 0x5e, 0x80, 0xe9, 0xd7, 0x03,
+	0xac, 0xd2, 0x85, 0xaa, 0x25, 0x1b, 0x51, 0x12, 0x37, 0xa9, 0x93, 0xb8, 0xeb, 0x30, 0xd3, 0xf1,
+	0x7c, 0x86, 0xa9, 0xdc, 0x7e, 0x4b, 0xb5, 0xcc, 0x4f, 0x60, 0x29, 0x47, 0x2b, 0x9d, 0x6f, 0x76,
+	0x38, 0x59, 0xf8, 0x74, 0xcd, 0x92, 0x0d, 0xf3, 0xcf, 0x25, 0xb8, 0x91, 0x9a, 0xb3, 0x4e, 0x02,
+	0x86, 0x03, 0xf6, 0xc3, 0x2d, 0xe6, 0x03, 0xa8, 0xbb, 0xdd, 0x41, 0x70, 0x8a, 0x79, 0xe6, 0x29,
+	0x75, 0x55, 0x18, 0xdf, 0x55, 0x45, 0x8f, 0xcf, 0x93, 0x73, 0x58, 0xce, 0xd7, 0x55, 0x2d, 0xb1,
+	0x01, 0xe5, 0x9e, 0xc3, 0xdc, 0x6e, 0xbc, 0xc8, 0xa8, 0x89, 0x56, 0x00, 0xc4, 0xa7, 0x9d, 0xb8,
+	0xbd, 0xab, 0x82, 0xb2, 0xe1, 0x30, 0x07, 0xdd, 0x86, 0x1a, 0x0e, 0xda, 0x36, 0xe9, 0xd8, 0x82,
+	0xa6, 0xb0, 0x47, 0xc0, 0x41, 0xfb, 0xa0, 0xb3, 0xc7, 0x29, 0xe6, 0xef, 0x4a, 0x30, 0x23, 0x91,
+	0xbb, 0xe8, 0x1d, 0x5f, 0x8a, 0xdf, 0xf1, 0x3c, 0x86, 0xc5, 0x35, 0x2b, 0x57, 0x2a, 0xbe, 0xd1,
+	0x8f, 0x61, 0x29, 0x3e, 0x40, 0x09, 0xf5, 0xbe, 0x16, 0x6e, 0x69, 0x77, 0xb1, 0xd3, 0xc6, 0x54,
+	0x9d, 0x48, 0x8b, 0xd1, 0x81, 0x1a, 0xf7, 0xef, 0x88, 0x6e, 0xf4, 0x1e, 0x5c, 0xe9, 0x79, 0x94,
+	0x12, 0x6a, 0x53, 0xdc, 0xe9, 0x39, 0xfd, 0xb0, 0x31, 0x25, 0x9e, 0x82, 0x97, 0x25, 0xd5, 0x92,
+	0x44, 0xf3, 0x0b, 0x58, 0xd9, 0xc6, 0xec, 0xa0, 0xf5, 0x0b, 0xec, 0xb2, 0x0d, 0x8f, 0x62, 0x77,
+	0x7c, 0x68, 0xf5, 0xff, 0xc1, 0xcd, 0x22, 0xd6, 0x23, 0x50, 0xeb, 0x3f, 0x95, 0x60, 0x61, 0xdd,
+	0x27, 0x01, 0xe6, 0xb7, 0xc1, 0x21, 0x21, 0x63, 0x28, 0xd1, 0xdc, 0x87, 0xa9, 0x3e, 0x7f, 0x95,
+	0x0f, 0x25, 0xd0, 0x52, 0x33, 0x21, 0x42, 0xf4, 0xa3, 0xfb, 0x31, 0x9c, 0x3c, 0x99, 0x8b, 0xc8,
+	0xaa, 0x5e, 0x73, 0x11, 0xae, 0x0d, 0x69, 0xa8, 0x7c, 0xeb, 0xef, 0x25, 0x58, 0x4e, 0xf5, 0xec,
+	0x06, 0x0c, 0xd3, 0xc0, 0xf9, 0x01, 0xd7, 0x90, 0x8b, 0x1c, 0x4c, 0xfe, 0x17, 0xc8, 0xc1, 0x2d,
+	0x58, 0x29, 0x58, 0x82, 0x06, 0x9b, 0xb9, 0x3d, 0xde, 0x8c, 0x1b, 0x6c, 0xce, 0x32, 0x55, 0x02,
+	0xdf, 0x72, 0x81, 0x81, 0x38, 0x86, 0xc6, 0x26, 0x50, 0xdc, 0x47, 0xd8, 0x77, 0x98, 0xf7, 0x46,
+	0xe1, 0xba, 0xea, 0x0d, 0x10, 0x11, 0xf9, 0x95, 0x20, 0xb5, 0x1a, 0x96, 0xac, 0xb4, 0xfa, 0x75,
+	0x89, 0xa7, 0x32, 0x7d, 0xdf, 0x73, 0xc7, 0x8b, 0xbb, 0xa3, 0x87, 0x30, 0x23, 0x37, 0x65, 0x04,
+	0xe0, 0xa3, 0x46, 0x98, 0x2b, 0x70, 0x23, 0x57, 0x07, 0xa5, 0xe3, 0x4b, 0x58, 0x3a, 0xe8, 0x33,
+	0xaf, 0x27, 0x62, 0x6e, 0x7c, 0x9b, 0xb5, 0x0c, 0x46, 0x1e, 0x5b, 0x29, 0xf4, 0xc9, 0x3f, 0x6f,
+	0x8a, 0x02, 0x6b, 0x54, 0xa5, 0x92, 0x95, 0x69, 0xf4, 0x25, 0xd4, 0x87, 0x8b, 0xc3, 0xe8, 0x56,
+	0x56, 0x5a, 0xaa, 0x16, 0x6d, 0xdc, 0x2e, 0x1e, 0xa0, 0x56, 0x38, 0xf3, 0xef, 0x6f, 0x1f, 0x4c,
+	0x54, 0x26, 0xd0, 0x57, 0x51, 0x51, 0x37, 0x51, 0xf1, 0x45, 0xc9, 0xe9, 0xb9, 0x25, 0x66, 0xe3,
+	0xce, 0x88, 0x11, 0x29, 0x09, 0x25, 0xf4, 0x1c, 0x40, 0x97, 0x70, 0xd1, 0x52, 0x7a, 0x62, 0xa2,
+	0x94, 0x6c, 0x18, 0x79, 0x5d, 0x59, 0x66, 0xba, 0x54, 0xab, 0x99, 0x65, 0xaa, 0xc1, 0x9a, 0x59,
+	0x4e, 0x65, 0x37, 0x62, 0xf6, 0x39, 0x5c, 0x49, 0x97, 0x54, 0xd1, 0x4a, 0xfc, 0x54, 0xcb, 0x2b,
+	0xfc, 0x1a, 0x37, 0x8b, 0xba, 0x87, 0x18, 0x7f, 0xa9, 0xc0, 0xd8, 0x44, 0xf1, 0x54, 0xef, 0x59,
+	0x41, 0xad, 0x56, 0xef, 0x59, 0x61, 0xdd, 0x35, 0xa1, 0x77, 0xba, 0x9a, 0xa9, 0xf5, 0xce, 0x2d,
+	0x9c, 0x6a, 0xbd, 0xf3, 0x8b, 0xa0, 0xb1, 0x33, 0xb8, 0x80, 0xb2, 0x55, 0x48, 0x14, 0xef, 0x75,
+	0x61, 0x51, 0xd4, 0x30, 0x47, 0x0d, 0x19, 0xd2, 0x7e, 0x1f, 0x66, 0x13, 0xa5, 0x38, 0x14, 0x6f,
+	0x54, 0xb6, 0xc0, 0x69, 0xdc, 0xc8, 0xed, 0xcb, 0x1a, 0x7b, 0x38, 0x1f, 0xd2, 0xc6, 0x2e, 0xa8,
+	0xee, 0x69, 0x63, 0x17, 0x56, 0xea, 0x22, 0xf6, 0x7b, 0x00, 0xba, 0x88, 0xa4, 0x3d, 0x2e, 0x53,
+	0x2a, 0xd3, 0x1e, 0x97, 0xad, 0x39, 0x45, 0x06, 0xfe, 0x58, 0x68, 0x3b, 0x5c, 0x14, 0xd2, 0xda,
+	0x16, 0xd4, 0xa0, 0xb4, 0xb6, 0x45, 0xf5, 0xa4, 0x64, 0x38, 0x67, 0xaa, 0x2c, 0x3a, 0x9c, 0x8b,
+	0x6a, 0x4b, 0x3a, 0x9c, 0x0b, 0x4b, 0x34, 0xb1, 0x3d, 0x7e, 0x04, 0x53, 0x5b, 0xa1, 0x7b, 0x8a,
+	0xe6, 0xe3, 0x29, 0xba, 0x40, 0x63, 0x2c, 0xa4, 0x89, 0x43, 0x53, 0x37, 0xa1, 0x12, 0xd5, 0x28,
+	0xd0, 0x62, 0xca, 0xdb, 0x75, 0xbd, 0xc5, 0x68, 0x64, 0x3b, 0x86, 0xd8, 0x1c, 0xc3, 0xe5, 0x54,
+	0x81, 0x01, 0x2d, 0xc7, 0x52, 0x73, 0xea, 0x1c, 0xc6, 0x4a, 0x41, 0xef, 0x90, 0xe5, 0x9e, 0x03,
+	0x68, 0xe0, 0x5f, 0xef, 0x73, 0xa6, 0x38, 0xa1, 0xf7, 0x39, 0xa7, 0x4e, 0x10, 0xa9, 0xe8, 0x02,
+	0xca, 0x62, 0xf7, 0x3a, 0x90, 0x0a, 0x6b, 0x09, 0x3a, 0x90, 0x8a, 0xa1, 0xff, 0x64, 0xb4, 0x66,
+	0xd1, 0xf6, 0xa4, 0x90, 0x02, 0xf4, 0x3f, 0x29, 0xa4, 0x08, 0xac, 0x8f, 0x85, 0xd0, 0x6c, 0x85,
+	0x5c, 0xa1, 0xe4, 0xe8, 0x7e, 0x51, 0x0c, 0xa5, 0x41, 0x7b, 0xe3, 0xfd, 0xef, 0x1d, 0x37, 0x64,
+	0xbd, 0x23, 0xa8, 0x25, 0x51, 0x72, 0x74, 0x23, 0xcd, 0x20, 0x05, 0x27, 0x1a, 0xcb, 0xf9, 0x9d,
+	0x99, 0xc0, 0xfb, 0x25, 0x18, 0xc5, 0x40, 0x21, 0xfa, 0x60, 0x94, 0x8e, 0x69, 0x81, 0x0f, 0xdf,
+	0x65, 0x68, 0x7a, 0x45, 0x0f, 0x4a, 0x68, 0x07, 0xaa, 0x31, 0x78, 0x8d, 0x1a, 0x45, 0xd0, 0xbb,
+	0xb1, 0x94, 0xd3, 0x33, 0x64, 0x9d, 0xcf, 0xa0, 0x96, 0x04, 0xa3, 0xb5, 0x75, 0x72, 0x70, 0x70,
+	0x6d, 0x9d, 0x5c, 0xfc, 0x3a, 0x79, 0x24, 0x6b, 0x38, 0x33, 0x71, 0x24, 0x67, 0x30, 0xd3, 0xc4,
+	0x91, 0x9c, 0xc5, 0x3f, 0x63, 0xa7, 0x69, 0x89, 0x9f, 0x1c, 0xd2, 0x18, 0x24, 0x4a, 0xfe, 0x65,
+	0x90, 0x0b, 0x7a, 0xea, 0x53, 0xa8, 0x10, 0xc0, 0x4c, 0xec, 0xe7, 0x57, 0x30, 0x97, 0x01, 0x15,
+	0xb5, 0x8c, 0x22, 0x14, 0x53, 0xcb, 0x28, 0x44, 0x24, 0xe3, 0x55, 0x34, 0xa1, 0xac, 0x7e, 0x4d,
+	0x42, 0xd7, 0xe3, 0x59, 0xa9, 0xff, 0x9e, 0x8c, 0xc5, 0x0c, 0x7d, 0xc8, 0xb2, 0x87, 0x30, 0x9b,
+	0x40, 0x1c, 0x51, 0xf2, 0x8e, 0x18, 0x42, 0x12, 0xb5, 0x65, 0x73, 0x20, 0xca, 0xc4, 0xba, 0x7f,
+	0xc5, 0x53, 0xa5, 0x11, 0xf8, 0x1f, 0xfa, 0x70, 0x94, 0x7f, 0x0e, 0x0b, 0x7d, 0xf4, 0x6e, 0x83,
+	0x87, 0x56, 0xf5, 0x73, 0xb8, 0x9c, 0xc2, 0xb2, 0xf4, 0x09, 0x9c, 0x07, 0x38, 0xea, 0x13, 0x38,
+	0x17, 0x00, 0x4b, 0xac, 0xed, 0x14, 0x16, 0xf2, 0x20, 0x06, 0x74, 0x57, 0x47, 0x45, 0x21, 0x58,
+	0x62, 0xdc, 0x1b, 0x3d, 0x28, 0x23, 0xac, 0x05, 0x73, 0x19, 0xbc, 0x46, 0x3b, 0x50, 0x11, 0xc0,
+	0xa4, 0x1d, 0xa8, 0x10, 0xec, 0x49, 0xc8, 0xc0, 0x80, 0xb2, 0x55, 0x1b, 0x94, 0x78, 0x3c, 0x17,
+	0x14, 0x8f, 0xf4, 0x11, 0x3d, 0xa2, 0xe8, 0xa3, 0x0f, 0x97, 0x16, 0xcc, 0x65, 0x0a, 0x35, 0x7a,
+	0x29, 0x45, 0x95, 0x21, 0xbd, 0x94, 0xc2, 0x2a, 0x4f, 0x62, 0x29, 0x04, 0xae, 0xe7, 0x83, 0x12,
+	0xe8, 0xbd, 0xc4, 0xf6, 0x16, 0xe3, 0x21, 0xc6, 0xfd, 0xef, 0x1b, 0x36, 0x14, 0x7e, 0xc7, 0x70,
+	0x39, 0x95, 0x4f, 0x6b, 0x27, 0xcb, 0x43, 0x39, 0xb4, 0x93, 0xe5, 0x23, 0x0c, 0x91, 0xeb, 0xfa,
+	0x43, 0x10, 0x44, 0x94, 0xa5, 0xa3, 0x7b, 0xb9, 0xf3, 0x87, 0x70, 0x08, 0xe3, 0xbd, 0xef, 0x19,
+	0x95, 0x7d, 0x9b, 0x0e, 0x67, 0xe7, 0xc9, 0xe4, 0x2d, 0x17, 0x0c, 0x48, 0x26, 0x6f, 0x05, 0x89,
+	0x7d, 0x8a, 0x7d, 0x3a, 0xcd, 0x4e, 0xb2, 0xcf, 0x4d, 0xfd, 0x93, 0xec, 0x0b, 0x32, 0xf4, 0x88,
+	0x7d, 0x07, 0xe6, 0x73, 0x92, 0x64, 0x94, 0xf0, 0xcd, 0xa2, 0x2c, 0xde, 0xb8, 0x3b, 0x72, 0x4c,
+	0xf6, 0xb5, 0x94, 0x4d, 0x8b, 0x75, 0x94, 0x14, 0x66, 0xe2, 0x3a, 0x4a, 0x8a, 0xb3, 0xea, 0x48,
+	0x48, 0xf3, 0xe3, 0x57, 0x7c, 0xb0, 0xef, 0xb4, 0x56, 0x5d, 0xd2, 0x7b, 0x2c, 0x3f, 0x3f, 0x22,
+	0xf4, 0xe4, 0xb1, 0x64, 0xf1, 0x58, 0xfc, 0xdf, 0xfd, 0xf8, 0x84, 0xa8, 0x76, 0xbf, 0xd5, 0x9a,
+	0x11, 0xa4, 0xa7, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x4f, 0xb9, 0xf5, 0x30, 0x2e, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -4341,7 +4251,6 @@ type RepositoryServiceClient interface {
 	SearchFilesByName(ctx context.Context, in *SearchFilesByNameRequest, opts ...grpc.CallOption) (RepositoryService_SearchFilesByNameClient, error)
 	RestoreCustomHooks(ctx context.Context, opts ...grpc.CallOption) (RepositoryService_RestoreCustomHooksClient, error)
 	BackupCustomHooks(ctx context.Context, in *BackupCustomHooksRequest, opts ...grpc.CallOption) (RepositoryService_BackupCustomHooksClient, error)
-	FetchHTTPRemote(ctx context.Context, in *FetchHTTPRemoteRequest, opts ...grpc.CallOption) (*FetchHTTPRemoteResponse, error)
 	GetObjectDirectorySize(ctx context.Context, in *GetObjectDirectorySizeRequest, opts ...grpc.CallOption) (*GetObjectDirectorySizeResponse, error)
 	CloneFromPool(ctx context.Context, in *CloneFromPoolRequest, opts ...grpc.CallOption) (*CloneFromPoolResponse, error)
 	CloneFromPoolInternal(ctx context.Context, in *CloneFromPoolInternalRequest, opts ...grpc.CallOption) (*CloneFromPoolInternalResponse, error)
@@ -4908,15 +4817,6 @@ func (x *repositoryServiceBackupCustomHooksClient) Recv() (*BackupCustomHooksRes
 	return m, nil
 }
 
-func (c *repositoryServiceClient) FetchHTTPRemote(ctx context.Context, in *FetchHTTPRemoteRequest, opts ...grpc.CallOption) (*FetchHTTPRemoteResponse, error) {
-	out := new(FetchHTTPRemoteResponse)
-	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/FetchHTTPRemote", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *repositoryServiceClient) GetObjectDirectorySize(ctx context.Context, in *GetObjectDirectorySizeRequest, opts ...grpc.CallOption) (*GetObjectDirectorySizeResponse, error) {
 	out := new(GetObjectDirectorySizeResponse)
 	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/GetObjectDirectorySize", in, out, opts...)
@@ -5017,7 +4917,6 @@ type RepositoryServiceServer interface {
 	SearchFilesByName(*SearchFilesByNameRequest, RepositoryService_SearchFilesByNameServer) error
 	RestoreCustomHooks(RepositoryService_RestoreCustomHooksServer) error
 	BackupCustomHooks(*BackupCustomHooksRequest, RepositoryService_BackupCustomHooksServer) error
-	FetchHTTPRemote(context.Context, *FetchHTTPRemoteRequest) (*FetchHTTPRemoteResponse, error)
 	GetObjectDirectorySize(context.Context, *GetObjectDirectorySizeRequest) (*GetObjectDirectorySizeResponse, error)
 	CloneFromPool(context.Context, *CloneFromPoolRequest) (*CloneFromPoolResponse, error)
 	CloneFromPoolInternal(context.Context, *CloneFromPoolInternalRequest) (*CloneFromPoolInternalResponse, error)
@@ -5136,9 +5035,6 @@ func (*UnimplementedRepositoryServiceServer) RestoreCustomHooks(srv RepositorySe
 func (*UnimplementedRepositoryServiceServer) BackupCustomHooks(req *BackupCustomHooksRequest, srv RepositoryService_BackupCustomHooksServer) error {
 	return status.Errorf(codes.Unimplemented, "method BackupCustomHooks not implemented")
 }
-func (*UnimplementedRepositoryServiceServer) FetchHTTPRemote(ctx context.Context, req *FetchHTTPRemoteRequest) (*FetchHTTPRemoteResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method FetchHTTPRemote not implemented")
-}
 func (*UnimplementedRepositoryServiceServer) GetObjectDirectorySize(ctx context.Context, req *GetObjectDirectorySizeRequest) (*GetObjectDirectorySizeResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetObjectDirectorySize not implemented")
 }
@@ -5835,24 +5731,6 @@ func (x *repositoryServiceBackupCustomHooksServer) Send(m *BackupCustomHooksResp
 	return x.ServerStream.SendMsg(m)
 }
 
-func _RepositoryService_FetchHTTPRemote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(FetchHTTPRemoteRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RepositoryServiceServer).FetchHTTPRemote(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.RepositoryService/FetchHTTPRemote",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RepositoryServiceServer).FetchHTTPRemote(ctx, req.(*FetchHTTPRemoteRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _RepositoryService_GetObjectDirectorySize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetObjectDirectorySizeRequest)
 	if err := dec(in); err != nil {
@@ -6084,10 +5962,6 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			Handler:    _RepositoryService_CreateRepositoryFromSnapshot_Handler,
 		},
 		{
-			MethodName: "FetchHTTPRemote",
-			Handler:    _RepositoryService_FetchHTTPRemote_Handler,
-		},
-		{
 			MethodName: "GetObjectDirectorySize",
 			Handler:    _RepositoryService_GetObjectDirectorySize_Handler,
 		},
diff --git a/proto/repository-service.proto b/proto/repository-service.proto
index e7d921b85..24c3ea7fa 100644
--- a/proto/repository-service.proto
+++ b/proto/repository-service.proto
@@ -184,11 +184,6 @@ service RepositoryService {
       op: ACCESSOR
     };
   }
-  rpc FetchHTTPRemote(FetchHTTPRemoteRequest) returns (FetchHTTPRemoteResponse) {
-    option (op_type) = {
-      op: MUTATOR
-    };
-  }
   rpc GetObjectDirectorySize(GetObjectDirectorySizeRequest) returns (GetObjectDirectorySizeResponse) {
     option (op_type) = {
       op: ACCESSOR
@@ -598,14 +593,6 @@ message Remote {
   repeated string mirror_refmaps = 4;
 }
 
-message FetchHTTPRemoteRequest {
-  Repository repository = 1 [(target_repository)=true];
-  Remote remote = 2;
-  int32 timeout = 3;
-}
-
-message FetchHTTPRemoteResponse {}
-
 message GetObjectDirectorySizeRequest {
   Repository repository = 1 [(target_repository)=true];
 }
diff --git a/ruby/proto/gitaly/repository-service_pb.rb b/ruby/proto/gitaly/repository-service_pb.rb
index 0256900fa..c73dd9516 100644
--- a/ruby/proto/gitaly/repository-service_pb.rb
+++ b/ruby/proto/gitaly/repository-service_pb.rb
@@ -288,13 +288,6 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :http_authorization_header, :string, 3
       repeated :mirror_refmaps, :string, 4
     end
-    add_message "gitaly.FetchHTTPRemoteRequest" do
-      optional :repository, :message, 1, "gitaly.Repository"
-      optional :remote, :message, 2, "gitaly.Remote"
-      optional :timeout, :int32, 3
-    end
-    add_message "gitaly.FetchHTTPRemoteResponse" do
-    end
     add_message "gitaly.GetObjectDirectorySizeRequest" do
       optional :repository, :message, 1, "gitaly.Repository"
     end
@@ -416,8 +409,6 @@ module Gitaly
   SearchFilesByContentRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.SearchFilesByContentRequest").msgclass
   SearchFilesByContentResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.SearchFilesByContentResponse").msgclass
   Remote = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Remote").msgclass
-  FetchHTTPRemoteRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FetchHTTPRemoteRequest").msgclass
-  FetchHTTPRemoteResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FetchHTTPRemoteResponse").msgclass
   GetObjectDirectorySizeRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.GetObjectDirectorySizeRequest").msgclass
   GetObjectDirectorySizeResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.GetObjectDirectorySizeResponse").msgclass
   CloneFromPoolRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CloneFromPoolRequest").msgclass
diff --git a/ruby/proto/gitaly/repository-service_services_pb.rb b/ruby/proto/gitaly/repository-service_services_pb.rb
index 43ff783b7..c5a28529b 100644
--- a/ruby/proto/gitaly/repository-service_services_pb.rb
+++ b/ruby/proto/gitaly/repository-service_services_pb.rb
@@ -49,7 +49,6 @@ module Gitaly
       rpc :SearchFilesByName, Gitaly::SearchFilesByNameRequest, stream(Gitaly::SearchFilesByNameResponse)
       rpc :RestoreCustomHooks, stream(Gitaly::RestoreCustomHooksRequest), Gitaly::RestoreCustomHooksResponse
       rpc :BackupCustomHooks, Gitaly::BackupCustomHooksRequest, stream(Gitaly::BackupCustomHooksResponse)
-      rpc :FetchHTTPRemote, Gitaly::FetchHTTPRemoteRequest, Gitaly::FetchHTTPRemoteResponse
       rpc :GetObjectDirectorySize, Gitaly::GetObjectDirectorySizeRequest, Gitaly::GetObjectDirectorySizeResponse
       rpc :CloneFromPool, Gitaly::CloneFromPoolRequest, Gitaly::CloneFromPoolResponse
       rpc :CloneFromPoolInternal, Gitaly::CloneFromPoolInternalRequest, Gitaly::CloneFromPoolInternalResponse