From a3629d57245bbef426eed53188d779c69c17771a Mon Sep 17 00:00:00 2001
From: Philippe Serhal <philippe.serhal@gmail.com>
Date: Fri, 28 Apr 2023 10:26:08 -0400
Subject: [PATCH] chore: misc. 2022 vim updates

---
 .gitignore                                    |    1 +
 vim/bundle/vim-fugitive/.gitattributes        |    2 +
 vim/bundle/vim-fugitive/.github/FUNDING.yml   |    2 +
 vim/bundle/vim-fugitive/CONTRIBUTING.markdown |   10 +-
 vim/bundle/vim-fugitive/README.markdown       |  172 +-
 vim/bundle/vim-fugitive/autoload/fugitive.vim | 6517 +++++++++++++++++
 vim/bundle/vim-fugitive/doc/fugitive.txt      |  771 +-
 vim/bundle/vim-fugitive/ftdetect/fugitive.vim |    1 +
 vim/bundle/vim-fugitive/plugin/fugitive.vim   | 3414 +--------
 vim/bundle/vim-fugitive/syntax/fugitive.vim   |   57 +
 .../vim-fugitive/syntax/fugitiveblame.vim     |    7 +
 vimrc                                         |   19 +-
 12 files changed, 7631 insertions(+), 3342 deletions(-)
 create mode 100644 vim/bundle/vim-fugitive/.gitattributes
 create mode 100644 vim/bundle/vim-fugitive/.github/FUNDING.yml
 create mode 100644 vim/bundle/vim-fugitive/autoload/fugitive.vim
 create mode 100644 vim/bundle/vim-fugitive/ftdetect/fugitive.vim
 create mode 100644 vim/bundle/vim-fugitive/syntax/fugitive.vim
 create mode 100644 vim/bundle/vim-fugitive/syntax/fugitiveblame.vim

diff --git a/.gitignore b/.gitignore
index 225c528..de1f652 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 ssh/known_hosts
 ssh/id_rsa
+vim/runtime/undo
diff --git a/vim/bundle/vim-fugitive/.gitattributes b/vim/bundle/vim-fugitive/.gitattributes
new file mode 100644
index 0000000..50afa41
--- /dev/null
+++ b/vim/bundle/vim-fugitive/.gitattributes
@@ -0,0 +1,2 @@
+.git* export-ignore
+*.markdown export-ignore
diff --git a/vim/bundle/vim-fugitive/.github/FUNDING.yml b/vim/bundle/vim-fugitive/.github/FUNDING.yml
new file mode 100644
index 0000000..e2a49d1
--- /dev/null
+++ b/vim/bundle/vim-fugitive/.github/FUNDING.yml
@@ -0,0 +1,2 @@
+github: tpope
+custom: ["https://www.paypal.me/vimpope"]
diff --git a/vim/bundle/vim-fugitive/CONTRIBUTING.markdown b/vim/bundle/vim-fugitive/CONTRIBUTING.markdown
index e651dca..843bbe6 100644
--- a/vim/bundle/vim-fugitive/CONTRIBUTING.markdown
+++ b/vim/bundle/vim-fugitive/CONTRIBUTING.markdown
@@ -8,8 +8,14 @@ platform issues, and interactions with other plugins.  I end up bisecting a
 lot more than other projects, and thus I'm especially meticulous here about
 maintaining a clean, readable, history.  Squash and force push any requested
 changes to a pull request.  And if your [commit message
-sucks](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html),
-I'm not going to accept it.  Period.
+sucks](https://commit.style), I'm not going to accept it.  Period.
+
+If your contribution involves adding a configuration option, you are going to
+need a very compelling justification for it.  Options add a maintenance
+burden, support burden, and documentation bloat, and oftentimes can be
+achieved much more simply with a custom map or autocommand.  If your option
+controls an underlying Git command, ask yourself why Git itself does not offer
+such configuration.
 
 Beyond that, don't be shy about asking before patching.  What takes you hours
 might take me minutes simply because I have both domain knowledge and a
diff --git a/vim/bundle/vim-fugitive/README.markdown b/vim/bundle/vim-fugitive/README.markdown
index fd15cc9..198490a 100644
--- a/vim/bundle/vim-fugitive/README.markdown
+++ b/vim/bundle/vim-fugitive/README.markdown
@@ -1,55 +1,80 @@
 # fugitive.vim
 
-I'm not going to lie to you; fugitive.vim may very well be the best
-Git wrapper of all time.  Check out these features:
-
-View any blob, tree, commit, or tag in the repository with `:Gedit` (and
-`:Gsplit`, `:Gvsplit`, `:Gtabedit`, ...).  Edit a file in the index and
-write to it to stage the changes.  Use `:Gdiff` to bring up the staged
-version of the file side by side with the working tree version and use
-Vim's diff handling capabilities to stage a subset of the file's
-changes.
-
-Bring up the output of `git status` with `:Gstatus`.  Press `-` to
-`add`/`reset` a file's changes, or `p` to `add`/`reset` `--patch`.  And guess
-what `:Gcommit` does!
-
-`:Gblame` brings up an interactive vertical split with `git blame`
-output.  Press enter on a line to edit the commit where the line
-changed, or `o` to open it in a split.  When you're done, use `:Gedit`
-in the historic buffer to go back to the work tree version.
-
-`:Gmove` does a `git mv` on a file and simultaneously renames the
-buffer.  `:Gdelete` does a `git rm` on a file and simultaneously deletes
-the buffer.
-
-Use `:Ggrep` to search the work tree (or any arbitrary commit) with
-`git grep`, skipping over that which is not tracked in the repository.
-`:Glog` loads all previous revisions of a file into the quickfix list so
-you can iterate over them and watch the file evolve!
-
-`:Gread` is a variant of `git checkout -- filename` that operates on the
-buffer rather than the filename.  This means you can use `u` to undo it
-and you never get any warnings about the file changing outside Vim.
-`:Gwrite` writes to both the work tree and index versions of a file,
-making it like `git add` when called from a work tree file and like
-`git checkout` when called from the index or a blob in history.
-
-Use `:Gbrowse` to open the current file on the web front-end of your favorite
-hosting provider, with optional line range (try it in visual mode!).  Built-in
-support is provided for `git instaweb`, and plugins are available for popular
-providers such as [GitHub][rhubarb.vim], [GitLab][fugitive-gitlab.vim], and
-[Bitbucket][fubitive.vim].
+Fugitive is the premier Vim plugin for Git.  Or maybe it's the premier Git
+plugin for Vim?  Either way, it's "so awesome, it should be illegal".  That's
+why it's called Fugitive.
+
+The crown jewel of Fugitive is `:Git` (or just `:G`), which calls any
+arbitrary Git command.  If you know how to use Git at the command line, you
+know how to use `:Git`.  It's vaguely akin to `:!git` but with numerous
+improvements:
+
+* The default behavior is to directly echo the command's output.  Quiet
+  commands like `:Git add` avoid the dreaded "Press ENTER or type command to
+  continue" prompt.
+* `:Git commit`, `:Git rebase -i`, and other commands that invoke an editor do
+  their editing in the current Vim instance.
+* `:Git diff`, `:Git log`, and other verbose, paginated commands have their
+  output loaded into a temporary buffer.  Force this behavior for any command
+  with `:Git --paginate` or `:Git -p`.
+* `:Git blame` uses a temporary buffer with maps for additional triage.  Press
+  enter on a line to view the commit where the line changed, or `g?` to see
+  other available maps.  Omit the filename argument and the currently edited
+  file will be blamed in a vertical, scroll-bound split.
+* `:Git mergetool` and `:Git difftool` load their changesets into the quickfix
+  list.
+* Called with no arguments, `:Git` opens a summary window with dirty files and
+  unpushed and unpulled commits.  Press `g?` to bring up a list of maps for
+  numerous operations including diffing, staging, committing, rebasing, and
+  stashing.  (This is the successor to the old `:Gstatus`.)
+* This command (along with all other commands) always uses the current
+  buffer's repository, so you don't need to worry about the current working
+  directory.
+
+Additional commands are provided for higher level operations:
+
+* View any blob, tree, commit, or tag in the repository with `:Gedit` (and
+  `:Gsplit`, etc.).  For example, `:Gedit HEAD~3:%` loads the current file as
+  it existed 3 commits ago.
+* `:Gdiffsplit` brings up the staged version of the file side by side with the
+  working tree version.  Use Vim's diff handling capabilities to apply changes
+  to the staged version, and write that buffer to stage the changes.  You can
+  also give an arbitrary `:Gedit` argument to diff against older versions of
+  the file.
+* `:Gread` is a variant of `git checkout -- filename` that operates on the
+  buffer rather than the file itself.  This means you can use `u` to undo it
+  and you never get any warnings about the file changing outside Vim.
+* `:Gwrite` writes to both the work tree and index versions of a file, making
+  it like `git add` when called from a work tree file and like `git checkout`
+  when called from the index or a blob in history.
+* `:Ggrep` is `:grep` for `git grep`.  `:Glgrep` is `:lgrep` for the same.
+* `:GMove` does a `git mv` on the current file and changes the buffer name to
+  match.  `:GRename` does the same with a destination filename relative to the
+  current file's directory.
+* `:GDelete` does a `git rm` on the current file and simultaneously deletes
+  the buffer.  `:GRemove` does the same but leaves the (now empty) buffer
+  open.
+* `:GBrowse` to open the current file on the web front-end of your favorite
+  hosting provider, with optional line range (try it in visual mode).  Plugins
+  are available for popular providers such as [GitHub][rhubarb.vim],
+  [GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim],
+  [Gitee][fugitive-gitee.vim], [Pagure][pagure],
+  [Phabricator][vim-phabricator], [Azure DevOps][fugitive-azure-devops.vim],
+  and [sourcehut][srht.vim].
 
 [rhubarb.vim]: https://github.com/tpope/vim-rhubarb
 [fugitive-gitlab.vim]: https://github.com/shumphrey/fugitive-gitlab.vim
 [fubitive.vim]: https://github.com/tommcdo/vim-fubitive
+[fugitive-gitee.vim]: https://github.com/linuxsuren/fugitive-gitee.vim
+[pagure]: https://github.com/FrostyX/vim-fugitive-pagure
+[vim-phabricator]: https://github.com/jparise/vim-phabricator
+[fugitive-azure-devops.vim]: https://github.com/cedarbaum/fugitive-azure-devops.vim
+[srht.vim]: https://git.sr.ht/~willdurand/srht.vim
 
-Add `%{fugitive#statusline()}` to `'statusline'` to get an indicator
-with the current branch in (surprise!) your statusline.
+Add `%{FugitiveStatusline()}` to `'statusline'` to get an indicator
+with the current branch in your statusline.
 
-Last but not least, there's `:Git` for running any arbitrary command,
-and `Git!` to open the output of a command in a temp file.
+For more information, see `:help fugitive`.
 
 ## Screencasts
 
@@ -61,53 +86,34 @@ and `Git!` to open the output of a command in a temp file.
 
 ## Installation
 
-If you don't have a preferred installation method, one option is to install
-[pathogen.vim](https://github.com/tpope/vim-pathogen), and then copy
-and paste:
+Install using your favorite package manager, or use Vim's built-in package support:
 
-    cd ~/.vim/bundle
-    git clone https://github.com/tpope/vim-fugitive.git
-    vim -u NONE -c "helptags vim-fugitive/doc" -c q
-
-If your Vim version is below 7.2, I recommend also installing
-[vim-git](https://github.com/tpope/vim-git) for syntax highlighting and
-other Git niceties.
+    mkdir -p ~/.vim/pack/tpope/start
+    cd ~/.vim/pack/tpope/start
+    git clone https://tpope.io/vim/fugitive.git
+    vim -u NONE -c "helptags fugitive/doc" -c q
 
 ## FAQ
 
-> I installed the plugin and started Vim.  Why don't any of the commands
-> exist?
-
-Fugitive cares about the current file, not the current working
-directory.  Edit a file from the repository.
-
-> I opened a new tab.  Why don't any of the commands exist?
-
-Fugitive cares about the current file, not the current working
-directory.  Edit a file from the repository.
-
-> Why is `:Gbrowse` not using the right browser?
-
-`:Gbrowse` delegates to `git web--browse`, which is less than perfect
-when it comes to finding the right browser.  You can tell it the correct
-browser to use with `git config --global web.browser ...`.  On macOS, for
-example, you might want to set this to `open`.  See `git web--browse --help`
-for details.
+> What happened to the dispatch.vim backed asynchronous `:Gpush` and
+> `:Gfetch`?
 
-> Here's a patch that automatically opens the quickfix window after
-> `:Ggrep`.
+This behavior was divisive, confusing, and complicated inputting passwords, so
+it was removed.  Use `:Dispatch git push` for effectively the same behavior,
+or provide your own asynchronous `:Gpush` and `:Gfetch` by adding the
+following to your vimrc:
 
-This is a great example of why I recommend asking before patching.
-There are valid arguments to be made both for and against automatically
-opening the quickfix window.  Whenever I have to make an arbitrary
-decision like this, I ask what Vim would do.  And Vim does not open a
-quickfix window after `:grep`.
+    command! -bang -bar -nargs=* Gpush execute 'Dispatch<bang> -dir=' .
+          \ fnameescape(FugitiveGitDir()) 'git push' <q-args>
+    command! -bang -bar -nargs=* Gfetch execute 'Dispatch<bang> -dir=' .
+          \ fnameescape(FugitiveGitDir()) 'git fetch' <q-args>
 
-Luckily, it's easy to implement the desired behavior without changing
-fugitive.vim.  The following autocommand will cause the quickfix window
-to open after any grep invocation:
+> So I have a symlink and...
 
-    autocmd QuickFixCmdPost *grep* cwindow
+Stop.  Just stop.  If Git won't deal with your symlink, then Fugitive won't
+either.  Consider using a [plugin that resolves
+symlinks](https://github.com/aymericbeaumet/symlink.vim), or even better,
+using fewer symlinks.
 
 ## Self-Promotion
 
diff --git a/vim/bundle/vim-fugitive/autoload/fugitive.vim b/vim/bundle/vim-fugitive/autoload/fugitive.vim
new file mode 100644
index 0000000..6e48d9d
--- /dev/null
+++ b/vim/bundle/vim-fugitive/autoload/fugitive.vim
@@ -0,0 +1,6517 @@
+" Location:     autoload/fugitive.vim
+" Maintainer:   Tim Pope <http://tpo.pe/>
+
+if exists('g:autoloaded_fugitive')
+  finish
+endif
+let g:autoloaded_fugitive = 1
+
+if !exists('g:fugitive_git_executable')
+  let g:fugitive_git_executable = 'git'
+elseif g:fugitive_git_executable =~# '^\w\+='
+  let g:fugitive_git_executable = 'env ' . g:fugitive_git_executable
+endif
+
+" Section: Utility
+
+function! s:function(name) abort
+  return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '.*\zs<SNR>\d\+_'),''))
+endfunction
+
+function! s:sub(str,pat,rep) abort
+  return substitute(a:str,'\v\C'.a:pat,a:rep,'')
+endfunction
+
+function! s:gsub(str,pat,rep) abort
+  return substitute(a:str,'\v\C'.a:pat,a:rep,'g')
+endfunction
+
+function! s:Uniq(list) abort
+  let i = 0
+  let seen = {}
+  while i < len(a:list)
+    let str = string(a:list[i])
+    if has_key(seen, str)
+      call remove(a:list, i)
+    else
+      let seen[str] = 1
+      let i += 1
+    endif
+  endwhile
+  return a:list
+endfunction
+
+function! s:winshell() abort
+  return has('win32') && &shellcmdflag !~# '^-'
+endfunction
+
+function! s:WinShellEsc(arg) abort
+  if type(a:arg) == type([])
+    return join(map(copy(a:arg), 's:shellesc(v:val)'))
+  elseif a:arg =~# '^[A-Za-z0-9_/:.-]\+$'
+    return a:arg
+  else
+    return '"' . s:gsub(s:gsub(a:arg, '"', '""'), '\%', '"%"') . '"'
+  endif
+endfunction
+
+function! s:shellesc(arg) abort
+  if type(a:arg) == type([])
+    return join(map(copy(a:arg), 's:shellesc(v:val)'))
+  elseif a:arg =~# '^[A-Za-z0-9_/:.-]\+$'
+    return a:arg
+  elseif s:winshell()
+    return '"' . s:gsub(s:gsub(a:arg, '"', '""'), '\%', '"%"') . '"'
+  else
+    return shellescape(a:arg)
+  endif
+endfunction
+
+let s:fnameescape = " \t\n*?[{`$\\%#'\"|!<"
+function! s:fnameescape(file) abort
+  if type(a:file) == type([])
+    return join(map(copy(a:file), 's:fnameescape(v:val)'))
+  elseif exists('*fnameescape')
+    return fnameescape(a:file)
+  else
+    return escape(a:file, s:fnameescape)
+  endif
+endfunction
+
+function! s:throw(string) abort
+  throw 'fugitive: '.a:string
+endfunction
+
+function! s:DirCheck(...) abort
+  if !empty(a:0 ? s:Dir(a:1) : s:Dir())
+    return ''
+  elseif empty(bufname(''))
+    return 'return ' . string('echoerr "fugitive: working directory does not belong to a Git repository"')
+  else
+    return 'return ' . string('echoerr "fugitive: file does not belong to a Git repository"')
+  endif
+endfunction
+
+function! s:Mods(mods, ...) abort
+  let mods = substitute(a:mods, '\C<mods>', '', '')
+  let mods = mods =~# '\S$' ? mods . ' ' : mods
+  if a:0 && mods !~# '\<\%(aboveleft\|belowright\|leftabove\|rightbelow\|topleft\|botright\|tab\)\>'
+    let mods = a:1 . ' ' . mods
+  endif
+  return substitute(mods, '\s\+', ' ', 'g')
+endfunction
+
+if exists('+shellslash')
+  function! s:Slash(path) abort
+    return tr(a:path, '\', '/')
+  endfunction
+else
+  function! s:Slash(path) abort
+    return a:path
+  endfunction
+endif
+
+function! s:Resolve(path) abort
+  let path = resolve(a:path)
+  if has('win32')
+    let path = FugitiveVimPath(fnamemodify(fnamemodify(path, ':h'), ':p') . fnamemodify(path, ':t'))
+  endif
+  return path
+endfunction
+
+function! s:FileIgnoreCase(for_completion) abort
+  return (exists('+fileignorecase') && &fileignorecase)
+        \ || (a:for_completion && exists('+wildignorecase') && &wildignorecase)
+endfunction
+
+function! s:cpath(path, ...) abort
+  if s:FileIgnoreCase(0)
+    let path = FugitiveVimPath(tolower(a:path))
+  else
+    let path = FugitiveVimPath(a:path)
+  endif
+  return a:0 ? path ==# s:cpath(a:1) : path
+endfunction
+
+let s:executables = {}
+
+function! s:executable(binary) abort
+  if !has_key(s:executables, a:binary)
+    let s:executables[a:binary] = executable(a:binary)
+  endif
+  return s:executables[a:binary]
+endfunction
+
+if !exists('s:temp_scripts')
+  let s:temp_scripts = {}
+endif
+function! s:TempScript(...) abort
+  let body = join(a:000, "\n")
+  if !has_key(s:temp_scripts, body)
+    let s:temp_scripts[body] = tempname() . '.sh'
+  endif
+  let temp = s:temp_scripts[body]
+  if !filereadable(temp)
+    call writefile(['#!/bin/sh'] + a:000, temp)
+  endif
+  return FugitiveGitPath(temp)
+endfunction
+
+function! s:DoAutocmd(cmd) abort
+  if v:version >= 704 || (v:version == 703 && has('patch442'))
+    return 'doautocmd <nomodeline>' . a:cmd
+  elseif &modelines > 0
+    return 'try|set modelines=0|doautocmd ' . a:cmd . '|finally|set modelines=' . &modelines . '|endtry'
+  else
+    return 'doautocmd ' . a:cmd
+  endif
+endfunction
+
+let s:nowait = v:version >= 704 ? '<nowait>' : ''
+
+function! s:Map(mode, lhs, rhs, ...) abort
+  for mode in split(a:mode, '\zs')
+    let flags = (a:0 ? a:1 : '') . (a:rhs =~# '<Plug>' ? '' : '<script>')
+    let head = a:lhs
+    let tail = ''
+    let keys = get(g:, mode.'remap', {})
+    if type(keys) == type([])
+      return
+    endif
+    while !empty(head)
+      if has_key(keys, head)
+        let head = keys[head]
+        if empty(head)
+          return
+        endif
+        break
+      endif
+      let tail = matchstr(head, '<[^<>]*>$\|.$') . tail
+      let head = substitute(head, '<[^<>]*>$\|.$', '', '')
+    endwhile
+    if flags !~# '<unique>' || empty(mapcheck(head.tail, mode))
+      exe mode.'map <buffer>' s:nowait flags head.tail a:rhs
+      if a:0 > 1
+        let b:undo_ftplugin = get(b:, 'undo_ftplugin', 'exe') .
+              \ '|sil! exe "' . mode . 'unmap <buffer> ' . head.tail . '"'
+      endif
+    endif
+  endfor
+endfunction
+
+" Section: Git
+
+function! s:UserCommandList(...) abort
+  let git = split(get(g:, 'fugitive_git_command', g:fugitive_git_executable), '\s\+')
+  let flags = []
+  if a:0 && type(a:1) == type({})
+    let git = copy(get(a:1, 'git', git))
+    let flags = get(a:1, 'flags', flags)
+    let dir = a:1.dir
+  elseif a:0
+    let dir = a:1
+  else
+    let dir = ''
+  endif
+  if len(dir)
+    let tree = s:Tree(dir)
+    if empty(tree)
+      call add(git, '--git-dir=' . FugitiveGitPath(dir))
+    elseif len(tree) && s:cpath(tree) !=# s:cpath(getcwd())
+      if fugitive#GitVersion(1, 8, 5)
+        call extend(git, ['-C', FugitiveGitPath(tree)])
+      else
+        throw 'fugitive: Git 1.8.5 or higher required to change directory'
+      endif
+    endif
+  endif
+  return git + flags
+endfunction
+
+function! s:UserCommand(...) abort
+  return s:shellesc(call('s:UserCommandList', a:0 ? [a:1] : []) + (a:0 ? a:2 : []))
+endfunction
+
+let s:git_versions = {}
+function! fugitive#GitVersion(...) abort
+  if !has_key(s:git_versions, g:fugitive_git_executable)
+    let s:git_versions[g:fugitive_git_executable] = matchstr(s:SystemError(g:fugitive_git_executable.' --version')[0], '\d[^[:space:]]\+')
+  endif
+  if !a:0
+    return s:git_versions[g:fugitive_git_executable]
+  endif
+  let components = split(s:git_versions[g:fugitive_git_executable], '\D\+')
+  if empty(components)
+    return -1
+  endif
+  for i in range(len(a:000))
+    if a:000[i] > +get(components, i)
+      return 0
+    elseif a:000[i] < +get(components, i)
+      return 1
+    endif
+  endfor
+  return a:000[i] ==# get(components, i)
+endfunction
+
+let s:commondirs = {}
+function! fugitive#CommonDir(dir) abort
+  if empty(a:dir)
+    return ''
+  endif
+  if !has_key(s:commondirs, a:dir)
+    if getfsize(a:dir . '/HEAD') < 10
+      let s:commondirs[a:dir] = ''
+    elseif filereadable(a:dir . '/commondir')
+      let cdir = get(readfile(a:dir . '/commondir', 1), 0, '')
+      if cdir =~# '^/\|^\a:/'
+        let s:commondirs[a:dir] = s:Slash(FugitiveVimPath(cdir))
+      else
+        let s:commondirs[a:dir] = simplify(a:dir . '/' . cdir)
+      endif
+    else
+      let s:commondirs[a:dir] = a:dir
+    endif
+  endif
+  return s:commondirs[a:dir]
+endfunction
+
+function! s:Dir(...) abort
+  return a:0 ? FugitiveGitDir(a:1) : FugitiveGitDir()
+endfunction
+
+function! s:Tree(...) abort
+  return a:0 ? FugitiveWorkTree(a:1) : FugitiveWorkTree()
+endfunction
+
+function! s:HasOpt(args, ...) abort
+  let args = a:args[0 : index(a:args, '--')]
+  let opts = copy(a:000)
+  if type(opts[0]) == type([])
+    if empty(args) || index(opts[0], args[0]) == -1
+      return 0
+    endif
+    call remove(opts, 0)
+  endif
+  for opt in opts
+    if index(args, opt) != -1
+      return 1
+    endif
+  endfor
+endfunction
+
+function! s:PreparePathArgs(cmd, dir, literal) abort
+  let literal_supported = fugitive#GitVersion(1, 9)
+  if a:literal && literal_supported
+    call insert(a:cmd, '--literal-pathspecs')
+  endif
+  let split = index(a:cmd, '--')
+  for i in range(split < 0 ? len(a:cmd) : split)
+    if type(a:cmd[i]) == type(0)
+      let a:cmd[i] = fugitive#Path(bufname(a:cmd[i]), './', a:dir)
+    endif
+  endfor
+  if split < 0
+    return a:cmd
+  endif
+  for i in range(split + 1, len(a:cmd) - 1)
+    if type(a:cmd[i]) == type(0)
+      let a:cmd[i] = fugitive#Path(bufname(a:cmd[i]), './', a:dir)
+    elseif a:literal
+      let a:cmd[i] = fugitive#Path(a:cmd[i], './', a:dir)
+    elseif !literal_supported
+      let a:cmd[i] = substitute(a:cmd[i], '^:\%(/\|([^)]*)\)\=:\=', './', '')
+    endif
+  endfor
+  return a:cmd
+endfunction
+
+let s:prepare_env = {
+      \ 'sequence.editor': 'GIT_SEQUENCE_EDITOR',
+      \ 'core.editor': 'GIT_EDITOR',
+      \ 'core.askpass': 'GIT_ASKPASS',
+      \ }
+function! fugitive#PrepareDirEnvGitArgv(...) abort
+  let git = split(g:fugitive_git_executable)
+  if a:0 && type(a:1) ==# type([])
+    let cmd = a:000[1:-1] + a:1
+  else
+    let cmd = copy(a:000)
+  endif
+  let env = {}
+  let i = 0
+  while i < len(cmd)
+    if type(cmd[i]) == type({})
+      if has_key(cmd[i], 'dir')
+        let dir = cmd[i].dir
+      endif
+      if has_key(cmd[i], 'git')
+        let git = cmd[i].git
+      endif
+      call remove(cmd, i)
+    elseif cmd[i] =~# '^$\|[\/.]' && cmd[i] !~# '^-'
+      let dir = remove(cmd, i)
+    elseif cmd[i] =~# '^--git-dir='
+      let dir = remove(cmd, i)[10:-1]
+    elseif type(cmd[i]) ==# type(0)
+      let dir = s:Dir(remove(cmd, i))
+    elseif cmd[i] ==# '-c' && len(cmd) > i + 1
+      let key = matchstr(cmd[i+1], '^[^=]*')
+      if has_key(s:prepare_env, tolower(key)) || key !~# '\.'
+        let var = get(s:prepare_env, tolower(key), key)
+        let val = matchstr(cmd[i+1], '=\zs.*')
+        let env[var] = val
+      endif
+      if fugitive#GitVersion(1, 8) && cmd[i+1] =~# '\.'
+        let i += 2
+      else
+        call remove(cmd, i, i + 1)
+      endif
+    elseif cmd[i] =~# '^--.*pathspecs$'
+      let explicit_pathspec_option = 1
+      if fugitive#GitVersion(1, 9)
+        let i += 1
+      else
+        call remove(cmd, i)
+      endif
+    elseif cmd[i] !~# '^-'
+      break
+    else
+      let i += 1
+    endif
+  endwhile
+  if !exists('dir')
+    let dir = s:Dir()
+  endif
+  call s:PreparePathArgs(cmd, dir, !exists('explicit_pathspec_option'))
+  return [dir, env, git, cmd]
+endfunction
+
+function! s:BuildEnvPrefix(env) abort
+  let pre = ''
+  let env = items(a:env)
+  if empty(env)
+    return ''
+  elseif &shellcmdflag =~# '-Command'
+    return join(map(env, '"$Env:" . v:val[0] . " = ''" . substitute(v:val[1], "''", "''''", "g") . "''; "'), '')
+  elseif s:winshell()
+    return join(map(env, '"set " . substitute(join(v:val, "="), "[&|<>^]", "^^^&", "g") . "& "'), '')
+  else
+    return 'env ' . s:shellesc(map(env, 'join(v:val, "=")')) . ' '
+  endif
+endfunction
+
+function! s:JobOpts(cmd, env) abort
+  if empty(a:env)
+    return [a:cmd, {}]
+  elseif has('patch-8.2.0239') || has('patch-8.1.0902') && !has('nvim') && (!has('win32') || empty(filter(keys(a:env), 'exists("$" . v:val)')))
+    return [a:cmd, {'env': a:env}]
+  endif
+  let envlist = map(items(a:env), 'join(v:val, "=")')
+  if !has('win32')
+    return [['env'] + envlist + a:cmd, {}]
+  else
+    let pre = join(map(envlist, '"set " . substitute(v:val, "[&|<>^]", "^^^&", "g") . "& "'), '')
+    if len(a:cmd) == 3 && a:cmd[0] ==# 'cmd.exe' && a:cmd[1] ==# '/c'
+      return [a:cmd[0:1] + [pre . a:cmd[2]], {}]
+    else
+      return [['cmd.exe', '/c', pre . s:WinShellEsc(a:cmd)], {}]
+    endif
+  endif
+endfunction
+
+function! s:BuildShell(dir, env, git, args) abort
+  let cmd = copy(a:args)
+  let tree = s:Tree(a:dir)
+  let pre = s:BuildEnvPrefix(a:env)
+  if empty(tree) || index(cmd, '--') == len(cmd) - 1
+    call insert(cmd, '--git-dir=' . FugitiveGitPath(a:dir))
+  elseif fugitive#GitVersion(1, 8, 5)
+    call extend(cmd, ['-C', FugitiveGitPath(tree)], 'keep')
+  else
+    let pre = 'cd ' . s:shellesc(tree) . (s:winshell() ? '& ' : '; ') . pre
+  endif
+  return pre . join(map(a:git + cmd, 's:shellesc(v:val)'))
+endfunction
+
+function! fugitive#Prepare(...) abort
+  let [dir, env, git, argv] = call('fugitive#PrepareDirEnvGitArgv', a:000)
+  return s:BuildShell(dir, env, git, argv)
+endfunction
+
+function! s:SystemError(cmd, ...) abort
+  try
+    if &shellredir ==# '>' && &shell =~# 'sh\|cmd'
+      let shellredir = &shellredir
+      if &shell =~# 'csh'
+        set shellredir=>&
+      else
+        set shellredir=>%s\ 2>&1
+      endif
+    endif
+    if exists('+guioptions') && &guioptions =~# '!'
+      let guioptions = &guioptions
+      set guioptions-=!
+    endif
+    let out = call('system', [type(a:cmd) ==# type([]) ? fugitive#Prepare(a:cmd) : a:cmd] + a:000)
+    return [out, v:shell_error]
+  catch /^Vim\%((\a\+)\)\=:E484:/
+    let opts = ['shell', 'shellcmdflag', 'shellredir', 'shellquote', 'shellxquote', 'shellxescape', 'shellslash']
+    call filter(opts, 'exists("+".v:val) && !empty(eval("&".v:val))')
+    call map(opts, 'v:val."=".eval("&".v:val)')
+    call s:throw('failed to run `' . a:cmd . '` with ' . join(opts, ' '))
+  finally
+    if exists('shellredir')
+      let &shellredir = shellredir
+    endif
+    if exists('guioptions')
+      let &guioptions = guioptions
+    endif
+  endtry
+endfunction
+
+function! s:ChompError(...) abort
+  let [out, exec_error] = s:SystemError(call('fugitive#Prepare', a:000))
+  return [s:sub(out, '\n$', ''), exec_error]
+endfunction
+
+function! s:ChompDefault(default, ...) abort
+  let [out, exec_error] = call('s:ChompError', a:000)
+  return exec_error ? a:default : out
+endfunction
+
+function! s:LinesError(...) abort
+  let [out, exec_error] = call('s:ChompError', a:000)
+  return [len(out) && !exec_error ? split(out, "\n", 1) : [], exec_error]
+endfunction
+
+function! s:NullError(...) abort
+  let [out, exec_error] = s:SystemError(call('fugitive#Prepare', a:000))
+  return [exec_error ? [] : split(out, "\1"), exec_error ? substitute(out, "\n$", "", "") : '', exec_error]
+endfunction
+
+function! s:TreeChomp(...) abort
+  let cmd = call('fugitive#Prepare', a:000)
+  let [out, exec_error] = s:SystemError(cmd)
+  let out = s:sub(out, '\n$', '')
+  if !exec_error
+    return out
+  endif
+  throw 'fugitive: error running `' . cmd . '`: ' . out
+endfunction
+
+function! s:EchoExec(...) abort
+  if s:RunJobs()
+    return 'Git ' . s:fnameescape(a:000)
+  else
+    echo call('s:ChompError', a:000)[0]
+    call fugitive#ReloadStatus(-1, 1)
+    return 'checktime'
+  endif
+endfunction
+
+let s:head_cache = {}
+
+function! fugitive#Head(...) abort
+  let dir = a:0 > 1 ? a:2 : s:Dir()
+  if empty(dir)
+    return ''
+  endif
+  let file = fugitive#Find('.git/HEAD', dir)
+  let ftime = getftime(file)
+  if ftime == -1
+    return ''
+  elseif ftime != get(s:head_cache, dir, [-1])[0]
+    let s:head_cache[dir] = [ftime, readfile(file)[0]]
+  endif
+  let head = s:head_cache[dir][1]
+  if head =~# '^ref: '
+    return substitute(head, '\C^ref: \%(refs/\%(heads/\|remotes/\|tags/\)\=\)\=', '', '')
+  elseif head =~# '^\x\{40,\}$'
+    let len = a:0 ? a:1 : 0
+    return len < 0 ? head : len ? head[0:len-1] : ''
+  else
+    return ''
+  endif
+endfunction
+
+function! fugitive#RevParse(rev, ...) abort
+  let [hash, exec_error] = s:ChompError([a:0 ? a:1 : s:Dir(), 'rev-parse', '--verify', a:rev, '--'])
+  if !exec_error && hash =~# '^\x\{40,\}$'
+    return hash
+  endif
+  throw 'fugitive: rev-parse '.a:rev.': '.hash
+endfunction
+
+function! s:ConfigTimestamps(dir, dict) abort
+  let files = ['/etc/gitconfig', '~/.gitconfig',
+        \ len($XDG_CONFIG_HOME) ? $XDG_CONFIG_HOME . '/git/config' : '~/.config/git/config']
+  if len(a:dir)
+    call add(files, fugitive#Find('.git/config', a:dir))
+  endif
+  call extend(files, get(a:dict, 'include.path', []))
+  return join(map(files, 'getftime(expand(v:val))'), ',')
+endfunction
+
+let s:config = {}
+function! fugitive#Config(...) abort
+  let dir = s:Dir()
+  let name = ''
+  if a:0 >= 2 && type(a:2) == type({})
+    let name = substitute(a:1, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+    return len(a:1) ? get(get(a:2, name, []), 0, '') : a:2
+  elseif a:0 >= 2
+    let dir = a:2
+    let name = a:1
+  elseif a:0 == 1 && type(a:1) == type({})
+    return a:1
+  elseif a:0 == 1 && a:1 =~# '^[[:alnum:]-]\+\.'
+    let name = a:1
+  elseif a:0 == 1
+    let dir = a:1
+  endif
+  let name = substitute(name, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+  let dir_key = len(dir) ? dir : '_'
+  if has_key(s:config, dir_key) && s:config[dir_key][0] ==# s:ConfigTimestamps(dir, s:config[dir_key][1])
+    let dict = s:config[dir_key][1]
+  else
+    let dict = {}
+    let [lines, message, exec_error] = s:NullError([dir, 'config', '--list', '-z'])
+    if exec_error
+      return {}
+    endif
+    for line in lines
+      let key = matchstr(line, "^[^\n]*")
+      if !has_key(dict, key)
+        let dict[key] = []
+      endif
+      if len(key) ==# len(line)
+        call add(dict[key], 1)
+      else
+        call add(dict[key], strpart(line, len(key) + 1))
+      endif
+    endfor
+    let s:config[dir_key] = [s:ConfigTimestamps(dir, dict), dict]
+    lockvar! dict
+  endif
+  return len(name) ? get(get(dict, name, []), 0, '') : dict
+endfunction
+
+function! s:Remote(dir) abort
+  let head = FugitiveHead(0, a:dir)
+  let remote = len(head) ? fugitive#Config('branch.' . head . '.remote') : ''
+  let i = 10
+  while remote ==# '.' && i > 0
+    let head = matchstr(fugitive#Config('branch.' . head . '.merge'), 'refs/heads/\zs.*')
+    let remote = len(head) ? fugitive#Config('branch.' . head . '.remote') : ''
+    let i -= 1
+  endwhile
+  return remote =~# '^\.\=$' ? 'origin' : remote
+endfunction
+
+function! fugitive#RemoteUrl(...) abort
+  let dir = a:0 > 1 ? a:2 : s:Dir()
+  let remote = !a:0 || a:1 =~# '^\.\=$' ? s:Remote(dir) : a:1
+  if !fugitive#GitVersion(2, 7)
+    return fugitive#Config('remote.' . remote . '.url')
+  endif
+  return s:ChompDefault('', [dir, 'remote', 'get-url', remote, '--'])
+endfunction
+
+" Section: Quickfix
+
+function! s:QuickfixGet(nr, ...) abort
+  if a:nr < 0
+    return call('getqflist', a:000)
+  else
+    return call('getloclist', [a:nr] + a:000)
+  endif
+endfunction
+
+function! s:QuickfixSet(nr, ...) abort
+  if a:nr < 0
+    return call('setqflist', a:000)
+  else
+    return call('setloclist', [a:nr] + a:000)
+  endif
+endfunction
+
+function! s:QuickfixCreate(nr, opts) abort
+  if has('patch-7.4.2200')
+    call s:QuickfixSet(a:nr, [], ' ', a:opts)
+  else
+    call s:QuickfixSet(a:nr, [], ' ')
+  endif
+endfunction
+
+function! s:QuickfixStream(nr, event, title, cmd, first, mods, callback, ...) abort
+  let mods = s:Mods(a:mods)
+  let opts = {'title': a:title, 'context': {'items': []}}
+  call s:QuickfixCreate(a:nr, opts)
+  let event = (a:nr < 0 ? 'c' : 'l') . 'fugitive-' . a:event
+  silent exe s:DoAutocmd('QuickFixCmdPre ' . event)
+  let winnr = winnr()
+  exe a:nr < 0 ? 'copen' : 'lopen'
+  if winnr != winnr()
+    wincmd p
+  endif
+
+  let buffer = []
+  let lines = split(s:SystemError(s:shellesc(a:cmd))[0], "\n")
+  for line in lines
+    call extend(buffer, call(a:callback, a:000 + [line]))
+    if len(buffer) >= 20
+      let contexts = map(copy(buffer), 'get(v:val, "context", {})')
+      lockvar contexts
+      call extend(opts.context.items, contexts)
+      unlet contexts
+      call s:QuickfixSet(a:nr, remove(buffer, 0, -1), 'a')
+      if mods !~# '\<silent\>'
+        redraw
+      endif
+    endif
+  endfor
+  call extend(buffer, call(a:callback, a:000 + [0]))
+  call extend(opts.context.items, map(copy(buffer), 'get(v:val, "context", {})'))
+  lockvar opts.context.items
+  call s:QuickfixSet(a:nr, buffer, 'a')
+
+  silent exe s:DoAutocmd('QuickFixCmdPost ' . event)
+  if a:first && len(s:QuickfixGet(a:nr))
+    call s:BlurStatus()
+    return mods . (a:nr < 0 ? 'cfirst' : 'lfirst')
+  else
+    return 'exe'
+  endif
+endfunction
+
+function! fugitive#Cwindow() abort
+  if &buftype == 'quickfix'
+    cwindow
+  else
+    botright cwindow
+    if &buftype == 'quickfix'
+      wincmd p
+    endif
+  endif
+endfunction
+
+" Section: Repository Object
+
+function! s:add_methods(namespace, method_names) abort
+  for name in a:method_names
+    let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name)
+  endfor
+endfunction
+
+let s:repo_prototype = {}
+let s:repos = {}
+
+function! fugitive#repo(...) abort
+  let dir = a:0 ? s:Dir(a:1) : (len(s:Dir()) ? s:Dir() : FugitiveExtractGitDir(expand('%:p')))
+  if dir !=# ''
+    if has_key(s:repos, dir)
+      let repo = get(s:repos, dir)
+    else
+      let repo = {'git_dir': dir}
+      let s:repos[dir] = repo
+    endif
+    return extend(repo, s:repo_prototype, 'keep')
+  endif
+  call s:throw('not a Git repository')
+endfunction
+
+function! s:repo_dir(...) dict abort
+  return join([self.git_dir]+a:000,'/')
+endfunction
+
+function! s:repo_tree(...) dict abort
+  let dir = s:Tree(self.git_dir)
+  if dir ==# ''
+    call s:throw('no work tree')
+  else
+    return join([dir]+a:000,'/')
+  endif
+endfunction
+
+function! s:repo_bare() dict abort
+  if self.dir() =~# '/\.git$'
+    return 0
+  else
+    return s:Tree(self.git_dir) ==# ''
+  endif
+endfunction
+
+function! s:repo_find(object) dict abort
+  return fugitive#Find(a:object, self.git_dir)
+endfunction
+
+function! s:repo_translate(rev) dict abort
+  return s:Slash(fugitive#Find(substitute(a:rev, '^/', ':(top)', ''), self.git_dir))
+endfunction
+
+function! s:repo_head(...) dict abort
+  return fugitive#Head(a:0 ? a:1 : 0, self.git_dir)
+endfunction
+
+call s:add_methods('repo',['dir','tree','bare','find','translate','head'])
+
+function! s:repo_prepare(...) dict abort
+  return call('fugitive#Prepare', [self.git_dir] + a:000)
+endfunction
+
+function! s:repo_git_command(...) dict abort
+  let git = g:fugitive_git_executable . ' --git-dir='.s:shellesc(self.git_dir)
+  return git.join(map(copy(a:000),'" ".s:shellesc(v:val)'),'')
+endfunction
+
+function! s:repo_git_chomp(...) dict abort
+  return s:sub(system(FugitivePrepare(a:000, self.git_dir)), '\n$', '')
+endfunction
+
+function! s:repo_git_chomp_in_tree(...) dict abort
+  return call(self.git_chomp, a:000, self)
+endfunction
+
+function! s:repo_rev_parse(rev) dict abort
+  return fugitive#RevParse(a:rev, self.git_dir)
+endfunction
+
+call s:add_methods('repo',['prepare','git_command','git_chomp','git_chomp_in_tree','rev_parse'])
+
+function! s:repo_superglob(base) dict abort
+  return map(fugitive#CompleteObject(a:base, self.git_dir), 'substitute(v:val, ''\\\(.\)'', ''\1'', "g")')
+endfunction
+
+call s:add_methods('repo',['superglob'])
+
+function! s:repo_config(name) dict abort
+  return fugitive#Config(a:name, self.git_dir)
+endfunction
+
+function! s:repo_user() dict abort
+  let username = self.config('user.name')
+  let useremail = self.config('user.email')
+  return username.' <'.useremail.'>'
+endfunction
+
+call s:add_methods('repo',['config', 'user'])
+
+" Section: File API
+
+function! s:DirCommitFile(path) abort
+  let vals = matchlist(s:Slash(a:path), '\c^fugitive:\%(//\)\=\(.\{-\}\)\%(//\|::\)\(\x\{40,\}\|[0-3]\)\(/.*\)\=$')
+  if empty(vals)
+    return ['', '', '']
+  endif
+  return vals[1:3]
+endfunction
+
+function! s:DirRev(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  return [dir, (commit =~# '^.$' ? ':' : '') . commit . substitute(file, '^/', ':', '')]
+endfunction
+
+let s:merge_heads = ['MERGE_HEAD', 'REBASE_HEAD', 'CHERRY_PICK_HEAD', 'REVERT_HEAD']
+function! s:MergeHead(...) abort
+  let dir = fugitive#Find('.git/', a:0 ? a:1 : s:Dir())
+  for head in s:merge_heads
+    if filereadable(dir . head)
+      return head
+    endif
+  endfor
+  return ''
+endfunction
+
+function! s:Owner(path, ...) abort
+  let dir = a:0 ? a:1 : s:Dir()
+  if empty(dir)
+    return ''
+  endif
+  let actualdir = fugitive#Find('.git/', dir)
+  let [pdir, commit, file] = s:DirCommitFile(a:path)
+  if s:cpath(dir, pdir)
+    if commit =~# '^\x\{40,\}$'
+      return commit
+    elseif commit ==# '2'
+      return 'HEAD^{}'
+    elseif commit ==# '0'
+      return ''
+    endif
+    let merge_head = s:MergeHead()
+    if empty(merge_head)
+      return ''
+    endif
+    if commit ==# '3'
+      return merge_head . '^{}'
+    elseif commit ==# '1'
+      return s:TreeChomp('merge-base', 'HEAD', merge_head, '--')
+    endif
+  endif
+  let path = fnamemodify(a:path, ':p')
+  if s:cpath(actualdir, strpart(path, 0, len(actualdir))) && a:path =~# 'HEAD$'
+    return strpart(path, len(actualdir))
+  endif
+  let refs = fugitive#Find('.git/refs', dir)
+  if s:cpath(refs . '/', path[0 : len(refs)]) && path !~# '[\/]$'
+    return strpart(path, len(refs) - 4)
+  endif
+  return ''
+endfunction
+
+function! fugitive#Real(url) abort
+  if empty(a:url)
+    return ''
+  endif
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  if len(dir)
+    let tree = s:Tree(dir)
+    return FugitiveVimPath((len(tree) ? tree : dir) . file)
+  endif
+  let pre = substitute(matchstr(a:url, '^\a\a\+\ze:'), '^.', '\u&', '')
+  if len(pre) && pre !=? 'fugitive' && exists('*' . pre . 'Real')
+    let url = {pre}Real(a:url)
+  else
+    let url = fnamemodify(a:url, ':p' . (a:url =~# '[\/]$' ? '' : ':s?[\/]$??'))
+  endif
+  return FugitiveVimPath(empty(url) ? a:url : url)
+endfunction
+
+function! fugitive#Path(url, ...) abort
+  if empty(a:url)
+    return ''
+  endif
+  let dir = a:0 > 1 ? a:2 : s:Dir()
+  let tree = s:Tree(dir)
+  if !a:0
+    return fugitive#Real(a:url)
+  elseif a:1 =~# '\.$'
+    let path = s:Slash(fugitive#Real(a:url))
+    let cwd = getcwd()
+    let lead = ''
+    while s:cpath(tree . '/', (cwd . '/')[0 : len(tree)])
+      if s:cpath(cwd . '/', path[0 : len(cwd)])
+        if strpart(path, len(cwd) + 1) =~# '^\.git\%(/\|$\)'
+          break
+        endif
+        return a:1[0:-2] . (empty(lead) ? './' : lead) . strpart(path, len(cwd) + 1)
+      endif
+      let cwd = fnamemodify(cwd, ':h')
+      let lead .= '../'
+    endwhile
+    return a:1[0:-2] . path
+  endif
+  let url = a:url
+  let temp_state = s:TempState(url)
+  if has_key(temp_state, 'origin_bufnr')
+    let url = bufname(temp_state.origin_bufnr)
+  endif
+  let url = s:Slash(fnamemodify(url, ':p'))
+  if url =~# '/$' && s:Slash(a:url) !~# '/$'
+    let url = url[0:-2]
+  endif
+  let [argdir, commit, file] = s:DirCommitFile(a:url)
+  if len(argdir) && s:cpath(argdir) !=# s:cpath(dir)
+    let file = ''
+  elseif len(dir) && s:cpath(url[0 : len(dir)]) ==# s:cpath(dir . '/')
+    let file = '/.git'.url[strlen(dir) : -1]
+  elseif len(tree) && s:cpath(url[0 : len(tree)]) ==# s:cpath(tree . '/')
+    let file = url[len(tree) : -1]
+  elseif s:cpath(url) ==# s:cpath(tree)
+    let file = '/'
+  endif
+  if empty(file) && a:1 =~# '^$\|^[.:]/$'
+    return FugitiveGitPath(fugitive#Real(a:url))
+  endif
+  return substitute(file, '^/', a:1, '')
+endfunction
+
+function! s:Relative(...) abort
+  return fugitive#Path(@%, a:0 ? a:1 : ':(top)', a:0 > 1 ? a:2 : s:Dir())
+endfunction
+
+function! fugitive#Find(object, ...) abort
+  if type(a:object) == type(0)
+    let name = bufname(a:object)
+    return FugitiveVimPath(name =~# '^$\|^/\|^\a\+:' ? name : getcwd() . '/' . name)
+  elseif a:object =~# '^[~$]'
+    let prefix = matchstr(a:object, '^[~$]\i*')
+    let owner = expand(prefix)
+    return FugitiveVimPath((len(owner) ? owner : prefix) . strpart(a:object, len(prefix)))
+  endif
+  let rev = s:Slash(a:object)
+  if rev =~# '^$\|^/\|^\%(\a\a\+:\).*\%(//\|::\)' . (has('win32') ? '\|^\a:/' : '')
+    return FugitiveVimPath(a:object)
+  elseif rev =~# '^\.\.\=\%(/\|$\)'
+    return FugitiveVimPath(simplify(getcwd() . '/' . a:object))
+  endif
+  let dir = a:0 ? a:1 : s:Dir()
+  if empty(dir)
+    let file = matchstr(a:object, '^\%(:\d:\|[^:]*:\)\zs.*', '', '')
+    let dir = FugitiveExtractGitDir(file)
+    if empty(dir)
+      return fnamemodify(FugitiveVimPath(len(file) ? file : a:object), ':p')
+    endif
+  endif
+  let tree = s:Tree(dir)
+  let base = len(tree) ? tree : 'fugitive://' . dir . '//0'
+  if rev ==# '.git'
+    let f = len(tree) ? tree . '/.git' : dir
+  elseif rev =~# '^\.git/'
+    let f = substitute(rev, '^\.git', '', '')
+    let cdir = fugitive#CommonDir(dir)
+    if f =~# '^/\.\./\.\.\%(/\|$\)'
+      let f = simplify(len(tree) ? tree . f[3:-1] : dir . f)
+    elseif f =~# '^/\.\.\%(/\|$\)'
+      let f = base . f[3:-1]
+    elseif cdir !=# dir && (
+          \ f =~# '^/\%(config\|hooks\|info\|logs/refs\|objects\|refs\|worktrees\)\%(/\|$\)' ||
+          \ f !~# '^/\%(index$\|index\.lock$\|\w*MSG$\|\w*HEAD$\|logs/\w*HEAD$\|logs$\|rebase-\w\+\)\%(/\|$\)' &&
+          \ getftime(FugitiveVimPath(dir . f)) < 0 && getftime(FugitiveVimPath(cdir . f)) >= 0)
+      let f = simplify(cdir . f)
+    else
+      let f = simplify(dir . f)
+    endif
+  elseif rev ==# ':/'
+    let f = base
+  elseif rev =~# '^\.\%(/\|$\)'
+    let f = base . rev[1:-1]
+  elseif rev =~# '^::\%(/\|\a\+\:\)'
+    let f = rev[2:-1]
+  elseif rev =~# '^::\.\.\=\%(/\|$\)'
+    let f = simplify(getcwd() . '/' . rev[2:-1])
+  elseif rev =~# '^::'
+    let f = base . '/' . rev[2:-1]
+  elseif rev =~# '^:\%([0-3]:\)\=\.\.\=\%(/\|$\)\|^:[0-3]:\%(/\|\a\+:\)'
+    let f = rev =~# '^:\%([0-3]:\)\=\.' ? simplify(getcwd() . '/' . matchstr(rev, '\..*')) : rev[3:-1]
+    if s:cpath(base . '/', (f . '/')[0 : len(base)])
+      let f = 'fugitive://' . dir . '//' . +matchstr(rev, '^:\zs\d\ze:') . '/' . strpart(f, len(base) + 1)
+    else
+      let altdir = FugitiveExtractGitDir(f)
+      if len(altdir) && !s:cpath(dir, altdir)
+        return fugitive#Find(a:object, altdir)
+      endif
+    endif
+  elseif rev =~# '^:[0-3]:'
+    let f = 'fugitive://' . dir . '//' . rev[1] . '/' . rev[3:-1]
+  elseif rev ==# ':'
+    if $GIT_INDEX_FILE =~# '/[^/]*index[^/]*\.lock$' && s:cpath(fnamemodify($GIT_INDEX_FILE,':p')[0:strlen(dir)]) ==# s:cpath(dir . '/') && filereadable($GIT_INDEX_FILE)
+      let f = fnamemodify($GIT_INDEX_FILE, ':p')
+    else
+      let f = fugitive#Find('.git/index', dir)
+    endif
+  elseif rev =~# '^:(\%(top\|top,literal\|literal,top\|literal\))'
+    let f = matchstr(rev, ')\zs.*')
+    if f=~# '^\.\.\=\%(/\|$\)'
+      let f = simplify(getcwd() . '/' . f)
+    elseif f !~# '^/\|^\%(\a\a\+:\).*\%(//\|::\)' . (has('win32') ? '\|^\a:/' : '')
+      let f = base . '/' . f
+    endif
+  elseif rev =~# '^:/\@!'
+    let f = 'fugitive://' . dir . '//0/' . rev[1:-1]
+  else
+    if !exists('f')
+      let commit = substitute(matchstr(rev, '^\%([^:.-]\|\.\.[^/:]\)[^:]*\|^:.*'), '^@\%($\|[~^]\|@{\)\@=', 'HEAD', '')
+      let file = substitute(matchstr(rev, '^\%([^:.-]\|\.\.[^/:]\)[^:]*\zs:.*'), '^:', '/', '')
+      if file =~# '^/\.\.\=\%(/\|$\)\|^//\|^/\a\+:'
+        let file = file =~# '^/\.' ? simplify(getcwd() . file) : file[1:-1]
+        if s:cpath(base . '/', (file . '/')[0 : len(base)])
+          let file = '/' . strpart(file, len(base) + 1)
+        else
+          let altdir = FugitiveExtractGitDir(file)
+          if len(altdir) && !s:cpath(dir, altdir)
+            return fugitive#Find(a:object, altdir)
+          endif
+          return file
+        endif
+      endif
+      let commits = split(commit, '\.\.\.-\@!', 1)
+      if len(commits) == 2
+        call map(commits, 'empty(v:val) || v:val ==# "@" ? "HEAD" : v:val')
+        let commit = matchstr(s:ChompDefault('', [dir, 'merge-base'] + commits + ['--']), '\<[0-9a-f]\{40,\}\>')
+      endif
+      if commit !~# '^[0-9a-f]\{40,\}$'
+        let commit = matchstr(s:ChompDefault('', [dir, 'rev-parse', '--verify', commit . (len(file) ? '^{}' : ''), '--']), '\<[0-9a-f]\{40,\}\>')
+        if empty(commit) && len(file)
+          let commit = repeat('0', 40)
+        endif
+      endif
+      if len(commit)
+        let f = 'fugitive://' . dir . '//' . commit . file
+      else
+        let f = base . '/' . substitute(rev, '^:/:\=\|^[^:]\+:', '', '')
+      endif
+    endif
+  endif
+  return FugitiveVimPath(f)
+endfunction
+
+function! s:Generate(rev, ...) abort
+  return fugitive#Find(a:rev, a:0 ? a:1 : s:Dir())
+endfunction
+
+function! s:DotRelative(path, ...) abort
+  let cwd = a:0 ? a:1 : getcwd()
+  let path = substitute(a:path, '^[~$]\i*', '\=expand(submatch(0))', '')
+  if len(cwd) && s:cpath(cwd . '/', (path . '/')[0 : len(cwd)])
+    return '.' . strpart(path, len(cwd))
+  endif
+  return a:path
+endfunction
+
+function! fugitive#Object(...) abort
+  let dir = a:0 > 1 ? a:2 : s:Dir()
+  let [fdir, rev] = s:DirRev(a:0 ? a:1 : @%)
+  if s:cpath(dir) !=# s:cpath(fdir)
+    let rev = ''
+  endif
+  let tree = s:Tree(dir)
+  let full = a:0 ? a:1 : @%
+  let full = fnamemodify(full, ':p' . (s:Slash(full) =~# '/$' ? '' : ':s?/$??'))
+  if empty(rev) && empty(tree)
+    return FugitiveGitPath(full)
+  elseif empty(rev)
+    let rev = fugitive#Path(full, './', dir)
+    if rev =~# '^\./.git\%(/\|$\)'
+      return FugitiveGitPath(full)
+    endif
+  endif
+  if rev !~# '^\.\%(/\|$\)' || s:cpath(getcwd(), tree)
+    return rev
+  else
+    return FugitiveGitPath(tree . rev[1:-1])
+  endif
+endfunction
+
+let s:var = '\%(%\|#<\=\d\+\|##\=\)'
+let s:flag = '\%(:[p8~.htre]\|:g\=s\(.\).\{-\}\1.\{-\}\1\)'
+let s:expand = '\%(\(' . s:var . '\)\(' . s:flag . '*\)\(:S\)\=\)'
+
+function! s:BufName(var) abort
+  if a:var ==# '%'
+    return bufname(get(s:TempState(), 'origin_bufnr', ''))
+  elseif a:var =~# '^#\d*$'
+    let nr = get(s:TempState(bufname(+a:var[1:-1])), 'origin_bufnr', '')
+    return bufname(nr ? nr : +a:var[1:-1])
+  else
+    return expand(a:var)
+  endif
+endfunction
+
+function! s:ExpandVarLegacy(str) abort
+  if get(g:, 'fugitive_legacy_quoting', 1)
+    return substitute(a:str, '\\\ze[%#!]', '', 'g')
+  else
+    return a:str
+  endif
+endfunction
+
+function! s:ExpandVar(other, var, flags, esc, ...) abort
+  let cwd = a:0 ? a:1 : getcwd()
+  if a:other =~# '^\'
+    return a:other[1:-1]
+  elseif a:other =~# '^'''
+    return s:ExpandVarLegacy(substitute(a:other[1:-2], "''", "'", "g"))
+  elseif a:other =~# '^"'
+    return s:ExpandVarLegacy(substitute(a:other[1:-2], '""', '"', "g"))
+  elseif a:other =~# '^!'
+    let buffer = s:BufName(len(a:other) > 1 ? '#'. a:other[1:-1] : '%')
+    let owner = s:Owner(buffer)
+    return len(owner) ? owner : '@'
+  endif
+  let flags = a:flags
+  let file = s:DotRelative(fugitive#Real(s:BufName(a:var)), cwd)
+  while len(flags)
+    let flag = matchstr(flags, s:flag)
+    let flags = strpart(flags, len(flag))
+    if flag ==# ':.'
+      let file = s:DotRelative(file, cwd)
+    else
+      let file = fnamemodify(file, flag)
+    endif
+  endwhile
+  let file = s:Slash(file)
+  return (len(a:esc) ? shellescape(file) : file)
+endfunction
+
+function! s:Expand(rev, ...) abort
+  if a:rev =~# '^:[0-3]$'
+    let file = len(expand('%')) ? a:rev . ':%' : '%'
+  elseif a:rev ==# '>'
+    let file = '%'
+  elseif a:rev =~# '^>[~^]'
+    let file = len(expand('%')) ? '!' . a:rev[1:-1] . ':%' : '%'
+  elseif a:rev =~# '^>[> ]\@!'
+    let file = len(expand('%')) ? a:rev[1:-1] . ':%' : '%'
+  else
+    let file = a:rev
+  endif
+  return substitute(file,
+        \ '\(\\[' . s:fnameescape . ']\|^\\[>+-]\|!\d*\)\|' . s:expand,
+        \ '\=s:ExpandVar(submatch(1),submatch(2),submatch(3),"", a:0 ? a:1 : getcwd())', 'g')
+endfunction
+
+function! fugitive#Expand(object) abort
+  return substitute(a:object,
+        \ '\(\\[' . s:fnameescape . ']\|^\\[>+-]\|!\d*\)\|' . s:expand,
+        \ '\=s:ExpandVar(submatch(1),submatch(2),submatch(3),submatch(5))', 'g')
+endfunction
+
+function! s:ExpandSplit(string, ...) abort
+  let list = []
+  let string = a:string
+  let handle_bar = a:0 && a:1
+  let dquote = handle_bar ? '"\%([^"]\|""\|\\"\)*"\|' : ''
+  let cwd = a:0 > 1 ? a:2 : getcwd()
+  while string =~# '\S'
+    if handle_bar && string =~# '^\s*|'
+      return [list, substitute(string, '^\s*', '', '')]
+    endif
+    let arg = matchstr(string, '^\s*\%(' . dquote . '''[^'']*''\|\\.\|[^[:space:] ' . (handle_bar ? '|' : '') . ']\)\+')
+    let string = strpart(string, len(arg))
+    let arg = substitute(arg, '^\s\+', '', '')
+    if !exists('seen_separator')
+      let arg = substitute(arg, '^\%([^:.][^:]*:\|^:\|^:[0-3]:\)\=\zs\.\.\=\%(/.*\)\=$',
+            \ '\=s:DotRelative(s:Slash(simplify(getcwd() . "/" . submatch(0))), cwd)', '')
+    endif
+    let arg = substitute(arg,
+          \ '\(' . dquote . '''\%(''''\|[^'']\)*''\|\\[' . s:fnameescape . ']\|^\\[>+-]\|!\d*\)\|' . s:expand,
+          \ '\=s:ExpandVar(submatch(1),submatch(2),submatch(3),submatch(5), cwd)', 'g')
+    call add(list, arg)
+    if arg ==# '--'
+      let seen_separator = 1
+    endif
+  endwhile
+  return handle_bar ? [list, ''] : list
+endfunction
+
+function! s:SplitExpand(string, ...) abort
+  return s:ExpandSplit(a:string, 0, a:0 ? a:1 : getcwd())
+endfunction
+
+function! s:SplitExpandChain(string, ...) abort
+  return s:ExpandSplit(a:string, 1, a:0 ? a:1 : getcwd())
+endfunction
+
+let s:trees = {}
+let s:indexes = {}
+function! s:TreeInfo(dir, commit) abort
+  if a:commit =~# '^:\=[0-3]$'
+    let index = get(s:indexes, a:dir, [])
+    let newftime = getftime(fugitive#Find('.git/index', a:dir))
+    if get(index, 0, -1) < newftime
+      let [lines, exec_error] = s:LinesError([a:dir, 'ls-files', '--stage', '--'])
+      let s:indexes[a:dir] = [newftime, {'0': {}, '1': {}, '2': {}, '3': {}}]
+      if exec_error
+        return [{}, -1]
+      endif
+      for line in lines
+        let [info, filename] = split(line, "\t")
+        let [mode, sha, stage] = split(info, '\s\+')
+        let s:indexes[a:dir][1][stage][filename] = [newftime, mode, 'blob', sha, -2]
+        while filename =~# '/'
+          let filename = substitute(filename, '/[^/]*$', '', '')
+          let s:indexes[a:dir][1][stage][filename] = [newftime, '040000', 'tree', '', 0]
+        endwhile
+      endfor
+    endif
+    return [get(s:indexes[a:dir][1], a:commit[-1:-1], {}), newftime]
+  elseif a:commit =~# '^\x\{40,\}$'
+    if !has_key(s:trees, a:dir)
+      let s:trees[a:dir] = {}
+    endif
+    if !has_key(s:trees[a:dir], a:commit)
+      let [ftime, exec_error] = s:ChompError([a:dir, 'log', '-1', '--pretty=format:%ct', a:commit, '--'])
+      if exec_error
+        let s:trees[a:dir][a:commit] = [{}, -1]
+        return s:trees[a:dir][a:commit]
+      endif
+      let s:trees[a:dir][a:commit] = [{}, +ftime]
+      let [lines, exec_error] = s:LinesError([a:dir, 'ls-tree', '-rtl', '--full-name', a:commit, '--'])
+      if exec_error
+        return s:trees[a:dir][a:commit]
+      endif
+      for line in lines
+        let [info, filename] = split(line, "\t")
+        let [mode, type, sha, size] = split(info, '\s\+')
+        let s:trees[a:dir][a:commit][0][filename] = [+ftime, mode, type, sha, +size, filename]
+      endfor
+    endif
+    return s:trees[a:dir][a:commit]
+  endif
+  return [{}, -1]
+endfunction
+
+function! s:PathInfo(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  if empty(dir) || !get(g:, 'fugitive_file_api', 1)
+    return [-1, '000000', '', '', -1]
+  endif
+  let path = substitute(file[1:-1], '/*$', '', '')
+  let [tree, ftime] = s:TreeInfo(dir, commit)
+  let entry = empty(path) ? [ftime, '040000', 'tree', '', -1] : get(tree, path, [])
+  if empty(entry) || file =~# '/$' && entry[2] !=# 'tree'
+    return [-1, '000000', '', '', -1]
+  else
+    return entry
+  endif
+endfunction
+
+function! fugitive#simplify(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  if empty(dir)
+    return ''
+  endif
+  if file =~# '/\.\.\%(/\|$\)'
+    let tree = s:Tree(dir)
+    if len(tree)
+      let path = simplify(tree . file)
+      if strpart(path . '/', 0, len(tree) + 1) !=# tree . '/'
+        return FugitiveVimPath(path)
+      endif
+    endif
+  endif
+  return FugitiveVimPath('fugitive://' . simplify(dir) . '//' . commit . simplify(file))
+endfunction
+
+function! fugitive#resolve(url) abort
+  let url = fugitive#simplify(a:url)
+  if url =~? '^fugitive:'
+    return url
+  else
+    return resolve(url)
+  endif
+endfunction
+
+function! fugitive#getftime(url) abort
+  return s:PathInfo(a:url)[0]
+endfunction
+
+function! fugitive#getfsize(url) abort
+  let entry = s:PathInfo(a:url)
+  if entry[4] == -2 && entry[2] ==# 'blob' && len(entry[3])
+    let dir = s:DirCommitFile(a:url)[0]
+    let entry[4] = +s:ChompDefault(-1, [dir, 'cat-file', '-s', entry[3]])
+  endif
+  return entry[4]
+endfunction
+
+function! fugitive#getftype(url) abort
+  return get({'tree': 'dir', 'blob': 'file'}, s:PathInfo(a:url)[2], '')
+endfunction
+
+function! fugitive#filereadable(url) abort
+  return s:PathInfo(a:url)[2] ==# 'blob'
+endfunction
+
+function! fugitive#filewritable(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  if commit !~# '^\d$' || !filewritable(fugitive#Find('.git/index', dir))
+    return 0
+  endif
+  return s:PathInfo(a:url)[2] ==# 'blob' ? 1 : 2
+endfunction
+
+function! fugitive#isdirectory(url) abort
+  return s:PathInfo(a:url)[2] ==# 'tree'
+endfunction
+
+function! fugitive#getfperm(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  let perm = getfperm(dir)
+  let fperm = s:PathInfo(a:url)[1]
+  if fperm ==# '040000'
+    let fperm = '000755'
+  endif
+  if fperm !~# '[15]'
+    let perm = tr(perm, 'x', '-')
+  endif
+  if fperm !~# '[45]$'
+    let perm = tr(perm, 'rw', '--')
+  endif
+  if commit !~# '^\d$'
+    let perm = tr(perm, 'w', '-')
+  endif
+  return perm ==# '---------' ? '' : perm
+endfunction
+
+function s:UpdateIndex(dir, info) abort
+  let info = join(a:info[0:-2]) . "\t" . a:info[-1] . "\n"
+  let [error, exec_error] = s:SystemError([a:dir, 'update-index', '--index-info'], info)
+  return !exec_error ? '' : len(error) ? error : 'fugitive: unknown update-index error'
+endfunction
+
+function! fugitive#setfperm(url, perm) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  let entry = s:PathInfo(a:url)
+  let perm = fugitive#getfperm(a:url)
+  if commit !~# '^\d$' || entry[2] !=# 'blob' ||
+      \ substitute(perm, 'x', '-', 'g') !=# substitute(a:perm, 'x', '-', 'g')
+    return -2
+  endif
+  let error = s:UpdateIndex(dir, [a:perm =~# 'x' ? '000755' : '000644', entry[3], commit, file[1:-1]])
+  return len(error) ? -1 : 0
+endfunction
+
+function! s:TempCmd(out, cmd) abort
+  try
+    let cmd = (type(a:cmd) == type([]) ? fugitive#Prepare(a:cmd) : a:cmd)
+    let redir = ' > ' . a:out
+    if (s:winshell() || &shellcmdflag ==# '-Command') && !has('nvim')
+      let cmd_escape_char = &shellxquote == '(' ?  '^' : '^^^'
+      return s:SystemError('cmd /c "' . s:gsub(cmd, '[<>%]', cmd_escape_char . '&') . redir . '"')
+    elseif &shell =~# 'fish'
+      return s:SystemError(' begin;' . cmd . redir . ';end ')
+    else
+      return s:SystemError(' (' . cmd . redir . ') ')
+    endif
+  endtry
+endfunction
+
+if !exists('s:blobdirs')
+  let s:blobdirs = {}
+endif
+function! s:BlobTemp(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  if empty(file)
+    return ''
+  endif
+  if !has_key(s:blobdirs, dir)
+    let s:blobdirs[dir] = tempname()
+  endif
+  let tempfile = s:blobdirs[dir] . '/' . commit . file
+  let tempparent = fnamemodify(tempfile, ':h')
+  if !isdirectory(tempparent)
+    call mkdir(tempparent, 'p')
+  endif
+  if commit =~# '^\d$' || !filereadable(tempfile)
+    let rev = s:DirRev(a:url)[1]
+    let exec_error = s:TempCmd(tempfile, [dir, 'cat-file', 'blob', rev])[1]
+    if exec_error
+      call delete(tempfile)
+      return ''
+    endif
+  endif
+  return s:Resolve(tempfile)
+endfunction
+
+function! fugitive#readfile(url, ...) abort
+  let entry = s:PathInfo(a:url)
+  if entry[2] !=# 'blob'
+    return []
+  endif
+  let temp = s:BlobTemp(a:url)
+  if empty(temp)
+    return []
+  endif
+  return call('readfile', [temp] + a:000)
+endfunction
+
+function! fugitive#writefile(lines, url, ...) abort
+  let url = type(a:url) ==# type('') ? a:url : ''
+  let [dir, commit, file] = s:DirCommitFile(url)
+  let entry = s:PathInfo(url)
+  if commit =~# '^\d$' && entry[2] !=# 'tree'
+    let temp = tempname()
+    if a:0 && a:1 =~# 'a' && entry[2] ==# 'blob'
+      call writefile(fugitive#readfile(url, 'b'), temp, 'b')
+    endif
+    call call('writefile', [a:lines, temp] + a:000)
+    let [hash, exec_error] = s:ChompError([dir, 'hash-object', '-w', temp])
+    let mode = len(entry[1]) ? entry[1] : '100644'
+    if !exec_error && hash =~# '^\x\{40,\}$'
+      let error = s:UpdateIndex(dir, [mode, hash, commit, file[1:-1]])
+      if empty(error)
+        return 0
+      endif
+    endif
+  endif
+  return call('writefile', [a:lines, a:url] + a:000)
+endfunction
+
+let s:globsubs = {
+      \ '/**/': '/\%([^./][^/]*/\)*',
+      \ '/**': '/\%([^./][^/]\+/\)*[^./][^/]*',
+      \ '**/': '[^/]*\%(/[^./][^/]*\)*',
+      \ '**': '.*',
+      \ '/*': '/[^/.][^/]*',
+      \ '*': '[^/]*',
+      \ '?': '[^/]'}
+function! fugitive#glob(url, ...) abort
+  let [dirglob, commit, glob] = s:DirCommitFile(a:url)
+  let append = matchstr(glob, '/*$')
+  let glob = substitute(glob, '/*$', '', '')
+  let pattern = '^' . substitute(glob, '/\=\*\*/\=\|/\=\*\|[.?\$]\|^^', '\=get(s:globsubs, submatch(0), "\\" . submatch(0))', 'g')[1:-1] . '$'
+  let results = []
+  for dir in dirglob =~# '[*?]' ? split(glob(dirglob), "\n") : [dirglob]
+    if empty(dir) || !get(g:, 'fugitive_file_api', 1) || !filereadable(fugitive#Find('.git/HEAD', dir))
+      continue
+    endif
+    let files = items(s:TreeInfo(dir, commit)[0])
+    if len(append)
+      call filter(files, 'v:val[1][2] ==# "tree"')
+    endif
+    call map(files, 'v:val[0]')
+    call filter(files, 'v:val =~# pattern')
+    let prepend = 'fugitive://' . dir . '//' . substitute(commit, '^:', '', '') . '/'
+    call sort(files)
+    call map(files, 'FugitiveVimPath(prepend . v:val . append)')
+    call extend(results, files)
+  endfor
+  if a:0 > 1 && a:2
+    return results
+  else
+    return join(results, "\n")
+  endif
+endfunction
+
+function! fugitive#delete(url, ...) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  if a:0 && len(a:1) || commit !~# '^\d$'
+    return -1
+  endif
+  let entry = s:PathInfo(a:url)
+  if entry[2] !=# 'blob'
+    return -1
+  endif
+  let error = s:UpdateIndex(dir, ['000000', '0000000000000000000000000000000000000000', commit, file[1:-1]])
+  return len(error) ? -1 : 0
+endfunction
+
+" Section: Buffer Object
+
+let s:buffer_prototype = {}
+
+function! fugitive#buffer(...) abort
+  let buffer = {'#': bufnr(a:0 ? a:1 : '%')}
+  call extend(buffer, s:buffer_prototype, 'keep')
+  return buffer
+endfunction
+
+function! s:buffer_repo() dict abort
+  return fugitive#repo(self['#'])
+endfunction
+
+function! s:buffer_type(...) dict abort
+  return 'see b:fugitive_type'
+endfunction
+
+call s:add_methods('buffer', ['repo', 'type'])
+
+" Section: Completion
+
+function! s:FilterEscape(items, ...) abort
+  let items = copy(a:items)
+  call map(items, 's:fnameescape(v:val)')
+  if a:0 && type(a:1) == type('')
+    let cmp = s:FileIgnoreCase(1) ? '==?' : '==#'
+    call filter(items, 'strpart(v:val, 0, strlen(a:1)) ' . cmp . ' a:1')
+  endif
+  return items
+endfunction
+
+function! s:GlobComplete(lead, pattern, ...) abort
+  if a:lead ==# '/'
+    return []
+  elseif v:version >= 704
+    let results = glob(a:lead . a:pattern, a:0 ? a:1 : 0, 1)
+  else
+    let results = split(glob(a:lead . a:pattern), "\n")
+  endif
+  call map(results, 'v:val !~# "/$" && isdirectory(v:val) ? v:val."/" : v:val')
+  call map(results, 'v:val[ strlen(a:lead) : -1 ]')
+  return results
+endfunction
+
+function! fugitive#CompletePath(base, ...) abort
+  let dir = a:0 == 1 ? a:1 : a:0 >= 3 ? a:3 : s:Dir()
+  let stripped = matchstr(a:base, '^\%(:/:\=\|:(top)\|:(top,literal)\|:(literal,top)\)')
+  let base = strpart(a:base, len(stripped))
+  if len(stripped) || a:0 < 4
+    let root = s:Tree(dir)
+  else
+    let root = a:4
+  endif
+  if root !=# '/' && len(root)
+    let root .= '/'
+  endif
+  if empty(stripped)
+    let stripped = matchstr(a:base, '^\%(:(literal)\|:\)')
+    let base = strpart(a:base, len(stripped))
+  endif
+  if base =~# '^\.git/'
+    let pattern = s:gsub(base[5:-1], '/', '*&').'*'
+    let matches = s:GlobComplete(dir . '/', pattern)
+    let cdir = fugitive#CommonDir(dir)
+    if len(cdir) && s:cpath(dir) !=# s:cpath(cdir)
+      call extend(matches, s:GlobComplete(cdir . '/', pattern))
+    endif
+    call s:Uniq(matches)
+    call map(matches, "'.git/' . v:val")
+  elseif base =~# '^\~/'
+    let matches = map(s:GlobComplete(expand('~/'), base[2:-1] . '*'), '"~/" . v:val')
+  elseif a:base =~# '^/\|^\a\+:\|^\.\.\=/'
+    let matches = s:GlobComplete('', base . '*')
+  elseif len(root)
+    let matches = s:GlobComplete(root, s:gsub(base, '/', '*&').'*')
+  else
+    let matches = []
+  endif
+  call map(matches, 's:fnameescape(s:Slash(stripped . v:val))')
+  return matches
+endfunction
+
+function! fugitive#PathComplete(...) abort
+  return call('fugitive#CompletePath', a:000)
+endfunction
+
+function! s:CompleteHeads(dir) abort
+  if empty(a:dir)
+    return []
+  endif
+  let dir = fugitive#Find('.git/', a:dir)
+  return sort(filter(['HEAD', 'FETCH_HEAD', 'ORIG_HEAD'] + s:merge_heads, 'filereadable(dir . v:val)')) +
+        \ sort(s:LinesError([a:dir, 'rev-parse', '--symbolic', '--branches', '--tags', '--remotes'])[0])
+endfunction
+
+function! fugitive#CompleteObject(base, ...) abort
+  let dir = a:0 == 1 ? a:1 : a:0 >= 3 ? a:3 : s:Dir()
+  let tree = s:Tree(dir)
+  let cwd = getcwd()
+  let subdir = ''
+  if len(tree) && s:cpath(tree . '/', cwd[0 : len(tree)])
+    let subdir = strpart(cwd, len(tree) + 1) . '/'
+  endif
+
+  if a:base =~# '^\.\=/\|^:(' || a:base !~# ':'
+    let results = []
+    if a:base =~# '^refs/'
+      let results += map(s:GlobComplete(fugitive#CommonDir(dir) . '/', a:base . '*'), 's:Slash(v:val)')
+      call map(results, 's:fnameescape(v:val)')
+    elseif a:base !~# '^\.\=/\|^:('
+      let heads = s:CompleteHeads(dir)
+      if filereadable(fugitive#Find('.git/refs/stash', dir))
+        let heads += ["stash"]
+        let heads += sort(s:LinesError(["stash","list","--pretty=format:%gd"], dir)[0])
+      endif
+      let results += s:FilterEscape(heads, a:base)
+    endif
+    let results += a:0 == 1 || a:0 >= 3 ? fugitive#CompletePath(a:base, 0, '', dir, a:0 >= 4 ? a:4 : tree) : fugitive#CompletePath(a:base)
+    return results
+
+  elseif a:base =~# '^:'
+    let entries = s:LinesError(['ls-files','--stage'], dir)[0]
+    if a:base =~# ':\./'
+      call map(entries, 'substitute(v:val, "\\M\t\\zs" . subdir, "./", "")')
+    endif
+    call map(entries,'s:sub(v:val,".*(\\d)\\t(.*)",":\\1:\\2")')
+    if a:base !~# '^:[0-3]\%(:\|$\)'
+      call filter(entries,'v:val[1] == "0"')
+      call map(entries,'v:val[2:-1]')
+    endif
+
+  else
+    let parent = matchstr(a:base, '.*[:/]')
+    let entries = s:LinesError(['ls-tree', substitute(parent,  ':\zs\./', '\=subdir', '')], dir)[0]
+    call map(entries,'s:sub(v:val,"^04.*\\zs$","/")')
+    call map(entries,'parent.s:sub(v:val,".*\t","")')
+  endif
+  return s:FilterEscape(entries, a:base)
+endfunction
+
+function! s:CompleteSub(subcommand, A, L, P, ...) abort
+  let pre = strpart(a:L, 0, a:P)
+  if pre =~# ' -- '
+    return fugitive#CompletePath(a:A)
+  elseif a:A =~# '^-' || a:A is# 0
+    return s:FilterEscape(split(s:ChompDefault('', a:subcommand, '--git-completion-helper'), ' '), a:A)
+  elseif !a:0
+    return fugitive#CompleteObject(a:A, s:Dir())
+  elseif type(a:1) == type(function('tr'))
+    return call(a:1, [a:A, a:L, a:P] + (a:0 > 1 ? a:2 : []))
+  else
+    return s:FilterEscape(a:1, a:A)
+  endif
+endfunction
+
+function! s:CompleteRevision(A, L, P, ...) abort
+  return s:FilterEscape(s:CompleteHeads(a:0 ? a:1 : s:Dir()), a:A)
+endfunction
+
+function! s:CompleteRemote(A, L, P, ...) abort
+  let dir = a:0 ? a:1 : s:Dir()
+  let remote = matchstr(a:L, '\u\w*[! ] *.\{-\}\s\@<=\zs[^-[:space:]]\S*\ze ')
+  if !empty(remote)
+    let matches = s:LinesError([dir, 'ls-remote', remote])[0]
+    call filter(matches, 'v:val =~# "\t" && v:val !~# "{"')
+    call map(matches, 's:sub(v:val, "^.*\t%(refs/%(heads/|tags/)=)=", "")')
+  else
+    let matches = s:LinesError([dir, 'remote'])[0]
+  endif
+  return s:FilterEscape(matches, a:A)
+endfunction
+
+" Section: Buffer auto-commands
+
+function! s:ReplaceCmd(cmd) abort
+  let temp = tempname()
+  let [err, exec_error] = s:TempCmd(temp, a:cmd)
+  if exec_error
+    call s:throw((len(err) ? err : 'unknown error running ' . a:cmd))
+  endif
+  setlocal noswapfile
+  silent exe 'lockmarks keepalt 0read ++edit' s:fnameescape(temp)
+  if &foldenable && foldlevel('$') > 0
+    set nofoldenable
+    silent keepjumps $delete _
+    set foldenable
+  else
+    silent keepjumps $delete _
+  endif
+  call delete(temp)
+  if s:cpath(fnamemodify(bufname('$'), ':p'), temp)
+    silent! execute bufnr('$') . 'bwipeout'
+  endif
+endfunction
+
+function! s:QueryLog(refspec) abort
+  let lines = s:LinesError(['log', '-n', '256', '--pretty=format:%h%x09%s', a:refspec, '--'])[0]
+  call map(lines, 'split(v:val, "\t")')
+  call map(lines, '{"type": "Log", "commit": v:val[0], "subject": v:val[-1]}')
+  return lines
+endfunction
+
+function! s:FormatLog(dict) abort
+  return a:dict.commit . ' ' . a:dict.subject
+endfunction
+
+function! s:FormatRebase(dict) abort
+  return a:dict.status . ' ' . a:dict.commit . ' ' . a:dict.subject
+endfunction
+
+function! s:FormatFile(dict) abort
+  return a:dict.status . ' ' . a:dict.filename
+endfunction
+
+function! s:Format(val) abort
+  if type(a:val) == type({})
+    return s:Format{a:val.type}(a:val)
+  elseif type(a:val) == type([])
+    return map(copy(a:val), 's:Format(v:val)')
+  else
+    return '' . a:val
+  endif
+endfunction
+
+function! s:AddHeader(key, value) abort
+  if empty(a:value)
+    return
+  endif
+  let before = 1
+  while !empty(getline(before))
+    let before += 1
+  endwhile
+  call append(before - 1, [a:key . ':' . (len(a:value) ? ' ' . a:value : '')])
+  if before == 1 && line('$') == 2
+    silent keepjumps 2delete _
+  endif
+endfunction
+
+function! s:AddSection(label, lines, ...) abort
+  let note = a:0 ? a:1 : ''
+  if empty(a:lines) && empty(note)
+    return
+  endif
+  call append(line('$'), ['', a:label . (len(note) ? ': ' . note : ' (' . len(a:lines) . ')')] + s:Format(a:lines))
+endfunction
+
+let s:rebase_abbrevs = {
+      \ 'p': 'pick',
+      \ 'r': 'reword',
+      \ 'e': 'edit',
+      \ 's': 'squash',
+      \ 'f': 'fixup',
+      \ 'x': 'exec',
+      \ 'd': 'drop',
+      \ 'l': 'label',
+      \ 't': 'reset',
+      \ 'm': 'merge',
+      \ 'b': 'break',
+      \ }
+
+function! fugitive#BufReadStatus() abort
+  let amatch = s:Slash(expand('%:p'))
+  let b:fugitive_type = 'index'
+  unlet! b:fugitive_reltime
+  try
+    silent doautocmd BufReadPre
+    let config = fugitive#Config()
+
+    let cmd = [fnamemodify(amatch, ':h')]
+    setlocal noro ma nomodeline buftype=nowrite
+    if s:cpath(fnamemodify($GIT_INDEX_FILE !=# '' ? $GIT_INDEX_FILE : fugitive#Find('.git/index'), ':p')) !=# s:cpath(amatch)
+      let cmd += ['-c', 'GIT_INDEX_FILE=' . amatch]
+    endif
+
+    if fugitive#GitVersion(2, 15)
+      call add(cmd, '--no-optional-locks')
+    endif
+
+    let b:fugitive_files = {'Staged': {}, 'Unstaged': {}}
+    let [staged, unstaged, untracked] = [[], [], []]
+    let props = {}
+
+    if fugitive#GitVersion(2, 11)
+      let cmd += ['status', '--porcelain=v2', '-bz']
+      let [output, message, exec_error] = s:NullError(cmd)
+      if exec_error
+        throw 'fugitive: ' . message
+      endif
+
+      let i = 0
+      while i < len(output)
+        let line = output[i]
+        let prop = matchlist(line, '# \(\S\+\) \(.*\)')
+        if len(prop)
+          let props[prop[1]] = prop[2]
+        elseif line[0] ==# '?'
+          call add(untracked, {'type': 'File', 'status': line[0], 'filename': line[2:-1]})
+        elseif line[0] !=# '#'
+          if line[0] ==# 'u'
+            let file = matchstr(line, '^.\{37\} \x\{40,\} \x\{40,\} \x\{40,\} \zs.*$')
+          else
+            let file = matchstr(line, '^.\{30\} \x\{40,\} \x\{40,\} \zs.*$')
+          endif
+          if line[0] ==# '2'
+            let i += 1
+            let file = matchstr(file, ' \zs.*')
+            let files = output[i] . ' -> ' . file
+          else
+            let files = file
+          endif
+          let sub = matchstr(line, '^[12u] .. \zs....')
+          if line[2] !=# '.'
+            call add(staged, {'type': 'File', 'status': line[2], 'filename': files, 'sub': sub})
+          endif
+          if line[3] !=# '.'
+            call add(unstaged, {'type': 'File', 'status': get({'C':'M','M':'?','U':'?'}, matchstr(sub, 'S\.*\zs[CMU]'), line[3]), 'filename': file, 'sub': sub})
+          endif
+        endif
+        let i += 1
+      endwhile
+      let branch = substitute(get(props, 'branch.head', '(unknown)'), '\C^(\%(detached\|unknown\))$', '', '')
+      if len(branch)
+        let head = branch
+      elseif has_key(props, 'branch.oid')
+        let head = props['branch.oid'][0:10]
+      else
+        let head = FugitiveHead(11)
+      endif
+      let pull = get(props, 'branch.upstream', '')
+    else " git < 2.11
+      let cmd += ['status', '--porcelain', '-bz']
+      let [output, message, exec_error] = s:NullError(cmd)
+      if exec_error
+        throw 'fugitive: ' . message
+      endif
+
+      while get(output, 0, '') =~# '^\l\+:'
+        call remove(output, 0)
+      endwhile
+      let head = matchstr(output[0], '^## \zs\S\+\ze\%($\| \[\)')
+      let pull = ''
+      if head =~# '\.\.\.'
+        let [head, pull] = split(head, '\.\.\.')
+        let branch = head
+      elseif head ==# 'HEAD' || empty(head)
+        let head = FugitiveHead(11)
+        let branch = ''
+      else
+        let branch = head
+      endif
+
+      let i = 0
+      while i < len(output)
+        let line = output[i]
+        let file = line[3:-1]
+        let files = file
+        let i += 1
+        if line[2] !=# ' '
+          continue
+        endif
+        if line[0:1] =~# '[RC]'
+          let files = output[i] . ' -> ' . file
+          let i += 1
+        endif
+        if line[0] !~# '[ ?!#]'
+          call add(staged, {'type': 'File', 'status': line[0], 'filename': files, 'sub': ''})
+        endif
+        if line[0:1] ==# '??'
+          call add(untracked, {'type': 'File', 'status': line[1], 'filename': files})
+        elseif line[1] !~# '[ !#]'
+          call add(unstaged, {'type': 'File', 'status': line[1], 'filename': file, 'sub': ''})
+        endif
+      endwhile
+    endif
+
+    if empty(s:Tree())
+      let [unstaged, untracked] = [[], []]
+    endif
+
+    for dict in staged
+      let b:fugitive_files['Staged'][dict.filename] = dict
+    endfor
+    for dict in unstaged
+      let b:fugitive_files['Unstaged'][dict.filename] = dict
+    endfor
+
+    let pull_type = 'Pull'
+    if len(pull)
+      let rebase = fugitive#Config('branch.' . branch . '.rebase', config)
+      if empty(rebase)
+        let rebase = fugitive#Config('pull.rebase', config)
+      endif
+      if rebase =~# '^\%(true\|yes\|on\|1\|interactive\|merges\|preserve\)$'
+        let pull_type = 'Rebase'
+      elseif rebase =~# '^\%(false\|no|off\|0\|\)$'
+        let pull_type = 'Merge'
+      endif
+    endif
+
+    let push_remote = fugitive#Config('branch.' . branch . '.pushRemote', config)
+    if empty(push_remote)
+      let push_remote = fugitive#Config('remote.pushDefault', config)
+    endif
+    let fetch_remote = fugitive#Config('branch.' . branch . '.remote', config)
+    if empty(fetch_remote)
+      let fetch_remote = 'origin'
+    endif
+    if empty(push_remote)
+      let push_remote = fetch_remote
+    endif
+
+    let push_default = fugitive#Config('push.default')
+    if empty(push_default)
+      let push_default = fugitive#GitVersion(2) ? 'simple' : 'matching'
+    endif
+    if push_default ==# 'upstream'
+      let push = pull
+    else
+      let push = len(branch) ? (push_remote ==# '.' ? '' : push_remote . '/') . branch : ''
+    endif
+
+    if isdirectory(fugitive#Find('.git/rebase-merge/'))
+      let rebasing_dir = fugitive#Find('.git/rebase-merge/')
+    elseif isdirectory(fugitive#Find('.git/rebase-apply/'))
+      let rebasing_dir = fugitive#Find('.git/rebase-apply/')
+    endif
+
+    let rebasing = []
+    let rebasing_head = 'detached HEAD'
+    if exists('rebasing_dir') && filereadable(rebasing_dir . 'git-rebase-todo')
+      let rebasing_head = substitute(readfile(rebasing_dir . 'head-name')[0], '\C^refs/heads/', '', '')
+      let len = 11
+      let lines = readfile(rebasing_dir . 'git-rebase-todo')
+      for line in lines
+        let hash = matchstr(line, '^[^a-z].*\s\zs[0-9a-f]\{4,\}\ze\.\.')
+        if len(hash)
+          let len = len(hash)
+          break
+        endif
+      endfor
+      if getfsize(rebasing_dir . 'done') > 0
+        let done = readfile(rebasing_dir . 'done')
+        call map(done, 'substitute(v:val, ''^\l\+\>'', "done", "")')
+        let done[-1] = substitute(done[-1], '^\l\+\>', 'stop', '')
+        let lines = done + lines
+      endif
+      call reverse(lines)
+      for line in lines
+        let match = matchlist(line, '^\(\l\+\)\s\+\(\x\{4,\}\)\s\+\(.*\)')
+        if len(match) && match[1] !~# 'exec\|merge\|label'
+          call add(rebasing, {'type': 'Rebase', 'status': get(s:rebase_abbrevs, match[1], match[1]), 'commit': strpart(match[2], 0, len), 'subject': match[3]})
+        endif
+      endfor
+    endif
+
+    let diff = {'Staged': [], 'Unstaged': []}
+    if len(staged)
+      let diff['Staged'] =
+          \ s:LinesError(['diff', '--color=never', '--no-ext-diff', '--no-prefix', '--cached'])[0]
+    endif
+    if len(unstaged)
+      let diff['Unstaged'] =
+          \ s:LinesError(['diff', '--color=never', '--no-ext-diff', '--no-prefix'])[0]
+    endif
+    let b:fugitive_diff = diff
+    let expanded = get(b:, 'fugitive_expanded', {'Staged': {}, 'Unstaged': {}})
+    let b:fugitive_expanded = {'Staged': {}, 'Unstaged': {}}
+
+    silent keepjumps %delete_
+
+    call s:AddHeader('Head', head)
+    call s:AddHeader(pull_type, pull)
+    if push !=# pull
+      call s:AddHeader('Push', push)
+    endif
+    if empty(s:Tree())
+      call s:AddHeader('Bare', 'yes')
+    endif
+    if get(FugitiveConfigGetAll('advice.statusHints', config), 0, 'true') !~# '^\%(false\|no|off\|0\|\)$'
+      call s:AddHeader('Help', 'g?')
+    endif
+
+    call s:AddSection('Rebasing ' . rebasing_head, rebasing)
+    call s:AddSection('Untracked', untracked)
+    call s:AddSection('Unstaged', unstaged)
+    let unstaged_end = len(unstaged) ? line('$') : 0
+    call s:AddSection('Staged', staged)
+    let staged_end = len(staged) ? line('$') : 0
+
+    if len(pull) && get(props, 'branch.ab') !~# ' -0$'
+      call s:AddSection('Unpulled from ' . pull, s:QueryLog(head . '..' . pull))
+    endif
+    if len(push) && push !=# pull
+      call s:AddSection('Unpulled from ' . push, s:QueryLog(head . '..' . push))
+    endif
+    if len(pull) && push !=# pull
+      call s:AddSection('Unpushed to ' . pull, s:QueryLog(pull . '..' . head))
+    endif
+    if len(push) && !(push ==# pull && get(props, 'branch.ab') =~# '^+0 ')
+      call s:AddSection('Unpushed to ' . push, s:QueryLog(push . '..' . head))
+    endif
+
+    setlocal nomodified readonly noswapfile
+    silent doautocmd BufReadPost
+    setlocal nomodifiable
+    if &bufhidden ==# ''
+      setlocal bufhidden=delete
+    endif
+    let b:dispatch = '-dir=' . fnameescape(len(s:Tree()) ? s:Tree() : s:Dir()) . ' ' . g:fugitive_git_executable . ' fetch --all'
+    call fugitive#MapJumps()
+    call s:Map('n', '-', ":<C-U>execute <SID>Do('Toggle',0)<CR>", '<silent>')
+    call s:Map('x', '-', ":<C-U>execute <SID>Do('Toggle',1)<CR>", '<silent>')
+    call s:Map('n', 's', ":<C-U>execute <SID>Do('Stage',0)<CR>", '<silent>')
+    call s:Map('x', 's', ":<C-U>execute <SID>Do('Stage',1)<CR>", '<silent>')
+    call s:Map('n', 'u', ":<C-U>execute <SID>Do('Unstage',0)<CR>", '<silent>')
+    call s:Map('x', 'u', ":<C-U>execute <SID>Do('Unstage',1)<CR>", '<silent>')
+    call s:Map('n', 'U', ":exe <SID>EchoExec('reset', '-q')<CR>", '<silent>')
+    call s:MapMotion('gu', "exe <SID>StageJump(v:count, 'Untracked', 'Unstaged')")
+    call s:MapMotion('gU', "exe <SID>StageJump(v:count, 'Unstaged', 'Untracked')")
+    call s:MapMotion('gs', "exe <SID>StageJump(v:count, 'Staged')")
+    call s:MapMotion('gp', "exe <SID>StageJump(v:count, 'Unpushed')")
+    call s:MapMotion('gP', "exe <SID>StageJump(v:count, 'Unpulled')")
+    call s:MapMotion('gr', "exe <SID>StageJump(v:count, 'Rebasing')")
+    call s:Map('n', 'C', ":echoerr ':Gstatus C has been removed in favor of cc'<CR>", '<silent>')
+    call s:Map('n', 'a', ":<C-U>execute <SID>Do('Toggle',0)<CR>", '<silent>')
+    call s:Map('n', 'i', ":<C-U>execute <SID>NextExpandedHunk(v:count1)<CR>", '<silent>')
+    call s:Map('n', "=", ":<C-U>execute <SID>StageInline('toggle',line('.'),v:count)<CR>", '<silent>')
+    call s:Map('n', "<", ":<C-U>execute <SID>StageInline('hide',  line('.'),v:count)<CR>", '<silent>')
+    call s:Map('n', ">", ":<C-U>execute <SID>StageInline('show',  line('.'),v:count)<CR>", '<silent>')
+    call s:Map('x', "=", ":<C-U>execute <SID>StageInline('toggle',line(\"'<\"),line(\"'>\")-line(\"'<\")+1)<CR>", '<silent>')
+    call s:Map('x', "<", ":<C-U>execute <SID>StageInline('hide',  line(\"'<\"),line(\"'>\")-line(\"'<\")+1)<CR>", '<silent>')
+    call s:Map('x', ">", ":<C-U>execute <SID>StageInline('show',  line(\"'<\"),line(\"'>\")-line(\"'<\")+1)<CR>", '<silent>')
+    call s:Map('n', 'D', ":<C-U>execute <SID>StageDiff('Gdiffsplit')<Bar>redraw<Bar>echohl WarningMsg<Bar> echo ':Gstatus D is deprecated in favor of dd'<Bar>echohl NONE<CR>", '<silent>')
+    call s:Map('n', 'dd', ":<C-U>execute <SID>StageDiff('Gdiffsplit')<CR>", '<silent>')
+    call s:Map('n', 'dh', ":<C-U>execute <SID>StageDiff('Ghdiffsplit')<CR>", '<silent>')
+    call s:Map('n', 'ds', ":<C-U>execute <SID>StageDiff('Ghdiffsplit')<CR>", '<silent>')
+    call s:Map('n', 'dp', ":<C-U>execute <SID>StageDiffEdit()<CR>", '<silent>')
+    call s:Map('n', 'dv', ":<C-U>execute <SID>StageDiff('Gvdiffsplit')<CR>", '<silent>')
+    call s:Map('n', 'd?', ":<C-U>help fugitive_d<CR>", '<silent>')
+    call s:Map('n', 'P', ":<C-U>execute <SID>StagePatch(line('.'),line('.')+v:count1-1)<CR>", '<silent>')
+    call s:Map('x', 'P', ":<C-U>execute <SID>StagePatch(line(\"'<\"),line(\"'>\"))<CR>", '<silent>')
+    call s:Map('n', 'p', ":<C-U>if v:count<Bar>silent exe <SID>GF('pedit')<Bar>else<Bar>echoerr 'Use = for inline diff, P for :Git add/reset --patch, 1p for :pedit'<Bar>endif<CR>", '<silent>')
+    call s:Map('x', 'p', ":<C-U>execute <SID>StagePatch(line(\"'<\"),line(\"'>\"))<CR>", '<silent>')
+    call s:Map('n', 'I', ":<C-U>execute <SID>StagePatch(line('.'),line('.'))<CR>", '<silent>')
+    call s:Map('x', 'I', ":<C-U>execute <SID>StagePatch(line(\"'<\"),line(\"'>\"))<CR>", '<silent>')
+    if empty(mapcheck('q', 'n'))
+      nnoremap <buffer> <silent> q :<C-U>if bufnr('$') == 1<Bar>quit<Bar>else<Bar>bdelete<Bar>endif<Bar>echohl WarningMsg<Bar>echo ':Gstatus q is deprecated in favor of gq or the built-in <Lt>C-W>q'<Bar>echohl NONE<CR>
+    endif
+    call s:Map('n', 'gq', ":<C-U>if bufnr('$') == 1<Bar>quit<Bar>else<Bar>bdelete<Bar>endif<CR>", '<silent>')
+    call s:Map('n', 'R', ":echohl WarningMsg<Bar>echo 'Reloading is automatic.  Use :e to force'<Bar>echohl NONE<CR>", '<silent>')
+    call s:Map('n', 'g<Bar>', ":<C-U>echoerr 'Changed to X'<CR>", '<silent>')
+    call s:Map('x', 'g<Bar>', ":<C-U>echoerr 'Changed to X'<CR>", '<silent>')
+    call s:Map('n', 'X', ":<C-U>execute <SID>StageDelete(line('.'), 0, v:count)<CR>", '<silent>')
+    call s:Map('x', 'X', ":<C-U>execute <SID>StageDelete(line(\"'<\"), line(\"'>\"), v:count)<CR>", '<silent>')
+    call s:Map('n', 'gI', ":<C-U>execute <SID>StageIgnore(line('.'), line('.'), v:count)<CR>", '<silent>')
+    call s:Map('x', 'gI', ":<C-U>execute <SID>StageIgnore(line(\"'<\"), line(\"'>\"), v:count)<CR>", '<silent>')
+    call s:Map('n', '.', ':<C-U> <C-R>=<SID>StageArgs(0)<CR><Home>')
+    call s:Map('x', '.', ':<C-U> <C-R>=<SID>StageArgs(1)<CR><Home>')
+    setlocal filetype=fugitive
+
+    for [lnum, section] in [[staged_end, 'Staged'], [unstaged_end, 'Unstaged']]
+      while len(getline(lnum))
+        let filename = matchstr(getline(lnum), '^[A-Z?] \zs.*')
+        if has_key(expanded[section], filename)
+          call s:StageInline('show', lnum)
+        endif
+        let lnum -= 1
+      endwhile
+    endfor
+
+    let b:fugitive_reltime = reltime()
+    return 'silent ' . s:DoAutocmd('User FugitiveIndex')
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+endfunction
+
+function! fugitive#FileReadCmd(...) abort
+  let amatch = a:0 ? a:1 : expand('<amatch>')
+  let [dir, rev] = s:DirRev(amatch)
+  let line = a:0 > 1 ? a:2 : line("'[")
+  if empty(dir)
+    return 'noautocmd ' . line . 'read ' . s:fnameescape(amatch)
+  endif
+  if rev !~# ':' && s:ChompDefault('', [dir, 'cat-file', '-t', rev]) =~# '^\%(commit\|tag\)$'
+    let cmd = fugitive#Prepare(dir, 'log', '--pretty=format:%B', '-1', rev, '--')
+  else
+    let cmd = fugitive#Prepare(dir, 'cat-file', '-p', rev)
+  endif
+  return line . 'read !' . escape(cmd, '!#%')
+endfunction
+
+function! fugitive#FileWriteCmd(...) abort
+  let tmp = tempname()
+  let amatch = a:0 ? a:1 : expand('<amatch>')
+  let autype = a:0 > 1 ? 'Buf' : 'File'
+  if exists('#' . autype . 'WritePre')
+    execute s:DoAutocmd(autype . 'WritePre ' . s:fnameescape(amatch))
+  endif
+  try
+    let [dir, commit, file] = s:DirCommitFile(amatch)
+    if commit !~# '^[0-3]$' || !v:cmdbang && (line("'[") != 1 || line("']") != line('$'))
+      return "noautocmd '[,']write" . (v:cmdbang ? '!' : '') . ' ' . s:fnameescape(amatch)
+    endif
+    silent execute "'[,']write !".fugitive#Prepare(dir, 'hash-object', '-w', '--stdin', '--').' > '.tmp
+    let sha1 = readfile(tmp)[0]
+    let old_mode = matchstr(s:SystemError([dir, 'ls-files', '--stage', '.' . file])[0], '^\d\+')
+    if empty(old_mode)
+      let old_mode = executable(s:Tree(dir) . file) ? '100755' : '100644'
+    endif
+    let error = s:UpdateIndex(dir, [old_mode, sha1, commit, file[1:-1]])
+    if empty(error)
+      setlocal nomodified
+      if exists('#' . autype . 'WritePost')
+        execute s:DoAutocmd(autype . 'WritePost ' . s:fnameescape(amatch))
+      endif
+      return ''
+    else
+      return 'echoerr '.string('fugitive: '.error)
+    endif
+  finally
+    call delete(tmp)
+  endtry
+endfunction
+
+function! fugitive#BufReadCmd(...) abort
+  let amatch = a:0 ? a:1 : expand('<amatch>')
+  try
+    let [dir, rev] = s:DirRev(amatch)
+    if empty(dir)
+      return 'echo "Invalid Fugitive URL"'
+    endif
+    let b:git_dir = dir
+    if rev =~# '^:\d$'
+      let b:fugitive_type = 'stage'
+    else
+      let [b:fugitive_type, exec_error] = s:ChompError([dir, 'cat-file', '-t', rev])
+      if exec_error && rev =~# '^:0'
+        let sha = s:ChompDefault('', dir, 'write-tree', '--prefix=' . rev[3:-1])
+        let exec_error = empty(sha)
+        let b:fugitive_type = exec_error ? '' : 'tree'
+      endif
+      if exec_error
+        let error = b:fugitive_type
+        unlet b:fugitive_type
+        setlocal noswapfile
+        if empty(&bufhidden)
+          setlocal bufhidden=delete
+        endif
+        if rev =~# '^:\d:'
+          let &l:readonly = !filewritable(fugitive#Find('.git/index', dir))
+          return 'silent doautocmd BufNewFile'
+        else
+          setlocal readonly nomodifiable
+          return 'silent doautocmd BufNewFile|echo ' . string(error)
+        endif
+      elseif b:fugitive_type !~# '^\%(tag\|commit\|tree\|blob\)$'
+        return "echoerr ".string("fugitive: unrecognized git type '".b:fugitive_type."'")
+      endif
+      if !exists('b:fugitive_display_format') && b:fugitive_type != 'blob'
+        let b:fugitive_display_format = +getbufvar('#','fugitive_display_format')
+      endif
+    endif
+
+    if b:fugitive_type !=# 'blob'
+      setlocal nomodeline
+    endif
+
+    setlocal noreadonly modifiable
+    let pos = getpos('.')
+    silent keepjumps %delete_
+    setlocal endofline
+
+    try
+      silent exe s:DoAutocmd('BufReadPre')
+      if b:fugitive_type ==# 'tree'
+        let b:fugitive_display_format = b:fugitive_display_format % 2
+        if b:fugitive_display_format
+          call s:ReplaceCmd([dir, 'ls-tree', exists('sha') ? sha : rev])
+        else
+          if !exists('sha')
+            let sha = s:TreeChomp(dir, 'rev-parse', '--verify', rev, '--')
+          endif
+          call s:ReplaceCmd([dir, 'show', '--no-color', sha])
+        endif
+      elseif b:fugitive_type ==# 'tag'
+        let b:fugitive_display_format = b:fugitive_display_format % 2
+        if b:fugitive_display_format
+          call s:ReplaceCmd([dir, 'cat-file', b:fugitive_type, rev])
+        else
+          call s:ReplaceCmd([dir, 'cat-file', '-p', rev])
+        endif
+      elseif b:fugitive_type ==# 'commit'
+        let b:fugitive_display_format = b:fugitive_display_format % 2
+        if b:fugitive_display_format
+          call s:ReplaceCmd([dir, 'cat-file', b:fugitive_type, rev])
+        else
+          call s:ReplaceCmd([dir, '-c', 'diff.noprefix=false', 'show', '--no-color', '-m', '--first-parent', '--pretty=format:tree%x20%T%nparent%x20%P%nauthor%x20%an%x20<%ae>%x20%ad%ncommitter%x20%cn%x20<%ce>%x20%cd%nencoding%x20%e%n%n%s%n%n%b', rev])
+          keepjumps 1
+          keepjumps call search('^parent ')
+          if getline('.') ==# 'parent '
+            silent lockmarks keepjumps delete_
+          else
+            silent exe (exists(':keeppatterns') ? 'keeppatterns' : '') 'keepjumps s/\m\C\%(^parent\)\@<! /\rparent /e' . (&gdefault ? '' : 'g')
+          endif
+          keepjumps let lnum = search('^encoding \%(<unknown>\)\=$','W',line('.')+3)
+          if lnum
+            silent lockmarks keepjumps delete_
+          end
+          silent exe (exists(':keeppatterns') ? 'keeppatterns' : '') 'keepjumps 1,/^diff --git\|\%$/s/\r$//e'
+          keepjumps 1
+        endif
+      elseif b:fugitive_type ==# 'stage'
+        call s:ReplaceCmd([dir, 'ls-files', '--stage'])
+      elseif b:fugitive_type ==# 'blob'
+        call s:ReplaceCmd([dir, 'cat-file', b:fugitive_type, rev])
+      endif
+    finally
+      keepjumps call setpos('.',pos)
+      setlocal nomodified noswapfile
+      let modifiable = rev =~# '^:.:' && b:fugitive_type !=# 'tree'
+      let &l:readonly = !modifiable || !filewritable(fugitive#Find('.git/index', dir))
+      if empty(&bufhidden)
+        setlocal bufhidden=delete
+      endif
+      let &l:modifiable = modifiable
+      if b:fugitive_type !=# 'blob'
+        setlocal filetype=git foldmethod=syntax
+        call s:Map('n', 'a', ":<C-U>let b:fugitive_display_format += v:count1<Bar>exe fugitive#BufReadCmd(@%)<CR>", '<silent>')
+        call s:Map('n', 'i', ":<C-U>let b:fugitive_display_format -= v:count1<Bar>exe fugitive#BufReadCmd(@%)<CR>", '<silent>')
+      endif
+      call fugitive#MapJumps()
+    endtry
+
+    setlocal modifiable
+
+    return 'silent ' . s:DoAutocmd('BufReadPost') .
+          \ (modifiable ? '' : '|setl nomodifiable') . '|silent ' .
+          \ s:DoAutocmd('User Fugitive' . substitute(b:fugitive_type, '^\l', '\u&', ''))
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+endfunction
+
+function! fugitive#BufWriteCmd(...) abort
+  return fugitive#FileWriteCmd(a:0 ? a:1 : expand('<amatch>'), 1)
+endfunction
+
+function! fugitive#SourceCmd(...) abort
+  let amatch = a:0 ? a:1 : expand('<amatch>')
+  let temp = s:BlobTemp(amatch)
+  if empty(temp)
+    return 'noautocmd source ' . s:fnameescape(amatch)
+  endif
+  if !exists('g:virtual_scriptnames')
+    let g:virtual_scriptnames = {}
+  endif
+  let g:virtual_scriptnames[temp] = amatch
+  return 'source ' . s:fnameescape(temp)
+endfunction
+
+" Section: Temp files
+
+if !exists('s:temp_files')
+  let s:temp_files = {}
+endif
+
+function! s:TempState(...) abort
+  return get(s:temp_files, s:cpath(fnamemodify(a:0 ? a:1 : @%, ':p')), {})
+endfunction
+
+function! s:TempReadPre(file) abort
+  if has_key(s:temp_files, s:cpath(a:file))
+    let dict = s:temp_files[s:cpath(a:file)]
+    setlocal nomodeline
+    if empty(&bufhidden)
+      setlocal bufhidden=delete
+    endif
+    setlocal buftype=nowrite
+    setlocal nomodifiable
+    if len(dict.dir)
+      let b:git_dir = dict.dir
+      call extend(b:, {'fugitive_type': 'temp'}, 'keep')
+    endif
+  endif
+endfunction
+
+function! s:TempReadPost(file) abort
+  if has_key(s:temp_files, s:cpath(a:file))
+    let dict = s:temp_files[s:cpath(a:file)]
+    setlocal nobuflisted
+    if get(dict, 'filetype', '') ==# 'git'
+      call fugitive#MapJumps()
+    endif
+    if has_key(dict, 'filetype')
+      let &l:filetype = dict.filetype
+    endif
+    setlocal foldmarker=<<<<<<<,>>>>>>>
+    if empty(mapcheck('q', 'n'))
+      nnoremap <buffer> <silent> q    :<C-U>bdelete<Bar>echohl WarningMsg<Bar>echo "Temp file q is deprecated in favor of the built-in <Lt>C-W>q"<Bar>echohl NONE<CR>
+    endif
+    if !&modifiable
+      call s:Map('n', 'gq', ":<C-U>bdelete<CR>", '<silent> <unique>')
+    endif
+  endif
+  return ''
+endfunction
+
+function! s:TempDelete(file) abort
+  let key = s:cpath(a:file)
+  if has_key(s:temp_files, key)
+    call delete(a:file)
+    call remove(s:temp_files, key)
+  endif
+  return ''
+endfunction
+
+augroup fugitive_temp
+  autocmd!
+  autocmd BufReadPre  * exe s:TempReadPre( expand('<amatch>:p'))
+  autocmd BufReadPost * exe s:TempReadPost(expand('<amatch>:p'))
+  autocmd BufWipeout  * exe s:TempDelete(  expand('<amatch>:p'))
+augroup END
+
+" Section: :Git
+
+function! s:AskPassArgs(dir) abort
+  if (len($DISPLAY) || len($TERM_PROGRAM) || has('gui_running')) && fugitive#GitVersion(1, 8) &&
+        \ empty($GIT_ASKPASS) && empty($SSH_ASKPASS) && empty(FugitiveConfigGetAll('core.askpass', a:dir))
+    if s:executable(s:ExecPath() . '/git-gui--askpass')
+      return ['-c', 'core.askPass=' . s:ExecPath() . '/git-gui--askpass']
+    elseif s:executable('ssh-askpass')
+      return ['-c', 'core.askPass=ssh-askpass']
+    endif
+  endif
+  return []
+endfunction
+
+function! s:RunJobs() abort
+  return exists('*job_start') || exists('*jobstart')
+endfunction
+
+function! s:RunEdit(state, job) abort
+  if get(a:state, 'request', '') == 'edit'
+    call remove(a:state, 'request')
+    let file = readfile(a:state.temp . '.edit')[0]
+    exe substitute(a:state.mods, '\<tab\>', '-tab', 'g') 'keepalt split' s:fnameescape(file)
+    set bufhidden=wipe
+    let s:edit_jobs[bufnr('')] = [a:state, a:job]
+    return 1
+  endif
+endfunction
+
+function! s:RunReceive(state, type, job, data, ...) abort
+  call add(a:state.log, a:data)
+  let data = type(a:data) == type([]) ? join(a:data, "\n") : a:data
+  if a:type ==# 'err' || a:state.pty
+    let data = a:state.escape_buffer . data
+    let escape = "\033]51;[^\007]*"
+    let a:state.escape_buffer = matchstr(data, escape . '$')
+    if len(a:state.escape_buffer)
+      let data = strpart(data, 0, len(data) - len(a:state.escape_buffer))
+    endif
+    let cmd = matchstr(data, escape . "\007")[5:-2]
+    let data = substitute(data, escape . "\007", '', 'g')
+    if cmd =~# '^fugitive:'
+      let a:state.request = strpart(cmd, 9)
+    endif
+  endif
+  let data = a:state.echo_buffer . data
+  let a:state.echo_buffer = matchstr(data, "[\r\n]\\+$")
+  if len(a:state.echo_buffer)
+    let data = strpart(data, 0, len(data) - len(a:state.echo_buffer))
+  endif
+  echon substitute(data, "\r\\ze\n", '', 'g')
+endfunction
+
+function! s:RunSend(job, str) abort
+  try
+    if type(a:job) == type(0)
+      call chansend(a:job, a:str)
+    else
+      call ch_sendraw(a:job, a:str)
+    endif
+    return len(a:str)
+  catch /^Vim\%((\a\+)\)\=:E90[06]:/
+    return 0
+  endtry
+endfunction
+
+if !exists('s:edit_jobs')
+  let s:edit_jobs = {}
+endif
+function! s:RunWait(state, job) abort
+  let finished = 0
+  try
+    while get(a:state, 'request', '') !=# 'edit' && (type(a:job) == type(0) ? jobwait([a:job], 1)[0] == -1 : ch_status(a:job) !=# 'closed' || job_status(a:job) ==# 'run')
+      if !exists('*jobwait')
+        sleep 1m
+      endif
+      if !get(a:state, 'closed')
+        let peek = getchar(1)
+        if peek != 0 && !(has('win32') && peek == 128)
+          let c = getchar()
+          let c = type(c) == type(0) ? nr2char(c) : c
+          if c ==# "\<C-D>"
+            let a:state.closed = 1
+            if type(a:job) ==# type(0)
+              call chanclose(a:job, 'stdin')
+            else
+              call ch_close_in(a:job)
+            endif
+          else
+            call s:RunSend(a:job, c)
+            if !a:state.pty
+              echon c
+            endif
+          endif
+        endif
+      endif
+    endwhile
+    sleep 1m
+    echo
+    call s:RunEdit(a:state, a:job)
+    let finished = 1
+  finally
+    if !finished
+      try
+        if a:state.pty
+          call s:RunSend(a:job, "\<C-C>")
+        elseif type(a:job) == type(0)
+          call jobstop(a:job)
+        else
+          call job_stop(a:job)
+        endif
+      catch /.*/
+      endtry
+    endif
+  endtry
+  call fugitive#ReloadStatus(a:state.dir, 1)
+  return ''
+endfunction
+
+if !exists('s:resume_queue')
+  let s:resume_queue = []
+endif
+function! fugitive#Resume() abort
+  while len(s:resume_queue)
+    let [state, job] = remove(s:resume_queue, 0)
+    if filereadable(state.temp . '.edit')
+      call delete(state.temp . '.edit')
+    endif
+    call s:RunWait(state, job)
+  endwhile
+endfunction
+
+function! s:RunBufDelete(bufnr) abort
+  if has_key(s:edit_jobs, a:bufnr) |
+    call add(s:resume_queue, remove(s:edit_jobs, a:bufnr))
+    call feedkeys(":redraw!|call fugitive#Resume()|silent checktime\r", 'n')
+  endif
+endfunction
+
+augroup fugitive_job
+  autocmd!
+  autocmd BufDelete * call s:RunBufDelete(expand('<abuf>'))
+  autocmd VimLeave *
+        \ for s:jobbuf in keys(s:edit_jobs) |
+        \   call writefile([], s:edit_jobs[s:jobbuf][0].temp . '.exit') |
+        \   redraw! |
+        \   call call('s:RunWait', remove(s:edit_jobs, s:jobbuf)) |
+        \ endfor
+augroup END
+
+function! s:OpenExec(cmd, mods, env, args, ...) abort
+  let options = a:0 ? a:1 : {'dir': s:Dir()}
+  let temp = tempname()
+  let columns = get(g:, 'fugitive_columns', 80)
+  let env = s:BuildEnvPrefix(extend({'COLUMNS': columns}, a:env))
+  silent! execute '!' . escape(env . s:UserCommand(options, ['--no-pager'] + a:args), '!#%') .
+        \ (&shell =~# 'csh' ? ' >& ' . temp : ' > ' . temp . ' 2>&1')
+  redraw!
+  let temp = s:Resolve(temp)
+  let first = join(readfile(temp, '', 2), "\n")
+  if first =~# '\<\([[:upper:][:digit:]_-]\+(\d\+)\).*\1'
+    let filetype = 'man'
+  else
+    let filetype = 'git'
+  endif
+  let s:temp_files[s:cpath(temp)] = { 'dir': options.dir, 'filetype': filetype }
+  if a:cmd ==# 'edit'
+    call s:BlurStatus()
+  endif
+  silent execute s:Mods(a:mods) . a:cmd temp
+  call fugitive#ReloadStatus(options.dir, 1)
+  return 'echo ' . string(':!' . s:UserCommand(options, a:args))
+endfunction
+
+function! fugitive#PagerFor(argv, ...) abort
+  let args = a:argv
+  if empty(args)
+    return 0
+  elseif (args[0] ==# 'help' || get(args, 1, '') ==# '--help') && !s:HasOpt(args, '--web')
+    return 1
+  endif
+  if args[0] ==# 'config' && (s:HasOpt(args, '-e', '--edit') ||
+        \   !s:HasOpt(args, '--list', '--get-all', '--get-regexp', '--get-urlmatch')) ||
+        \ args[0] =~# '^\%(tag\|branch\)$' && (
+        \    s:HasOpt(args, '--edit-description', '--unset-upstream', '-m', '-M', '--move', '-c', '-C', '--copy', '-d', '-D', '--delete') ||
+        \   len(filter(args[1:-1], 'v:val =~# "^[^-]\\|^--set-upstream-to="')) &&
+        \   !s:HasOpt(args, '--contains', '--no-contains', '--merged', '--no-merged', '--points-at'))
+    return 0
+  endif
+  let config = a:0 ? a:1 : fugitive#Config()
+  let value = get(FugitiveConfigGetAll('pager.' . args[0], config), 0, -1)
+  if value =~# '^\%(true\|yes\|on\|1\)$'
+    return 1
+  elseif value =~# '^\%(false\|no|off\|0\|\)$'
+    return 0
+  elseif type(value) == type('')
+    return value
+  elseif args[0] =~# 'diff\%(tool\)\@!\|log\|^show$\|^config$\|^branch$\|^tag$' ||
+        \ (args[0] ==# 'stash' && get(args, 1, '') ==# 'show') ||
+        \ (args[0] ==# 'am' && s:HasOpt(args, '--show-current-patch'))
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+let s:disable_colors = []
+for s:colortype in ['advice', 'branch', 'diff', 'grep', 'interactive', 'pager', 'push', 'remote', 'showBranch', 'status', 'transport', 'ui']
+  call extend(s:disable_colors, ['-c', 'color.' . s:colortype . '=false'])
+endfor
+unlet s:colortype
+function! fugitive#Command(line1, line2, range, bang, mods, arg) abort
+  let dir = s:Dir()
+  let config = copy(fugitive#Config(dir))
+  let [args, after] = s:SplitExpandChain(a:arg, s:Tree(dir))
+  let flags = []
+  let pager = -1
+  while len(args)
+    if args[0] ==# '-c' && len(args) > 1
+      call extend(flags, remove(args, 0, 1))
+    elseif args[0] =~# '^-p$\|^--paginate$'
+      let pager = 1
+      call remove(args, 0)
+    elseif args[0] =~# '^-P$\|^--no-pager$'
+      let pager = 0
+      call remove(args, 0)
+    elseif args[0] =~# '^--\%([[:lower:]-]\+-pathspecs\|no-optional-locks\)$'
+      call add(flags, remove(args, 0))
+    elseif args[0] =~# '^-C$\|^--\%(exec-path=\|git-dir=\|work-tree=\|bare$\)'
+      return 'echoerr ' . string('fugitive: ' . args[0] . ' is not supported')
+    else
+      break
+    endif
+  endwhile
+  if pager is# 0
+    call add(flags, '--no-pager')
+  endif
+  if empty(args) && pager is# -1
+    let cmd = s:StatusCommand(a:line1, a:line2, a:range, a:line2, a:bang, a:mods, '', '', [])
+    return (empty(cmd) ? 'exe' : cmd) . after
+  endif
+  let alias = fugitive#Config('alias.' . get(args, 0, ''), config)
+  if get(args, 1, '') !=# '--help' && alias !~# '^$\|^!\|[\"'']' && !filereadable(s:ExecPath() . '/git-' . args[0])
+        \ && !(has('win32') && filereadable(s:ExecPath() . '/git-' . args[0] . '.exe'))
+    call remove(args, 0)
+    call extend(args, split(alias, '\s\+'), 'keep')
+  endif
+  let name = substitute(get(args, 0, ''), '\%(^\|-\)\(\l\)', '\u\1', 'g')
+  let git = split(get(g:, 'fugitive_git_command', g:fugitive_git_executable), '\s\+')
+  let options = {'git': git, 'dir': dir, 'flags': flags}
+  if pager is# -1 && exists('*s:' . name . 'Subcommand') && get(args, 1, '') !=# '--help'
+    try
+      let overrides = s:{name}Subcommand(a:line1, a:line2, a:range, a:bang, a:mods, extend({'subcommand': args[0], 'subcommand_args': args[1:-1]}, options))
+      if type(overrides) == type('')
+        return 'exe ' . string(overrides) . after
+      endif
+      let args = [get(overrides, 'command', args[0])] + get(overrides, 'insert_args', []) + args[1:-1]
+    catch /^fugitive:/
+      return 'echoerr ' . string(v:exception)
+    endtry
+  else
+    let overrides = {}
+  endif
+  let env = get(overrides, 'env', {})
+  let i = 0
+  while i < len(flags) - 1
+    if flags[i] ==# '-c'
+      let i += 1
+      let config_name = tolower(matchstr(flags[i], '^[^=]\+'))
+      if has_key(s:prepare_env, config_name) && flags[i] =~# '=.'
+        let env[s:prepare_env[config_name]] = matchstr(flags[i], '=\zs.*')
+      endif
+      if flags[i] =~# '='
+        let config[config_name] = [matchstr(flags[i], '=\zs.*')]
+      else
+        let config[config_name] = [1]
+      endif
+    endif
+    let i += 1
+  endwhile
+  let editcmd = a:line2 ? 'split' : 'edit'
+  if pager is# 1
+    if a:bang && a:line2 >= 0
+      let editcmd = 'read'
+    elseif a:bang
+      let editcmd = 'pedit'
+    endif
+  elseif pager is# -1
+    let pager = fugitive#PagerFor(args, config)
+    if a:bang && pager isnot# 1
+      return 'echoerr ' .  string('fugitive: :Git! for temp buffer output has been replaced by :Git --paginate')
+    endif
+  endif
+  if (s:HasOpt(args, ['add', 'checkout', 'commit', 'stage', 'stash', 'reset'], '-p', '--patch') ||
+        \ s:HasOpt(args, ['add', 'clean', 'stage'], '-i', '--interactive') ||
+        \ type(pager) == type('')) && pager isnot# 1
+    let mods = substitute(s:Mods(a:mods), '\<tab\>', '-tab', 'g')
+    let assign = len(dir) ? '|let b:git_dir = ' . string(dir) : ''
+    if has('nvim')
+      if &autowrite || &autowriteall | silent! wall | endif
+      return mods . (a:line2 ? 'split' : 'edit') . ' term://' . s:fnameescape(s:UserCommand(options, args)) . assign . '|startinsert' . after
+    elseif has('terminal')
+      if &autowrite || &autowriteall | silent! wall | endif
+      return 'exe ' . string(mods . 'terminal ' . (a:line2 ? '' : '++curwin ') . join(map(s:UserCommandList(options) + args, 's:fnameescape(v:val)'))) . assign . after
+    endif
+  endif
+  if pager is# 1
+    if editcmd ==# 'read'
+      return s:ReadExec(a:line1, a:line2, a:range, a:mods, env, args, options) . after
+    else
+      return s:OpenExec(editcmd, a:mods, env, args, options) . after
+    endif
+  endif
+  if s:RunJobs()
+    let state = {
+          \ 'dir': dir,
+          \ 'mods': s:Mods(a:mods),
+          \ 'title': ':Git ' . a:arg,
+          \ 'echo_buffer': '',
+          \ 'escape_buffer': '',
+          \ 'log': [],
+          \ 'temp': s:Resolve(tempname())}
+    let state.pty = get(g:, 'fugitive_pty', has('unix') && (has('patch-8.0.0744') || has('nvim')))
+    if !state.pty
+      let args = s:AskPassArgs(dir) + args
+    endif
+    let env.FUGITIVE_TEMP = state.temp
+    let env.FUGITIVE = state.temp
+    let editor = 'sh ' . s:TempScript(
+          \ '[ -f "$FUGITIVE.exit" ] && exit 1',
+          \ 'echo "$1" > "$FUGITIVE.edit"',
+          \ 'printf "\033]51;fugitive:edit\007" >&2',
+          \ 'while [ -f "$FUGITIVE.edit" -a ! -f "$FUGITIVE.exit" ]; do sleep 0.05 2>/dev/null || sleep 1; done',
+          \ 'exit 0')
+    call extend(env, {
+          \ 'NO_COLOR': '1',
+          \ 'GIT_EDITOR': editor,
+          \ 'GIT_SEQUENCE_EDITOR': editor,
+          \ 'GIT_MERGE_AUTOEDIT': '1',
+          \ 'GIT_PAGER': 'cat',
+          \ 'PAGER': 'cat'}, 'keep')
+    let args = s:disable_colors + flags + ['-c', 'advice.waitingForEditor=false'] + args
+    let argv = s:UserCommandList({'git': git, 'dir': dir}) + args
+    let [argv, jobopts] = s:JobOpts(argv, env)
+    let state.cmd = argv
+    let g:_fugitive_last_job = state
+    if &autowrite || &autowriteall | silent! wall | endif
+    echo ""
+    if exists('*job_start')
+      call extend(jobopts, {
+            \ 'mode': 'raw',
+            \ 'out_cb': function('s:RunReceive', [state, 'out']),
+            \ 'err_cb': function('s:RunReceive', [state, 'err']),
+            \ })
+      if state.pty
+        let jobopts.pty = 1
+      endif
+      let job = job_start(argv, jobopts)
+    else
+      let job = jobstart(argv, extend(jobopts, {
+            \ 'pty': state.pty,
+            \ 'TERM': 'dumb',
+            \ 'on_stdout': function('s:RunReceive', [state, 'out']),
+            \ 'on_stderr': function('s:RunReceive', [state, 'err']),
+            \ }))
+    endif
+    let state.job = job
+    call s:RunWait(state, job)
+    return 'silent checktime' . after
+  elseif has('win32')
+    return 'echoerr ' . string('fugitive: Vim 8 with job support required to use :Git on Windows')
+  elseif has('gui_running')
+    return 'echoerr ' . string('fugitive: Vim 8 with job support required to use :Git in GVim')
+  else
+    let pre = s:BuildEnvPrefix(env)
+    return 'exe ' . string('noautocmd !' . escape(pre . s:UserCommand(options, args), '!#%')) .
+          \ '|call fugitive#ReloadStatus(' . string(dir) . ', 1)' .
+          \ after
+  endif
+endfunction
+
+let s:exec_paths = {}
+function! s:ExecPath() abort
+  if !has_key(s:exec_paths, g:fugitive_git_executable)
+    let s:exec_paths[g:fugitive_git_executable] = s:sub(system(g:fugitive_git_executable.' --exec-path'),'\n$','')
+  endif
+  return s:exec_paths[g:fugitive_git_executable]
+endfunction
+
+function! s:Subcommands() abort
+  let exec_path = s:ExecPath()
+  return map(s:GlobComplete(exec_path.'/git-', '*', 1),'substitute(v:val,"\\.exe$","","")')
+endfunction
+
+let s:aliases = {}
+function! s:Aliases(dir) abort
+  let dir_key = len(a:dir) ? a:dir : '_'
+  if !has_key(s:aliases, dir_key)
+    let s:aliases[dir_key] = {}
+    let lines = s:NullError([a:dir, 'config', '-z', '--get-regexp', '^alias[.]'])[0]
+    for line in lines
+      let s:aliases[dir_key][matchstr(line, '\.\zs.\{-}\ze\n')] = matchstr(line, '\n\zs.*')
+    endfor
+  endif
+  return s:aliases[dir_key]
+endfunction
+
+function! fugitive#Complete(lead, ...) abort
+  let dir = a:0 == 1 ? a:1 : a:0 >= 3 ? a:3 : s:Dir()
+  let root = a:0 >= 4 ? a:4 : s:Tree(s:Dir())
+  let pre = a:0 > 1 ? strpart(a:1, 0, a:2) : ''
+  let subcmd = matchstr(pre, '\u\w*[! ] *\zs[[:alnum:]-]\+\ze ')
+  if empty(subcmd)
+    let results = sort(s:Subcommands() + keys(s:Aliases(dir)))
+  elseif a:0 ==# 2 && subcmd =~# '^\%(commit\|revert\|push\|fetch\|pull\|merge\|rebase\)$'
+    let cmdline = substitute(a:1, '\u\w*\([! ] *\)' . subcmd, 'G' . subcmd, '')
+    let caps_subcmd = substitute(subcmd, '\%(^\|-\)\l', '\u&', 'g')
+    return fugitive#{caps_subcmd}Complete(a:lead, cmdline, a:2 + len(cmdline) - len(a:1), dir, root)
+  elseif pre =~# ' -- '
+    return fugitive#CompletePath(a:lead, a:1, a:2, dir, root)
+  elseif a:lead =~# '^-'
+    let results = split(s:ChompDefault('', dir, subcmd, '--git-completion-helper'), ' ')
+  else
+    return fugitive#CompleteObject(a:lead, a:1, a:2, dir, root)
+  endif
+  return filter(results, 'strpart(v:val, 0, strlen(a:lead)) ==# a:lead')
+endfunction
+
+function! fugitive#CompleteForWorkingDir(A, L, P, ...) abort
+  let path = a:0 ? a:1 : getcwd()
+  return fugitive#Complete(a:A, a:L, a:P, FugitiveExtractGitDir(path), path)
+endfunction
+
+" Section: :Gcd, :Glcd
+
+function! fugitive#CdComplete(A, L, P) abort
+  return filter(fugitive#CompletePath(a:A), 'v:val =~# "/$"')
+endfunction
+
+function! fugitive#Cd(path, ...) abort
+  let path = substitute(a:path, '^:/:\=\|^:(\%(top\|top,literal\|literal,top\|literal\))', '', '')
+  if path !~# '^/\|^\a\+:\|^\.\.\=\%(/\|$\)'
+    let dir = s:Dir()
+    exe s:DirCheck(dir)
+    let path = (empty(s:Tree(dir)) ? dir : s:Tree(dir)) . '/' . path
+  endif
+  return (a:0 && a:1 ? 'lcd ' : 'cd ') . s:fnameescape(FugitiveVimPath(path))
+endfunction
+
+" Section: :Gstatus
+
+function! s:StatusCommand(line1, line2, range, count, bang, mods, reg, arg, args, ...) abort
+  let dir = a:0 ? a:1 : s:Dir()
+  exe s:DirCheck(dir)
+  try
+    let mods = s:Mods(a:mods, &splitbelow ? 'botright' : 'topleft')
+    let file = fugitive#Find(':', dir)
+    let arg = ' +setl\ foldmethod=syntax\ foldlevel=1\|let\ w:fugitive_status=FugitiveGitDir() ' .
+          \ s:fnameescape(file)
+    for winnr in range(1, winnr('$'))
+      if s:cpath(file, fnamemodify(bufname(winbufnr(winnr)), ':p'))
+        if winnr == winnr()
+          call s:ReloadStatus()
+        else
+          call s:ExpireStatus(dir)
+          exe winnr . 'wincmd w'
+        endif
+        let w:fugitive_status = dir
+        1
+        return ''
+      endif
+    endfor
+    if a:count ==# 0
+      return mods . 'edit' . (a:bang ? '!' : '') . arg
+    elseif a:bang
+      return mods . 'pedit' . arg . '|wincmd P'
+    else
+      return mods . 'keepalt split' . arg
+    endif
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  return ''
+endfunction
+
+function! s:StageJump(offset, section, ...) abort
+  let line = search('^\%(' . a:section . '\)', 'nw')
+  if !line && a:0
+    let line = search('^\%(' . a:1 . '\)', 'nw')
+  endif
+  if line
+    exe line
+    if a:offset
+      for i in range(a:offset)
+        call search(s:file_commit_pattern . '\|^$', 'W')
+        if empty(getline('.')) && a:0 && getline(line('.') + 1) =~# '^\%(' . a:1 . '\)'
+          call search(s:file_commit_pattern . '\|^$', 'W')
+        endif
+        if empty(getline('.'))
+          return ''
+        endif
+      endfor
+      call s:StageReveal()
+    else
+      call s:StageReveal()
+      +
+    endif
+  endif
+  return ''
+endfunction
+
+function! s:StageSeek(info, fallback) abort
+  let info = a:info
+  if empty(info.section)
+    return a:fallback
+  endif
+  let line = search('^' . info.section, 'wn')
+  if !line
+    for section in get({'Staged': ['Unstaged', 'Untracked'], 'Unstaged': ['Untracked', 'Staged'], 'Untracked': ['Unstaged', 'Staged']}, info.section, [])
+      let line = search('^' . section, 'wn')
+      if line
+        return line + (info.index > 0 ? 1 : 0)
+      endif
+    endfor
+    return 1
+  endif
+  let i = 0
+  while len(getline(line))
+    let filename = matchstr(getline(line), '^[A-Z?] \zs.*')
+    if len(filename) &&
+          \ ((info.filename[-1:-1] ==# '/' && filename[0 : len(info.filename) - 1] ==# info.filename) ||
+          \ (filename[-1:-1] ==# '/' && filename ==# info.filename[0 : len(filename) - 1]) ||
+          \ filename ==# info.filename)
+      if info.offset < 0
+        return line
+      else
+        if getline(line+1) !~# '^@'
+          exe s:StageInline('show', line)
+        endif
+        if getline(line+1) !~# '^@'
+          return line
+        endif
+        let type = info.sigil ==# '-' ? '-' : '+'
+        let offset = -1
+        while offset < info.offset
+          let line += 1
+          if getline(line) =~# '^@'
+            let offset = +matchstr(getline(line), type . '\zs\d\+') - 1
+          elseif getline(line) =~# '^[ ' . type . ']'
+            let offset += 1
+          elseif getline(line) !~# '^[ @\+-]'
+            return line - 1
+          endif
+        endwhile
+        return line
+      endif
+    endif
+    let commit = matchstr(getline(line), '^\%(\%(\x\x\x\)\@!\l\+\s\+\)\=\zs[0-9a-f]\+')
+    if len(commit) && commit ==# info.commit
+      return line
+    endif
+    if i ==# info.index
+      let backup = line
+    endif
+    let i += getline(line) !~# '^[ @\+-]'
+    let line += 1
+  endwhile
+  return exists('backup') ? backup : line - 1
+endfunction
+
+function! s:DoAutocmdChanged(dir) abort
+  let dir = a:dir is# -2 ? '' : FugitiveGitDir(a:dir)
+  if empty(dir) || !exists('#User#FugitiveChanged') || exists('g:fugitive_event')
+    return ''
+  endif
+  try
+    let g:fugitive_event = dir
+    exe s:DoAutocmd('User FugitiveChanged')
+  finally
+    unlet! g:fugitive_event
+    " Force statusline reload with the buffer's Git dir
+    let &ro = &ro
+  endtry
+  return ''
+endfunction
+
+function! s:ReloadStatusBuffer(...) abort
+  if get(b:, 'fugitive_type', '') !=# 'index'
+    return ''
+  endif
+  let original_lnum = a:0 ? a:1 : line('.')
+  let info = s:StageInfo(original_lnum)
+  call fugitive#BufReadStatus()
+  call setpos('.', [0, s:StageSeek(info, original_lnum), 1, 0])
+  return ''
+endfunction
+
+function! s:ReloadStatus(...) abort
+  call s:ExpireStatus(-1)
+  call s:ReloadStatusBuffer(a:0 ? a:1 : line('.'))
+  exe s:DoAutocmdChanged(-1)
+  return ''
+endfunction
+
+let s:last_time = reltime()
+if !exists('s:last_times')
+  let s:last_times = {}
+endif
+
+function! s:ExpireStatus(bufnr) abort
+  if a:bufnr == -2
+    let s:head_cache = {}
+    let s:last_time = reltime()
+    return ''
+  endif
+  let dir = s:Dir(a:bufnr)
+  if len(dir)
+    let s:last_times[s:cpath(dir)] = reltime()
+    if has_key(s:head_cache, dir)
+      call remove(s:head_cache, dir)
+    endif
+  endif
+  return ''
+endfunction
+
+function! s:ReloadWinStatus(...) abort
+  if get(b:, 'fugitive_type', '') !=# 'index' || &modified
+    return
+  endif
+  if !exists('b:fugitive_reltime')
+    exe s:ReloadStatusBuffer()
+    return
+  endif
+  let t = b:fugitive_reltime
+  if reltimestr(reltime(s:last_time, t)) =~# '-\|\d\{10\}\.' ||
+        \ reltimestr(reltime(get(s:last_times, s:cpath(s:Dir()), t), t)) =~# '-\|\d\{10\}\.'
+    exe s:ReloadStatusBuffer()
+  endif
+endfunction
+
+function! s:ReloadTabStatus(...) abort
+  let mytab = tabpagenr()
+  let tab = a:0 ? a:1 : mytab
+  let winnr = 1
+  while winnr <= tabpagewinnr(tab, '$')
+    if getbufvar(tabpagebuflist(tab)[winnr-1], 'fugitive_type') ==# 'index'
+      execute 'tabnext '.tab
+      if winnr != winnr()
+        execute winnr.'wincmd w'
+        let restorewinnr = 1
+      endif
+      try
+        call s:ReloadWinStatus()
+      finally
+        if exists('restorewinnr')
+          unlet restorewinnr
+          wincmd p
+        endif
+        execute 'tabnext '.mytab
+      endtry
+    endif
+    let winnr += 1
+  endwhile
+  unlet! t:fugitive_reload_status
+endfunction
+
+function! fugitive#ReloadStatus(...) abort
+  call s:ExpireStatus(a:0 ? a:1 : -1)
+  if a:0 > 1 ? a:2 : 1
+    let t = reltime()
+    let t:fugitive_reload_status = t
+    for tabnr in exists('*settabvar') ? range(1, tabpagenr('$')) : []
+      call settabvar(tabnr, 'fugitive_reload_status', t)
+    endfor
+    call s:ReloadTabStatus()
+    exe s:DoAutocmdChanged(a:0 ? a:1 : -1)
+  else
+    call s:ReloadWinStatus()
+  endif
+  return ''
+endfunction
+
+function! fugitive#EfmDir(...) abort
+  let dir = matchstr(a:0 ? a:1 : &errorformat, '\c,%\\&\%(git\|fugitive\)_\=dir=\zs\%(\\.\|[^,]\)*')
+  let dir = substitute(dir, '%%', '%', 'g')
+  let dir = substitute(dir, '\\\ze[\,]', '', 'g')
+  return dir
+endfunction
+
+augroup fugitive_status
+  autocmd!
+  autocmd BufWritePost         * call fugitive#ReloadStatus(-1, 0)
+  autocmd ShellCmdPost,ShellFilterPost * nested call fugitive#ReloadStatus(-2, 0)
+  autocmd BufDelete * nested
+        \ if getbufvar(+expand('<abuf>'), 'buftype') ==# 'terminal' |
+        \   if !empty(FugitiveGitDir(+expand('<abuf>'))) |
+        \     call fugitive#ReloadStatus(+expand('<abuf>'), 1) |
+        \   else |
+        \     call fugitive#ReloadStatus(-2, 0) |
+        \  endif |
+        \ endif
+  autocmd QuickFixCmdPost make,lmake,[cl]file,[cl]getfile nested
+        \ call fugitive#ReloadStatus(fugitive#EfmDir(), 1)
+  if !has('win32')
+    autocmd FocusGained        * call fugitive#ReloadStatus(-2, 0)
+  endif
+  autocmd BufEnter index,index.lock
+        \ call s:ReloadWinStatus()
+  autocmd TabEnter *
+        \ if exists('t:fugitive_reload_status') |
+        \    call s:ReloadTabStatus() |
+        \ endif
+augroup END
+
+function! s:StageInfo(...) abort
+  let lnum = a:0 ? a:1 : line('.')
+  let sigil = matchstr(getline(lnum), '^[ @\+-]')
+  let offset = -1
+  if len(sigil)
+    let type = sigil ==# '-' ? '-' : '+'
+    while lnum > 0 && getline(lnum) !~# '^@'
+      if getline(lnum) =~# '^[ '.type.']'
+        let offset += 1
+      endif
+      let lnum -= 1
+    endwhile
+    let offset += matchstr(getline(lnum), type.'\zs\d\+')
+    while getline(lnum) =~# '^[ @\+-]'
+      let lnum -= 1
+    endwhile
+  endif
+  let slnum = lnum + 1
+  let section = ''
+  let index = 0
+  while len(getline(slnum - 1)) && empty(section)
+    let slnum -= 1
+    let section = matchstr(getline(slnum), '^\u\l\+\ze.* (\d\+)$')
+    if empty(section) && getline(slnum) !~# '^[ @\+-]'
+      let index += 1
+    endif
+  endwhile
+  let text = matchstr(getline(lnum), '^[A-Z?] \zs.*')
+  return {'section': section,
+        \ 'heading': getline(slnum),
+        \ 'sigil': sigil,
+        \ 'offset': offset,
+        \ 'filename': text,
+        \ 'relative': reverse(split(text, ' -> ')),
+        \ 'paths': map(reverse(split(text, ' -> ')), 's:Tree() . "/" . v:val'),
+        \ 'commit': matchstr(getline(lnum), '^\%(\%(\x\x\x\)\@!\l\+\s\+\)\=\zs[0-9a-f]\{4,\}\ze '),
+        \ 'status': matchstr(getline(lnum), '^[A-Z?]\ze \|^\%(\x\x\x\)\@!\l\+\ze [0-9a-f]'),
+        \ 'sub': get(get(get(b:fugitive_files, section, {}), text, {}), 'sub', ''),
+        \ 'index': index}
+endfunction
+
+function! s:Selection(arg1, ...) abort
+  if a:arg1 ==# 'n'
+    let arg1 = line('.')
+    let arg2 = -v:count
+  elseif a:arg1 ==# 'v'
+    let arg1 = line("'<")
+    let arg2 = line("'>")
+  else
+    let arg1 = a:arg1
+    let arg2 = a:0 ? a:1 : 0
+  endif
+  let first = arg1
+  if arg2 < 0
+    let last = first - arg2 - 1
+  elseif arg2 > 0
+    let last = arg2
+  else
+    let last = first
+  endif
+  while getline(first) =~# '^$\|^[A-Z][a-z]'
+    let first += 1
+  endwhile
+  if first > last || &filetype !=# 'fugitive'
+    return []
+  endif
+  let flnum = first
+  while getline(flnum) =~# '^[ @\+-]'
+    let flnum -= 1
+  endwhile
+  let slnum = flnum + 1
+  let section = ''
+  let index = 0
+  while len(getline(slnum - 1)) && empty(section)
+    let slnum -= 1
+    let heading = matchstr(getline(slnum), '^\u\l\+.* (\d\+)$')
+    if empty(heading) && getline(slnum) !~# '^[ @\+-]'
+      let index += 1
+    endif
+  endwhile
+  let results = []
+  let template = {
+        \ 'heading': heading,
+        \ 'section': matchstr(heading, '^\u\l\+\ze.* (\d\+)$'),
+        \ 'filename': '',
+        \ 'relative': [],
+        \ 'paths': [],
+        \ 'commit': '',
+        \ 'status': '',
+        \ 'patch': 0,
+        \ 'index': index}
+  let line = getline(flnum)
+  let lnum = first - (arg1 == flnum ? 0 : 1)
+  let root = s:Tree() . '/'
+  while lnum <= last
+    if line =~# '^\u\l\+\ze.* (\d\+)$'
+      let template.heading = getline(lnum)
+      let template.section = matchstr(template.heading, '^\u\l\+\ze.* (\d\+)$')
+      let template.index = 0
+    elseif line =~# '^[ @\+-]'
+      let template.index -= 1
+      if !results[-1].patch
+        let results[-1].patch = lnum
+      endif
+      let results[-1].lnum = lnum
+    elseif line =~# '^[A-Z?] '
+      let filename = matchstr(line, '^[A-Z?] \zs.*')
+      call add(results, extend(deepcopy(template), {
+            \ 'lnum': lnum,
+            \ 'filename': filename,
+            \ 'relative': reverse(split(filename, ' -> ')),
+            \ 'paths': map(reverse(split(filename, ' -> ')), 'root . v:val'),
+            \ 'status': matchstr(line, '^[A-Z?]'),
+            \ }))
+    elseif line =~# '^\x\x\x\+ '
+      call add(results, extend({
+            \ 'lnum': lnum,
+            \ 'commit': matchstr(line, '^\x\x\x\+'),
+            \ }, template, 'keep'))
+    elseif line =~# '^\l\+ \x\x\x\+ '
+      call add(results, extend({
+            \ 'lnum': lnum,
+            \ 'commit': matchstr(line, '^\l\+ \zs\x\x\x\+'),
+            \ 'status': matchstr(line, '^\l\+'),
+            \ }, template, 'keep'))
+    endif
+    let lnum += 1
+    let template.index += 1
+    let line = getline(lnum)
+  endwhile
+  if len(results) && results[0].patch && arg2 == 0
+    while getline(results[0].patch) =~# '^[ \+-]'
+      let results[0].patch -= 1
+    endwhile
+    while getline(results[0].lnum + 1) =~# '^[ \+-]'
+      let results[0].lnum += 1
+    endwhile
+  endif
+  return results
+endfunction
+
+function! s:StageArgs(visual) abort
+  let commits = []
+  let paths = []
+  for record in s:Selection(a:visual ? 'v' : 'n')
+    if len(record.commit)
+      call add(commits, record.commit)
+    endif
+    call extend(paths, record.paths)
+  endfor
+  if s:cpath(s:Tree(), getcwd())
+    call map(paths, 'fugitive#Path(v:val, "./")')
+  endif
+  return join(map(commits + paths, 's:fnameescape(v:val)'), ' ')
+endfunction
+
+function! s:Do(action, visual) abort
+  let line = getline('.')
+  let reload = 0
+  if !a:visual && !v:count && line =~# '^[A-Z][a-z]'
+    let header = matchstr(line, '^\S\+\ze:')
+    if len(header) && exists('*s:Do' . a:action . header . 'Header')
+      let reload = s:Do{a:action}{header}Header(matchstr(line, ': \zs.*')) > 0
+    else
+      let section = matchstr(line, '^\S\+')
+      if exists('*s:Do' . a:action . section . 'Heading')
+        let reload = s:Do{a:action}{section}Heading(line) > 0
+      endif
+    endif
+    return reload ? s:ReloadStatus() : ''
+  endif
+  let selection = s:Selection(a:visual ? 'v' : 'n')
+  if empty(selection)
+    return ''
+  endif
+  call filter(selection, 'v:val.section ==# selection[0].section')
+  let status = 0
+  let err = ''
+  try
+    for record in selection
+      if exists('*s:Do' . a:action . record.section)
+        let status = s:Do{a:action}{record.section}(record)
+      else
+        continue
+      endif
+      if !status
+        return ''
+      endif
+      let reload = reload || (status > 0)
+    endfor
+    if status < 0
+      execute record.lnum + 1
+    endif
+    let success = 1
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  finally
+    if reload
+      execute s:ReloadStatus()
+    endif
+    if exists('success')
+      call s:StageReveal()
+    endif
+  endtry
+  return ''
+endfunction
+
+function! s:StageReveal() abort
+  exe 'normal! zv'
+  let begin = line('.')
+  if getline(begin) =~# '^@'
+    let end = begin + 1
+    while getline(end) =~# '^[ \+-]'
+      let end += 1
+    endwhile
+  elseif getline(begin) =~# '^commit '
+    let end = begin
+    while end < line('$') && getline(end + 1) !~# '^commit '
+      let end += 1
+    endwhile
+  elseif getline(begin) =~# s:section_pattern
+    let end = begin
+    while len(getline(end + 1))
+      let end += 1
+    endwhile
+  endif
+  if exists('end')
+    while line('.') > line('w0') + &scrolloff && end > line('w$')
+      execute "normal! \<C-E>"
+    endwhile
+  endif
+endfunction
+
+let s:file_pattern = '^[A-Z?] .\|^diff --'
+let s:file_commit_pattern = s:file_pattern . '\|^\%(\l\{3,\} \)\=[0-9a-f]\{4,\} '
+let s:item_pattern = s:file_commit_pattern . '\|^@@'
+
+function! s:NextHunk(count) abort
+  if &filetype ==# 'fugitive' && getline('.') =~# s:file_pattern
+    exe s:StageInline('show')
+  endif
+  for i in range(a:count)
+    if &filetype ==# 'fugitive'
+      call search(s:file_pattern . '\|^@', 'W')
+      if getline('.') =~# s:file_pattern
+        exe s:StageInline('show')
+        if getline(line('.') + 1) =~# '^@'
+          +
+        endif
+      endif
+    else
+      call search('^@@', 'W')
+    endif
+  endfor
+  call s:StageReveal()
+  return '.'
+endfunction
+
+function! s:PreviousHunk(count) abort
+  for i in range(a:count)
+    if &filetype ==# 'fugitive'
+      let lnum = search(s:file_pattern . '\|^@','Wbn')
+      call s:StageInline('show', lnum)
+      call search('^? .\|^@','Wb')
+    else
+      call search('^@@', 'Wb')
+    endif
+  endfor
+  call s:StageReveal()
+  return '.'
+endfunction
+
+function! s:NextFile(count) abort
+  for i in range(a:count)
+    exe s:StageInline('hide')
+    if !search(s:file_pattern, 'W')
+      break
+    endif
+  endfor
+  exe s:StageInline('hide')
+  return '.'
+endfunction
+
+function! s:PreviousFile(count) abort
+  exe s:StageInline('hide')
+  for i in range(a:count)
+    if !search(s:file_pattern, 'Wb')
+      break
+    endif
+    exe s:StageInline('hide')
+  endfor
+  return '.'
+endfunction
+
+function! s:NextItem(count) abort
+  for i in range(a:count)
+    if !search(s:item_pattern, 'W') && getline('.') !~# s:item_pattern
+      call search('^commit ', 'W')
+    endif
+  endfor
+  call s:StageReveal()
+  return '.'
+endfunction
+
+function! s:PreviousItem(count) abort
+  for i in range(a:count)
+    if !search(s:item_pattern, 'Wbe') && getline('.') !~# s:item_pattern
+      call search('^commit ', 'Wbe')
+    endif
+  endfor
+  call s:StageReveal()
+  return '.'
+endfunction
+
+let s:section_pattern = '^[A-Z][a-z][^:]*$'
+let s:section_commit_pattern = s:section_pattern . '\|^commit '
+
+function! s:NextSection(count) abort
+  let orig = line('.')
+  if getline('.') !~# '^commit '
+    -
+  endif
+  for i in range(a:count)
+    if !search(s:section_commit_pattern, 'W')
+      break
+    endif
+  endfor
+  if getline('.') =~# s:section_commit_pattern
+    call s:StageReveal()
+    return getline('.') =~# s:section_pattern ? '+' : ':'
+  else
+    return orig
+  endif
+endfunction
+
+function! s:PreviousSection(count) abort
+  let orig = line('.')
+  if getline('.') !~# '^commit '
+    -
+  endif
+  for i in range(a:count)
+    if !search(s:section_commit_pattern . '\|\%^', 'bW')
+      break
+    endif
+  endfor
+  if getline('.') =~# s:section_commit_pattern || line('.') == 1
+    call s:StageReveal()
+    return getline('.') =~# s:section_pattern ? '+' : ':'
+  else
+    return orig
+  endif
+endfunction
+
+function! s:NextSectionEnd(count) abort
+  +
+  if empty(getline('.'))
+    +
+  endif
+  for i in range(a:count)
+    if !search(s:section_commit_pattern, 'W')
+      return '$'
+    endif
+  endfor
+  return search('^.', 'Wb')
+endfunction
+
+function! s:PreviousSectionEnd(count) abort
+  let old = line('.')
+  for i in range(a:count)
+    if search(s:section_commit_pattern, 'Wb') <= 1
+      exe old
+      if i
+        break
+      else
+        return ''
+      endif
+    endif
+    let old = line('.')
+  endfor
+  return search('^.', 'Wb')
+endfunction
+
+function! s:PatchSearchExpr(reverse) abort
+  let line = getline('.')
+  if col('.') ==# 1 && line =~# '^[+-]'
+    if line =~# '^[+-]\{3\} '
+      let pattern = '^[+-]\{3\} ' . substitute(escape(strpart(line, 4), '^$.*[]~\'), '^\w/', '\\w/', '') . '$'
+    else
+      let pattern = '^[+-]\s*' . escape(substitute(strpart(line, 1), '^\s*\|\s*$', '', ''), '^$.*[]~\') . '\s*$'
+    endif
+    if a:reverse
+      return '?' . escape(pattern, '/?') . "\<CR>"
+    else
+      return '/' . escape(pattern, '/') . "\<CR>"
+    endif
+  endif
+  return a:reverse ? '#' : '*'
+endfunction
+
+function! s:StageInline(mode, ...) abort
+  if &filetype !=# 'fugitive'
+    return ''
+  endif
+  let lnum1 = a:0 ? a:1 : line('.')
+  let lnum = lnum1 + 1
+  if a:0 > 1 && a:2 == 0 && lnum1 == 1
+    let lnum = line('$') - 1
+  elseif a:0 > 1 && a:2 == 0
+    let info = s:StageInfo(lnum - 1)
+    if empty(info.paths) && len(info.section)
+      while len(getline(lnum))
+        let lnum += 1
+      endwhile
+    endif
+  elseif a:0 > 1
+    let lnum += a:2 - 1
+  endif
+  while lnum > lnum1
+    let lnum -= 1
+    while lnum > 0 && getline(lnum) =~# '^[ @\+-]'
+      let lnum -= 1
+    endwhile
+    let info = s:StageInfo(lnum)
+    if !has_key(b:fugitive_diff, info.section)
+      continue
+    endif
+    if getline(lnum + 1) =~# '^[ @\+-]'
+      let lnum2 = lnum + 1
+      while getline(lnum2 + 1) =~# '^[ @\+-]'
+        let lnum2 += 1
+      endwhile
+      if a:mode !=# 'show'
+        setlocal modifiable noreadonly
+        exe 'silent keepjumps ' . (lnum + 1) . ',' . lnum2 . 'delete _'
+        call remove(b:fugitive_expanded[info.section], info.filename)
+        setlocal nomodifiable readonly nomodified
+      endif
+      continue
+    endif
+    if !has_key(b:fugitive_diff, info.section) || info.status !~# '^[ADMRU]$' || a:mode ==# 'hide'
+      continue
+    endif
+    let mode = ''
+    let diff = []
+    let index = 0
+    let start = -1
+    for line in b:fugitive_diff[info.section]
+      if mode ==# 'await' && line[0] ==# '@'
+        let mode = 'capture'
+      endif
+      if mode !=# 'head' && line !~# '^[ @\+-]'
+        if len(diff)
+          break
+        endif
+        let start = index
+        let mode = 'head'
+      elseif mode ==# 'head' && line =~# '^diff '
+        let start = index
+      elseif mode ==# 'head' && substitute(line, "\t$", '', '') ==# '--- ' . info.relative[-1]
+        let mode = 'await'
+      elseif mode ==# 'head' && substitute(line, "\t$", '', '') ==# '+++ ' . info.relative[0]
+        let mode = 'await'
+      elseif mode ==# 'capture'
+        call add(diff, line)
+      elseif line[0] ==# '@'
+        let mode = ''
+      endif
+      let index += 1
+    endfor
+    if len(diff)
+      setlocal modifiable noreadonly
+      silent call append(lnum, diff)
+      let b:fugitive_expanded[info.section][info.filename] = [start, len(diff)]
+      setlocal nomodifiable readonly nomodified
+      if foldclosed(lnum+1) > 0
+        silent exe (lnum+1) . ',' . (lnum+len(diff)) . 'foldopen!'
+      endif
+    endif
+  endwhile
+  return lnum
+endfunction
+
+function! s:NextExpandedHunk(count) abort
+  for i in range(a:count)
+    call s:StageInline('show', line('.'), 1)
+    call search(s:file_pattern . '\|^@','W')
+  endfor
+  return '.'
+endfunction
+
+function! s:StageDiff(diff) abort
+  let lnum = line('.')
+  let info = s:StageInfo(lnum)
+  let prefix = info.offset > 0 ? '+' . info.offset : ''
+  if info.sub =~# '^S'
+    if info.section ==# 'Staged'
+      return 'Git --paginate diff --no-ext-diff --submodule=log --cached -- ' . info.paths[0]
+    elseif info.sub =~# '^SC'
+      return 'Git --paginate diff --no-ext-diff --submodule=log -- ' . info.paths[0]
+    else
+      return 'Git --paginate diff --no-ext-diff --submodule=diff -- ' . info.paths[0]
+    endif
+  elseif empty(info.paths) && info.section ==# 'Staged'
+    return 'Git --paginate diff --no-ext-diff --cached'
+  elseif empty(info.paths)
+    return 'Git --paginate diff --no-ext-diff'
+  elseif len(info.paths) > 1
+    execute 'Gedit' . prefix s:fnameescape(':0:' . info.paths[0])
+    return a:diff . '! HEAD:'.s:fnameescape(info.paths[1])
+  elseif info.section ==# 'Staged' && info.sigil ==# '-'
+    execute 'Gedit' prefix s:fnameescape(':0:'.info.paths[0])
+    return a:diff . '! :0:%'
+  elseif info.section ==# 'Staged'
+    execute 'Gedit' prefix s:fnameescape(':0:'.info.paths[0])
+    return a:diff . '! @:%'
+  elseif info.sigil ==# '-'
+    execute 'Gedit' prefix s:fnameescape(':0:'.info.paths[0])
+    return a:diff . '! :(top)%'
+  else
+    execute 'Gedit' prefix s:fnameescape(':(top)'.info.paths[0])
+    return a:diff . '!'
+  endif
+endfunction
+
+function! s:StageDiffEdit() abort
+  let info = s:StageInfo(line('.'))
+  let arg = (empty(info.paths) ? s:Tree() : info.paths[0])
+  if info.section ==# 'Staged'
+    return 'Git --paginate diff --no-ext-diff --cached '.s:fnameescape(arg)
+  elseif info.status ==# '?'
+    call s:TreeChomp('add', '--intent-to-add', '--', arg)
+    return s:ReloadStatus()
+  else
+    return 'Git --paginate diff --no-ext-diff '.s:fnameescape(arg)
+  endif
+endfunction
+
+function! s:StageApply(info, reverse, extra) abort
+  if a:info.status ==# 'R'
+    call s:throw('fugitive: patching renamed file not yet supported')
+  endif
+  let cmd = ['apply', '-p0', '--recount'] + a:extra
+  let info = a:info
+  let start = info.patch
+  let end = info.lnum
+  let lines = getline(start, end)
+  if empty(filter(copy(lines), 'v:val =~# "^[+-]"'))
+    return -1
+  endif
+  while getline(end) =~# '^[-+\ ]'
+    let end += 1
+    if getline(end) =~# '^[' . (a:reverse ? '+' : '-') . '\ ]'
+      call add(lines, ' ' . getline(end)[1:-1])
+    endif
+  endwhile
+  while start > 0 && getline(start) !~# '^@'
+    let start -= 1
+    if getline(start) =~# '^[' . (a:reverse ? '+' : '-') . ' ]'
+      call insert(lines, ' ' . getline(start)[1:-1])
+    elseif getline(start) =~# '^@'
+      call insert(lines, getline(start))
+    endif
+  endwhile
+  if start == 0
+    throw 'fugitive: cold not find hunk'
+  elseif getline(start) !~# '^@@ '
+    throw 'fugitive: cannot apply conflict hunk'
+  endif
+  let i = b:fugitive_expanded[info.section][info.filename][0]
+  let head = []
+  while get(b:fugitive_diff[info.section], i, '@') !~# '^@'
+    let line = b:fugitive_diff[info.section][i]
+    if line ==# '--- /dev/null'
+      call add(head, '--- ' . get(b:fugitive_diff[info.section], i + 1, '')[4:-1])
+    elseif line !~# '^new file '
+      call add(head, line)
+    endif
+    let i += 1
+  endwhile
+  call extend(lines, head, 'keep')
+  let temp = tempname()
+  call writefile(lines, temp)
+  if a:reverse
+    call add(cmd, '--reverse')
+  endif
+  call extend(cmd, ['--', temp])
+  let [output, exec_error] = s:ChompError(cmd)
+  if !exec_error
+    return 1
+  endif
+  call s:throw(output)
+endfunction
+
+function! s:StageDelete(lnum1, lnum2, count) abort
+  let restore = []
+  let err = ''
+  let did_conflict_err = 0
+  try
+    for info in s:Selection(a:lnum1, a:lnum2)
+      if empty(info.paths)
+        continue
+      endif
+      let sub = get(get(get(b:fugitive_files, info.section, {}), info.filename, {}), 'sub')
+      if sub =~# '^S'
+        if info.status ==# 'A'
+          continue
+        endif
+        if info.section ==# 'Staged'
+          call s:TreeChomp('reset', '--', info.paths[0])
+        endif
+        if info.status =~# '[MD]'
+          call s:TreeChomp('submodule', 'update', '--', info.paths[0])
+          call add(restore, ':Git -C ' . info.relative[0] . ' checkout -')
+        endif
+        continue
+      endif
+      if info.status ==# 'D'
+        let undo = 'GRemove'
+      elseif info.paths[0] =~# '/$'
+        let err .= '|echoerr ' . string('fugitive: will not delete directory ' . string(info.relative[0]))
+        break
+      else
+        let undo = 'Gread ' . s:TreeChomp('hash-object', '-w', '--', info.paths[0])[0:10]
+      endif
+      if info.patch
+        call s:StageApply(info, 1, info.section ==# 'Staged' ? ['--index'] : [])
+      elseif info.status ==# '?'
+        call s:TreeChomp('clean', '-f', '--', info.paths[0])
+      elseif a:count == 2
+        if get(b:fugitive_files['Staged'], info.filename, {'status': ''}).status ==# 'D'
+          call delete(FugitiveVimPath(info.paths[0]))
+        else
+          call s:TreeChomp('checkout', '--ours', '--', info.paths[0])
+        endif
+      elseif a:count == 3
+        if get(b:fugitive_files['Unstaged'], info.filename, {'status': ''}).status ==# 'D'
+          call delete(FugitiveVimPath(info.paths[0]))
+        else
+          call s:TreeChomp('checkout', '--theirs', '--', info.paths[0])
+        endif
+      elseif info.status =~# '[ADU]' &&
+            \ get(b:fugitive_files[info.section ==# 'Staged' ? 'Unstaged' : 'Staged'], info.filename, {'status': ''}).status =~# '[AU]'
+        if get(g:, 'fugitive_conflict_x', 0)
+          call s:TreeChomp('checkout', info.section ==# 'Unstaged' ? '--ours' : '--theirs', '--', info.paths[0])
+        else
+          if !did_conflict_err
+            let err .= '|echoerr "Use 2X for --ours or 3X for --theirs"'
+            let did_conflict_err = 1
+          endif
+          continue
+        endif
+      elseif info.status ==# 'U'
+        call delete(FugitiveVimPath(info.paths[0]))
+      elseif info.status ==# 'A'
+        call s:TreeChomp('rm', '-f', '--', info.paths[0])
+      elseif info.section ==# 'Unstaged'
+        call s:TreeChomp('checkout', '--', info.paths[0])
+      else
+        call s:TreeChomp('checkout', 'HEAD^{}', '--', info.paths[0])
+      endif
+      if len(undo)
+        call add(restore, ':Gsplit ' . s:fnameescape(info.relative[0]) . '|' . undo)
+      endif
+    endfor
+  catch /^fugitive:/
+    let err .= '|echoerr ' . string(v:exception)
+  endtry
+  if empty(restore)
+    return err[1:-1]
+  endif
+  exe s:ReloadStatus()
+  call s:StageReveal()
+  if len(restore)
+    return 'checktime|redraw|echomsg ' . string('To restore, ' . join(restore, '|')) . err
+  else
+    return 'checktime|redraw' . err
+  endif
+endfunction
+
+function! s:StageIgnore(lnum1, lnum2, count) abort
+  let paths = []
+  for info in s:Selection(a:lnum1, a:lnum2)
+    call extend(paths, info.relative)
+  endfor
+  call map(paths, '"/" . v:val')
+  exe 'Gsplit' (a:count ? '.gitignore' : '.git/info/exclude')
+  let last = line('$')
+  if last == 1 && empty(getline(1))
+    call setline(last, paths)
+  else
+    call append(last, paths)
+    exe last + 1
+  endif
+  return ''
+endfunction
+
+function! s:DoToggleHeadHeader(value) abort
+  exe 'edit' s:fnameescape(s:Dir())
+  call search('\C^index$', 'wc')
+endfunction
+
+function! s:DoToggleHelpHeader(value) abort
+  exe 'help fugitive-map'
+endfunction
+
+function! s:DoStagePushHeader(value) abort
+  let remote = matchstr(a:value, '\zs[^/]\+\ze/')
+  if empty(remote)
+    let remote = '.'
+  endif
+  let branch = matchstr(a:value, '\%([^/]\+/\)\=\zs\S\+')
+  call feedkeys(':Git push ' . remote . ' ' . branch)
+endfunction
+
+function! s:DoTogglePushHeader(value) abort
+  return s:DoStagePushHeader(a:value)
+endfunction
+
+function! s:DoStageUnpushedHeading(heading) abort
+  let remote = matchstr(a:heading, 'to \zs[^/]\+\ze/')
+  if empty(remote)
+    let remote = '.'
+  endif
+  let branch = matchstr(a:heading, 'to \%([^/]\+/\)\=\zs\S\+')
+  call feedkeys(':Git push ' . remote . ' ' . 'HEAD:' . 'refs/heads/' . branch)
+endfunction
+
+function! s:DoToggleUnpushedHeading(heading) abort
+  return s:DoStageUnpushedHeading(a:heading)
+endfunction
+
+function! s:DoStageUnpushed(record) abort
+  let remote = matchstr(a:record.heading, 'to \zs[^/]\+\ze/')
+  if empty(remote)
+    let remote = '.'
+  endif
+  let branch = matchstr(a:record.heading, 'to \%([^/]\+/\)\=\zs\S\+')
+  call feedkeys(':Git push ' . remote . ' ' . a:record.commit . ':' . 'refs/heads/' . branch)
+endfunction
+
+function! s:DoToggleUnpushed(record) abort
+  return s:DoStageUnpushed(a:record)
+endfunction
+
+function! s:DoUnstageUnpulledHeading(heading) abort
+  call feedkeys(':Git rebase')
+endfunction
+
+function! s:DoToggleUnpulledHeading(heading) abort
+  call s:DoUnstageUnpulledHeading(a:heading)
+endfunction
+
+function! s:DoUnstageUnpulled(record) abort
+  call feedkeys(':Git rebase ' . a:record.commit)
+endfunction
+
+function! s:DoToggleUnpulled(record) abort
+  call s:DoUnstageUnpulled(a:record)
+endfunction
+
+function! s:DoUnstageUnpushed(record) abort
+  call feedkeys(':Git -c sequence.editor=true rebase --interactive --autosquash ' . a:record.commit . '^')
+endfunction
+
+function! s:DoToggleStagedHeading(...) abort
+  call s:TreeChomp('reset', '-q')
+  return 1
+endfunction
+
+function! s:DoUnstageStagedHeading(heading) abort
+  return s:DoToggleStagedHeading(a:heading)
+endfunction
+
+function! s:DoToggleUnstagedHeading(...) abort
+  call s:TreeChomp('add', '-u')
+  return 1
+endfunction
+
+function! s:DoStageUnstagedHeading(heading) abort
+  return s:DoToggleUnstagedHeading(a:heading)
+endfunction
+
+function! s:DoToggleUntrackedHeading(...) abort
+  call s:TreeChomp('add', '.')
+  return 1
+endfunction
+
+function! s:DoStageUntrackedHeading(heading) abort
+  return s:DoToggleUntrackedHeading(a:heading)
+endfunction
+
+function! s:DoToggleStaged(record) abort
+  if a:record.patch
+    return s:StageApply(a:record, 1, ['--cached'])
+  else
+    call s:TreeChomp(['reset', '-q', '--'] + a:record.paths)
+    return 1
+  endif
+endfunction
+
+function! s:DoUnstageStaged(record) abort
+  return s:DoToggleStaged(a:record)
+endfunction
+
+function! s:DoToggleUnstaged(record) abort
+  if a:record.patch
+    return s:StageApply(a:record, 0, ['--cached'])
+  else
+    call s:TreeChomp(['add', '-A', '--'] + a:record.paths)
+    return 1
+  endif
+endfunction
+
+function! s:DoStageUnstaged(record) abort
+  return s:DoToggleUnstaged(a:record)
+endfunction
+
+function! s:DoUnstageUnstaged(record) abort
+  if a:record.status ==# 'A'
+    call s:TreeChomp(['reset', '-q', '--'] + a:record.paths)
+    return 1
+  else
+    return -1
+  endif
+endfunction
+
+function! s:DoToggleUntracked(record) abort
+  call s:TreeChomp(['add', '--'] + a:record.paths)
+  return 1
+endfunction
+
+function! s:DoStageUntracked(record) abort
+  return s:DoToggleUntracked(a:record)
+endfunction
+
+function! s:StagePatch(lnum1,lnum2) abort
+  let add = []
+  let reset = []
+  let intend = []
+
+  for lnum in range(a:lnum1,a:lnum2)
+    let info = s:StageInfo(lnum)
+    if empty(info.paths) && info.section ==# 'Staged'
+      return 'Git reset --patch'
+    elseif empty(info.paths) && info.section ==# 'Unstaged'
+      return 'Git add --patch'
+    elseif empty(info.paths) && info.section ==# 'Untracked'
+      return 'Git add --interactive'
+    elseif empty(info.paths)
+      continue
+    endif
+    execute lnum
+    if info.section ==# 'Staged'
+      let reset += info.relative
+    elseif info.section ==# 'Untracked'
+      let intend += info.paths
+    elseif info.status !~# '^D'
+      let add += info.relative
+    endif
+  endfor
+  try
+    if !empty(intend)
+      call s:TreeChomp(['add', '--intent-to-add', '--'] + intend)
+    endif
+    if !empty(add)
+      execute "Git add --patch -- ".join(map(add,'s:fnameescape(v:val)'))
+    endif
+    if !empty(reset)
+      execute "Git reset --patch -- ".join(map(reset,'s:fnameescape(v:val)'))
+    endif
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  return s:ReloadStatus()
+endfunction
+
+" Section: :Git commit, :Git revert
+
+function! s:CommitInteractive(line1, line2, range, bang, mods, options, patch) abort
+  let status = s:StatusCommand(a:line1, a:line2, a:range, a:line2, a:bang, a:mods, '', '', [], a:options.dir)
+  let status = len(status) ? status . '|' : ''
+  if a:patch
+    return status . 'if search("^Unstaged")|exe "normal >"|exe "+"|endif'
+  else
+    return status . 'if search("^Untracked\\|^Unstaged")|exe "+"|endif'
+  endif
+endfunction
+
+function! s:CommitSubcommand(line1, line2, range, bang, mods, options) abort
+  let argv = copy(a:options.subcommand_args)
+  let i = 0
+  while get(argv, i, '--') !=# '--'
+    if argv[i] =~# '^-[apzsneiovq].'
+      call insert(argv, argv[i][0:1])
+      let argv[i+1] = '-' . argv[i+1][2:-1]
+    else
+      let i += 1
+    endif
+  endwhile
+  if s:HasOpt(argv, '-i', '--interactive')
+    return s:CommitInteractive(a:line1, a:line2, a:range, a:bang, a:mods, a:options, 0)
+  elseif s:HasOpt(argv, '-p', '--patch')
+    return s:CommitInteractive(a:line1, a:line2, a:range, a:bang, a:mods, a:options, 1)
+  else
+    return {}
+  endif
+endfunction
+
+function! s:RevertSubcommand(line1, line2, range, bang, mods, options) abort
+  return {'insert_args': ['--edit']}
+endfunction
+
+function! fugitive#CommitComplete(A, L, P, ...) abort
+  let dir = a:0 ? a:1 : s:Dir()
+  if a:A =~# '^--fixup=\|^--squash='
+    let commits = s:LinesError([dir, 'log', '--pretty=format:%s', '@{upstream}..'])[0]
+    let pre = matchstr(a:A, '^--\w*=''\=') . ':/^'
+    if pre =~# "'"
+      call map(commits, 'pre . string(tr(v:val, "|\"^$*[]", "......."))[1:-1]')
+      call filter(commits, 'strpart(v:val, 0, strlen(a:A)) ==# a:A')
+      return commits
+    else
+      return s:FilterEscape(map(commits, 'pre . tr(v:val, "\\ !^$*?[]()''\"`&;<>|#", "....................")'), a:A)
+    endif
+  else
+    return s:CompleteSub('commit', a:A, a:L, a:P, function('fugitive#CompletePath'), a:000)
+  endif
+  return []
+endfunction
+
+function! fugitive#RevertComplete(A, L, P, ...) abort
+  return s:CompleteSub('revert', a:A, a:L, a:P, function('s:CompleteRevision'), a:000)
+endfunction
+
+" Section: :Git merge, :Git rebase, :Git pull
+
+function! fugitive#MergeComplete(A, L, P, ...) abort
+  return s:CompleteSub('merge', a:A, a:L, a:P, function('s:CompleteRevision'), a:000)
+endfunction
+
+function! fugitive#RebaseComplete(A, L, P, ...) abort
+  return s:CompleteSub('rebase', a:A, a:L, a:P, function('s:CompleteRevision'), a:000)
+endfunction
+
+function! fugitive#PullComplete(A, L, P, ...) abort
+  return s:CompleteSub('pull', a:A, a:L, a:P, function('s:CompleteRemote'), a:000)
+endfunction
+
+function! s:MergeSubcommand(line1, line2, range, bang, mods, options) abort
+  let dir = a:options.dir
+  if empty(a:options.subcommand_args) && (
+        \ filereadable(fugitive#Find('.git/MERGE_MSG', dir)) ||
+        \ isdirectory(fugitive#Find('.git/rebase-apply', dir)) ||
+        \  !empty(s:TreeChomp(dir, 'diff-files', '--diff-filter=U')))
+    return 'echohl WarningMsg|echo ":Git merge for loading conflicts is deprecated in favor of :Git mergetool"|echohl NONE|silent Git' . (a:bang ? '!' : '') . s:fnameescape(a:options.flags + ['mergetool'])
+  endif
+  return {}
+endfunction
+
+function! s:RebaseSubcommand(line1, line2, range, bang, mods, options) abort
+  let args = a:options.subcommand_args
+  if s:HasOpt(args, '--autosquash') && !s:HasOpt(args, '-i', '--interactive')
+    return {'env': {'GIT_SEQUENCE_EDITOR': 'true'}, 'insert_args': ['--interactive']}
+  endif
+  return {}
+endfunction
+
+" Section: :Git difftool, :Git mergetool
+
+function! s:ToolItems(state, from, to, offsets, text, ...) abort
+  let items = []
+  for i in range(len(a:state.diff))
+    let diff = a:state.diff[i]
+    let path = (i == len(a:state.diff) - 1) ? a:to : a:from
+    if empty(path)
+      return []
+    endif
+    let item = {
+          \ 'valid': a:0 ? a:1 : 1,
+          \ 'filename': diff.filename . FugitiveVimPath(path),
+          \ 'lnum': matchstr(get(a:offsets, i), '\d\+'),
+          \ 'text': a:text}
+    if len(get(diff, 'module', ''))
+      let item.module = diff.module . path
+    endif
+    call add(items, item)
+  endfor
+  let diff = items[0:-2]
+  let items[-1].context = {'diff': items[0:-2]}
+  return [items[-1]]
+endfunction
+
+function! s:ToolToFrom(str) abort
+  if a:str =~# ' => '
+    let str = a:str =~# '{.* => .*}' ? a:str : '{' . a:str . '}'
+    return [substitute(str, '{.* => \(.*\)}', '\1', ''),
+          \ substitute(str, '{\(.*\) => .*}', '\1', '')]
+  else
+    return [a:str, a:str]
+  endif
+endfunction
+
+function! s:ToolParse(state, line) abort
+  if type(a:line) !=# type('') || a:state.mode ==# 'hunk' && a:line =~# '^[ +-]'
+    return []
+  elseif a:line =~# '^diff '
+    let a:state.mode = 'diffhead'
+    let a:state.from = ''
+    let a:state.to = ''
+  elseif a:state.mode ==# 'diffhead' && a:line =~# '^--- [^/]'
+    let a:state.from = a:line[4:-1]
+    let a:state.to = a:state.from
+  elseif a:state.mode ==# 'diffhead' && a:line =~# '^+++ [^/]'
+    let a:state.to = a:line[4:-1]
+    if empty(get(a:state, 'from', ''))
+      let a:state.from = a:state.to
+    endif
+  elseif a:line[0] ==# '@'
+    let a:state.mode = 'hunk'
+    if has_key(a:state, 'from')
+      let offsets = split(matchstr(a:line, '^@\+ \zs[-+0-9, ]\+\ze @'), ' ')
+      return s:ToolItems(a:state, a:state.from, a:state.to, offsets, matchstr(a:line, ' @@\+ \zs.*'))
+    endif
+  elseif a:line =~# '^\* Unmerged path .'
+    let file = a:line[16:-1]
+    return s:ToolItems(a:state, file, file, [], '')
+  elseif a:line =~# '^[A-Z]\d*\t.\|^:.*\t.'
+    " --raw, --name-status
+    let [status; files] = split(a:line, "\t")
+    return s:ToolItems(a:state, files[0], files[-1], [], a:state.name_only ? '' : status)
+  elseif a:line =~# '^ \S.* |'
+    " --stat
+    let [_, to, changes; __] = matchlist(a:line, '^ \(.\{-\}\) \+|\zs \(.*\)$')
+    let [to, from] = s:ToolToFrom(to)
+    return s:ToolItems(a:state, from, to, [], changes)
+  elseif a:line =~# '^ *\([0-9.]\+%\) .'
+    " --dirstat
+    let [_, changes, to; __] = matchlist(a:line, '^ *\([0-9.]\+%\) \(.*\)')
+    return s:ToolItems(a:state, to, to, [], changes)
+  elseif a:line =~# '^\(\d\+\|-\)\t\(\d\+\|-\)\t.'
+    " --numstat
+    let [_, add, remove, to; __] = matchlist(a:line, '^\(\d\+\|-\)\t\(\d\+\|-\)\t\(.*\)')
+    let [to, from] = s:ToolToFrom(to)
+    return s:ToolItems(a:state, from, to, [], add ==# '-' ? 'Binary file' : '+' . add . ' -' . remove, add !=# '-')
+  elseif a:state.mode !=# 'diffhead' && a:state.mode !=# 'hunk' && len(a:line) || a:line =~# '^git: \|^usage: \|^error: \|^fatal: '
+    return [{'text': a:line}]
+  endif
+  return []
+endfunction
+
+function! s:ToolStream(line1, line2, range, bang, mods, options, args, state) abort
+  let i = 0
+  let argv = copy(a:args)
+  let prompt = 1
+  let state = a:state
+  while i < len(argv)
+    let match = matchlist(argv[i], '^\(-[a-zABDFH-KN-RT-Z]\)\ze\(.*\)')
+    if len(match) && len(match[2])
+      call insert(argv, match[1])
+      let argv[i+1] = '-' . match[2]
+      continue
+    endif
+    let arg = argv[i]
+    if arg =~# '^-t$\|^--tool=\|^--tool-help$\|^--help$'
+      return {}
+    elseif arg =~# '^-y$\|^--no-prompt$'
+      let prompt = 0
+      call remove(argv, i)
+      continue
+    elseif arg ==# '--prompt'
+      let prompt = 1
+      call remove(argv, i)
+      continue
+    elseif arg =~# '^--\%(no-\)\=\(symlinks\|trust-exit-code\|gui\)$'
+      call remove(argv, i)
+      continue
+    elseif arg ==# '--'
+      break
+    endif
+    let i += 1
+  endwhile
+  let a:state.mode = 'init'
+  let a:state.from = ''
+  let a:state.to = ''
+  let exec = s:UserCommandList({'git': a:options.git, 'dir': a:options.dir})
+  if fugitive#GitVersion(1, 9) || (!s:HasOpt(argv, '--name-status') && !prompt)
+    let exec += ['-c', 'diff.context=0']
+  endif
+  let exec += a:options.flags + ['--no-pager', 'diff', '--no-ext-diff', '--no-color', '--no-prefix'] + argv
+  if prompt
+    let title = ':Git ' . s:fnameescape(a:options.flags + [a:options.subcommand] + a:options.subcommand_args)
+    return s:QuickfixStream(a:line2, 'difftool', title, exec, !a:bang, a:mods, s:function('s:ToolParse'), a:state)
+  else
+    let filename = ''
+    let cmd = []
+    let tabnr = tabpagenr() + 1
+    for line in split(s:SystemError(s:shellesc(exec))[0], "\n")
+      for item in s:ToolParse(a:state, line)
+        if len(get(item, 'filename', '')) && item.filename != filename
+          call add(cmd, 'tabedit ' . s:fnameescape(item.filename))
+          for i in reverse(range(len(get(item.context, 'diff', []))))
+            call add(cmd, (i ? 'rightbelow' : 'leftabove') . ' vert Gdiffsplit! ' . s:fnameescape(item.context.diff[i].filename))
+          endfor
+          call add(cmd, 'wincmd =')
+          let filename = item.filename
+        endif
+      endfor
+    endfor
+    return join(cmd, '|') . (empty(cmd) ? '' : '|' . tabnr . 'tabnext')
+  endif
+endfunction
+
+function! s:MergetoolSubcommand(line1, line2, range, bang, mods, options) abort
+  let dir = a:options.dir
+  exe s:DirCheck(dir)
+  let i = 0
+  let prompt = 1
+  let cmd = ['diff', '--diff-filter=U']
+  let state = {'name_only': 0}
+  let state.diff = [{'prefix': ':2:', 'module': ':2:'}, {'prefix': ':3:', 'module': ':3:'}, {'prefix': ':(top)'}]
+  call map(state.diff, 'extend(v:val, {"filename": fugitive#Find(v:val.prefix, dir)})')
+  return s:ToolStream(a:line1, a:line2, a:range, a:bang, a:mods, a:options, ['--diff-filter=U'] + a:options.subcommand_args, state)
+endfunction
+
+function! s:DifftoolSubcommand(line1, line2, range, bang, mods, options) abort
+  let dir = a:options.dir
+  exe s:DirCheck(dir)
+  let i = 0
+  let argv = copy(a:options.subcommand_args)
+  let commits = []
+  let cached = 0
+  let reverse = 1
+  let prompt = 1
+  let state = {'name_only': 0}
+  let merge_base_against = {}
+  let dash = (index(argv, '--') > i ? ['--'] : [])
+  while i < len(argv)
+    let match = matchlist(argv[i], '^\(-[a-zABDFH-KN-RT-Z]\)\ze\(.*\)')
+    if len(match) && len(match[2])
+      call insert(argv, match[1])
+      let argv[i+1] = '-' . match[2]
+      continue
+    endif
+    let arg = argv[i]
+    if arg ==# '--cached'
+      let cached = 1
+    elseif arg ==# '-R'
+      let reverse = 1
+    elseif arg ==# '--name-only'
+      let state.name_only = 1
+      let argv[0] = '--name-status'
+    elseif arg ==# '--'
+      break
+    elseif arg !~# '^-\|^\.\.\=\%(/\|$\)'
+      let parsed = s:LinesError(['rev-parse', '--revs-only', substitute(arg, ':.*', '', '')] + dash)[0]
+      call map(parsed, '{"uninteresting": v:val =~# "^\\^", "prefix": substitute(v:val, "^\\^", "", "") . ":"}')
+      let merge_base_against = {}
+      if arg =~# '\.\.\.' && len(parsed) > 2
+        let display = map(split(arg, '\.\.\.', 1), 'empty(v:val) ? "@" : v:val')
+        if len(display) == 2
+          let parsed[0].module = display[1] . ':'
+          let parsed[1].module = display[0] . ':'
+        endif
+        let parsed[2].module = arg . ':'
+        if empty(commits)
+          let merge_base_against = parsed[0]
+          let parsed = [parsed[2]]
+        endif
+      elseif arg =~# '\.\.' && len(parsed) == 2
+        let display = map(split(arg, '\.\.', 1), 'empty(v:val) ? "@" : v:val')
+        if len(display) == 2
+          let parsed[0].module = display[0] . ':'
+          let parsed[1].module = display[1] . ':'
+        endif
+      elseif len(parsed) == 1
+        let parsed[0].module = arg . ':'
+      endif
+      call extend(commits, parsed)
+    endif
+    let i += 1
+  endwhile
+  if len(merge_base_against)
+    call add(commits, merge_base_against)
+  endif
+  let commits = filter(copy(commits), 'v:val.uninteresting') + filter(commits, '!v:val.uninteresting')
+  if cached
+    if empty(commits)
+      call add(commits, {'prefix': '@:', 'module': '@:'})
+    endif
+    call add(commits, {'prefix': ':0:', 'module': ':0:'})
+  elseif len(commits) < 2
+    call add(commits, {'prefix': ':(top)'})
+    if len(commits) < 2
+      call insert(commits, {'prefix': ':0:', 'module': ':0:'})
+    endif
+  endif
+  if reverse
+    let commits = [commits[-1]] + repeat([commits[0]], len(commits) - 1)
+    call reverse(commits)
+  endif
+  if len(commits) > 2
+    call add(commits, remove(commits, 0))
+  endif
+  call map(commits, 'extend(v:val, {"filename": fugitive#Find(v:val.prefix, dir)})')
+  let state.diff = commits
+  return s:ToolStream(a:line1, a:line2, a:range, a:bang, a:mods, a:options, argv, state)
+endfunction
+
+" Section: :Ggrep, :Glog
+
+if !exists('g:fugitive_summary_format')
+  let g:fugitive_summary_format = '%s'
+endif
+
+function! fugitive#GrepComplete(A, L, P) abort
+  return s:CompleteSub('grep', a:A, a:L, a:P)
+endfunction
+
+function! fugitive#LogComplete(A, L, P) abort
+  return s:CompleteSub('log', a:A, a:L, a:P)
+endfunction
+
+function! s:GrepParseLine(prefix, name_only, dir, line) abort
+  let entry = {'valid': 1}
+  let match = matchlist(a:line, '^\(.\{-\}\):\(\d\+\):\(\d\+:\)\=\(.*\)$')
+  if len(match)
+    let entry.module = match[1]
+    let entry.lnum = +match[2]
+    let entry.col = +match[3]
+    let entry.text = match[4]
+  elseif a:line =~# '^git: \|^usage: \|^error: \|^fatal: '
+    return {'text': a:line}
+  else
+    let entry.module = matchstr(a:line, '\CBinary file \zs.*\ze matches$')
+    if len(entry.module)
+      let entry.text = 'Binary file'
+      let entry.valid = 0
+    endif
+  endif
+  if empty(entry.module) && a:name_only
+    let entry.module = a:line
+  endif
+  if empty(entry.module)
+    return {'text': a:line}
+  endif
+  if entry.module !~# ':'
+    let entry.filename = a:prefix . entry.module
+  else
+    let entry.filename = fugitive#Find(entry.module, a:dir)
+  endif
+  return entry
+endfunction
+
+function! s:GrepSubcommand(line1, line2, range, bang, mods, options) abort
+  let dir = a:options.dir
+  exe s:DirCheck(dir)
+  let listnr = a:line1 == 0 ? a:line1 : a:line2
+  let cmd = ['--no-pager', 'grep', '-n', '--no-color', '--full-name']
+  let tree = s:Tree(dir)
+  let args = a:options.subcommand_args
+  if get(args, 0, '') =~# '^-O\|--open-files-in-pager$'
+    let args = args[1:-1]
+  endif
+  let name_only = s:HasOpt(args, '-l', '--files-with-matches', '--name-only', '-L', '--files-without-match')
+  if listnr > 0
+    exe listnr 'wincmd w'
+  else
+    call s:BlurStatus()
+  endif
+  redraw
+  call s:QuickfixCreate(listnr, {'title': (listnr < 0 ? ':Git grep ' : ':0Git grep ') . s:fnameescape(args)})
+  let tempfile = tempname()
+  let event = listnr < 0 ? 'grep-fugitive' : 'lgrep-fugitive'
+  silent exe s:DoAutocmd('QuickFixCmdPre ' . event)
+  let prefix = FugitiveVimPath(s:HasOpt(args, '--cached') || empty(tree) ?
+        \ 'fugitive://' . dir . '//0/' :
+        \ s:cpath(getcwd(), tree) ? '' : tree . '/')
+  try
+    if exists('+guioptions') && &guioptions =~# '!'
+      let guioptions = &guioptions
+      set guioptions-=!
+    endif
+    exe '!' . escape(s:UserCommand(a:options, cmd + args), '%#!')
+          \ printf(&shellpipe . (&shellpipe =~# '%s' ? '' : ' %s'), s:shellesc(tempfile))
+  finally
+    if exists('guioptions')
+      let &guioptions = guioptions
+    endif
+  endtry
+  let list = map(readfile(tempfile), 's:GrepParseLine(prefix, name_only, dir, v:val)')
+  call s:QuickfixSet(listnr, list, 'a')
+  silent exe s:DoAutocmd('QuickFixCmdPost ' . event)
+  if !has('gui_running')
+    redraw
+  endif
+  if !a:bang && !empty(list)
+    return (listnr < 0 ? 'c' : 'l').'first'
+  else
+    return ''
+  endif
+endfunction
+
+function! fugitive#GrepCommand(line1, line2, range, bang, mods, arg) abort
+  return fugitive#Command(a:line1, a:line2, a:range, a:bang, a:mods,
+        \ "grep -O " . (fugitive#GitVersion(2, 19) ? "--column " : "") . a:arg)
+endfunction
+
+let s:log_diff_context = '{"filename": fugitive#Find(v:val . from, a:dir), "lnum": get(offsets, v:key), "module": strpart(v:val, 0, len(a:state.base_module)) . from}'
+
+function! s:LogFlushQueue(state, dir) abort
+  let queue = remove(a:state, 'queue')
+  if a:state.child_found && get(a:state, 'ignore_commit')
+    call remove(queue, 0)
+  elseif len(queue) && len(a:state.target) && len(get(a:state, 'parents', []))
+    let from = substitute(a:state.target, '^/', ':', '')
+    let offsets = []
+    let queue[0].context.diff = map(copy(a:state.parents), s:log_diff_context)
+  endif
+  if len(queue) && queue[-1] ==# {'text': ''}
+    call remove(queue, -1)
+  endif
+  return queue
+endfunction
+
+function! s:LogParse(state, dir, line) abort
+  if a:state.mode ==# 'hunk' && a:line =~# '^[-+ ]'
+    return []
+  endif
+  let list = matchlist(a:line, '^\%(fugitive \(.\{-\}\)\t\|commit \|From \)\=\(\x\{40,\}\)\%( \(.*\)\)\=$')
+  if len(list)
+    let queue = s:LogFlushQueue(a:state, a:dir)
+    let a:state.mode = 'commit'
+    let a:state.base = 'fugitive://' . a:dir . '//' . list[2]
+    if len(list[1])
+      let [a:state.base_module; a:state.parents] = split(list[1], ' ')
+    else
+      let a:state.base_module = list[2]
+      let a:state.parents = []
+    endif
+    let a:state.message = list[3]
+    let a:state.from = ''
+    let a:state.to = ''
+    let context = {}
+    let a:state.queue = [{
+          \ 'valid': 1,
+          \ 'context': context,
+          \ 'filename': a:state.base . a:state.target,
+          \ 'module': a:state.base_module . substitute(a:state.target, '^/', ':', ''),
+          \ 'text': a:state.message}]
+    let a:state.child_found = 0
+    return queue
+  elseif type(a:line) == type(0)
+    return s:LogFlushQueue(a:state, a:dir)
+  elseif a:line =~# '^diff'
+    let a:state.mode = 'diffhead'
+    let a:state.from = ''
+    let a:state.to = ''
+  elseif a:state.mode ==# 'diffhead' && a:line =~# '^--- \w/'
+    let a:state.from = a:line[6:-1]
+    let a:state.to = a:state.from
+  elseif a:state.mode ==# 'diffhead' && a:line =~# '^+++ \w/'
+    let a:state.to = a:line[6:-1]
+    if empty(get(a:state, 'from', ''))
+      let a:state.from = a:state.to
+    endif
+  elseif a:line =~# '^@@[^@]*+\d' && len(get(a:state, 'to', '')) && has_key(a:state, 'base')
+    let a:state.mode = 'hunk'
+    if empty(a:state.target) || a:state.target ==# '/' . a:state.to
+      if !a:state.child_found && len(a:state.queue) && a:state.queue[-1] ==# {'text': ''}
+        call remove(a:state.queue, -1)
+      endif
+      let a:state.child_found = 1
+      let offsets = map(split(matchstr(a:line, '^@\+ \zs[-+0-9, ]\+\ze @'), ' '), '+matchstr(v:val, "\\d\\+")')
+      let context = {}
+      if len(a:state.parents)
+        let from = ":" . a:state.from
+        let context.diff = map(copy(a:state.parents), s:log_diff_context)
+      endif
+      call add(a:state.queue, {
+            \ 'valid': 1,
+            \ 'context': context,
+            \ 'filename': FugitiveVimPath(a:state.base . '/' . a:state.to),
+            \ 'module': a:state.base_module . ':' . a:state.to,
+            \ 'lnum': offsets[-1],
+            \ 'text': a:state.message . matchstr(a:line, ' @@\+ .\+')})
+    endif
+  elseif a:state.follow &&
+        \ a:line =~# '^ \%(mode change \d\|\%(create\|delete\) mode \d\|\%(rename\|copy\|rewrite\) .* (\d\+%)$\)'
+    let rename = matchstr(a:line, '^ rename \zs.* => .*\ze (\d\+%)$')
+    if len(rename)
+      let rename = rename =~# '{.* => .*}' ? rename : '{' . rename . '}'
+      if a:state.target ==# simplify('/' . substitute(rename, '{.* => \(.*\)}', '\1', ''))
+        let a:state.target = simplify('/' . substitute(rename, '{\(.*\) => .*}', '\1', ''))
+      endif
+    endif
+    if !get(a:state, 'ignore_summary')
+      call add(a:state.queue, {'text': a:line})
+    endif
+  elseif a:state.mode ==# 'commit' || a:state.mode ==# 'init'
+    call add(a:state.queue, {'text': a:line})
+  endif
+  return []
+endfunction
+
+function! fugitive#LogCommand(line1, count, range, bang, mods, args, type) abort
+  let dir = s:Dir()
+  exe s:DirCheck(dir)
+  let listnr = a:type =~# '^l' ? 0 : -1
+  let [args, after] = s:SplitExpandChain(a:args, s:Tree(dir))
+  let split = index(args, '--')
+  if split > 0
+    let paths = args[split : -1]
+    let args = args[0 : split - 1]
+  elseif split == 0
+    let paths = args
+    let args = []
+  else
+    let paths = []
+  endif
+  if a:line1 == 0 && a:count
+    let path = fugitive#Path(bufname(a:count), '/', dir)
+    let titlepre = ':0,' . a:count
+  elseif a:count >= 0
+    let path = fugitive#Path(@%, '/', dir)
+    let titlepre = a:count == 0 ? ':0,' . bufnr('') : ':'
+  else
+    let titlepre = ':'
+    let path = ''
+  endif
+  let range = ''
+  let extra_args = []
+  let extra_paths = []
+  let state = {'mode': 'init', 'child_found': 0, 'queue': [], 'follow': 0}
+  if path =~# '^/\.git\%(/\|$\)\|^$'
+    let path = ''
+  elseif a:line1 == 0
+    let range = "0," . (a:count ? a:count : bufnr(''))
+    let extra_paths = ['.' . path]
+    if (empty(paths) || paths ==# ['--']) && !s:HasOpt(args, '--no-follow')
+      let state.follow = 1
+      if !s:HasOpt(args, '--follow')
+        call insert(extra_args, '--follow')
+      endif
+      if !s:HasOpt(args, '--summary')
+        call insert(extra_args, '--summary')
+        let state.ignore_summary = 1
+      endif
+    endif
+    let state.ignore_commit = 1
+  elseif a:count > 0
+    if !s:HasOpt(args, '--merges', '--no-merges')
+      call insert(extra_args, '--no-merges')
+    endif
+    call add(args, '-L' . a:line1 . ',' . a:count . ':' . path[1:-1])
+    let state.ignore_commit = 1
+  endif
+  if len(path) && empty(filter(copy(args), 'v:val =~# "^[^-]"'))
+    let owner = s:Owner(@%, dir)
+    if len(owner)
+      call add(args, owner)
+    endif
+  endif
+  if empty(extra_paths)
+    let path = ''
+  endif
+  if s:HasOpt(args, '-g', '--walk-reflogs')
+    let format = "%gd %P\t%H %gs"
+  else
+    let format = "%h %P\t%H " . g:fugitive_summary_format
+  endif
+  let cmd = ['--no-pager']
+  if fugitive#GitVersion(1, 9)
+    call extend(cmd, ['-c', 'diff.context=0', '-c', 'diff.noprefix=false', 'log'])
+  else
+    call extend(cmd, ['log', '-U0', '-s'])
+  endif
+  call extend(cmd,
+        \ ['--no-color', '--no-ext-diff', '--pretty=format:fugitive ' . format] +
+        \ args + extra_args + paths + extra_paths)
+  let state.target = path
+  let title = titlepre . (listnr < 0 ? 'Gclog ' : 'Gllog ') . s:fnameescape(args + paths)
+  if empty(paths + extra_paths) && empty(a:type) && a:count < 0 && len(s:Relative('/'))
+    let after = '|echohl WarningMsg|echo ' . string('Use :0Glog or :0Gclog for old behavior of targeting current file') . '|echohl NONE' . after
+  endif
+  return s:QuickfixStream(listnr, 'log', title, s:UserCommandList(dir) + cmd, !a:bang, a:mods, s:function('s:LogParse'), state, dir) . after
+endfunction
+
+" Section: :Gedit, :Gpedit, :Gsplit, :Gvsplit, :Gtabedit, :Gread
+
+function! s:UsableWin(nr) abort
+  return a:nr && !getwinvar(a:nr, '&previewwindow') && !getwinvar(a:nr, '&winfixwidth') &&
+        \ (empty(getwinvar(a:nr, 'fugitive_status')) || getbufvar(winbufnr(a:nr), 'fugitive_type') !=# 'index') &&
+        \ index(['gitrebase', 'gitcommit'], getbufvar(winbufnr(a:nr), '&filetype')) < 0 &&
+        \ index(['nofile','help','quickfix', 'terminal'], getbufvar(winbufnr(a:nr), '&buftype')) < 0
+endfunction
+
+function! s:ArgSplit(string) abort
+  let string = a:string
+  let args = []
+  while string =~# '\S'
+    let arg = matchstr(string, '^\s*\%(\\.\|[^[:space:]]\)\+')
+    let string = strpart(string, len(arg))
+    let arg = substitute(arg, '^\s\+', '', '')
+    call add(args, substitute(arg, '\\\@<!\\ ', ' ', 'g'))
+  endwhile
+  return args
+endfunction
+
+function! s:OpenParse(string, wants_cmd) abort
+  let opts = []
+  let cmds = []
+  let args = s:ArgSplit(a:string)
+  while !empty(args)
+    if args[0] =~# '^++'
+      call add(opts, ' ' . escape(remove(args, 0), ' |"'))
+    elseif a:wants_cmd && args[0] =~# '^+'
+      call add(cmds, remove(args, 0)[1:-1])
+    else
+      break
+    endif
+  endwhile
+  if len(args)
+    let file = join(args)
+  elseif empty(expand('%'))
+    let file = ''
+  elseif empty(s:DirCommitFile(@%)[1]) && s:Relative('./') !~# '^\./\.git\>'
+    let file = '>:0'
+  else
+    let file = '>'
+  endif
+  let dir = s:Dir()
+  let efile = s:Expand(file)
+  let url = fugitive#Find(efile, dir)
+
+  if a:wants_cmd && file[0] ==# '>' && efile[0] !=# '>' && get(b:, 'fugitive_type', '') isnot# 'tree' && &filetype !=# 'netrw'
+    let line = line('.')
+    if expand('%:p') !=# url
+      let diffcmd = 'diff'
+      let from = s:DirRev(@%)[1]
+      let to = s:DirRev(url)[1]
+      if empty(from) && empty(to)
+        let diffcmd = 'diff-files'
+        let args = ['--', expand('%:p'), url]
+      elseif empty(to)
+        let args = [from, '--', url]
+      elseif empty(from)
+        let args = [to, '--', expand('%:p')]
+        let reverse = 1
+      else
+        let args = [from, to]
+      endif
+      let [res, exec_error] = s:LinesError([dir, diffcmd, '-U0'] + args)
+      if !exec_error
+        call filter(res, 'v:val =~# "^@@ "')
+        call map(res, 'substitute(v:val, ''[-+]\d\+\zs '', ",1 ", "g")')
+        call map(res, 'matchlist(v:val, ''^@@ -\(\d\+\),\(\d\+\) +\(\d\+\),\(\d\+\) @@'')[1:4]')
+        if exists('reverse')
+          call map(res, 'v:val[2:3] + v:val[0:1]')
+        endif
+        call filter(res, 'v:val[0] < '.line('.'))
+        let hunk = get(res, -1, [0,0,0,0])
+        if hunk[0] + hunk[1] > line('.')
+          let line = hunk[2] + max([1 - hunk[3], 0])
+        else
+          let line = hunk[2] + max([hunk[3], 1]) + line('.') - hunk[0] - max([hunk[1], 1])
+        endif
+      endif
+    endif
+    call insert(cmds, line)
+  endif
+
+  let pre = join(opts, '')
+  if len(cmds) > 1
+    let pre .= ' +' . escape(join(map(cmds, '"exe ".string(v:val)'), '|'), ' |"')
+  elseif len(cmds)
+    let pre .= ' +' . escape(cmds[0], ' |"')
+  endif
+  return [url, pre]
+endfunction
+
+function! fugitive#DiffClose() abort
+  let mywinnr = winnr()
+  for winnr in [winnr('#')] + range(winnr('$'),1,-1)
+    if winnr != mywinnr && getwinvar(winnr,'&diff')
+      execute winnr.'wincmd w'
+      close
+      if winnr('$') > 1
+        wincmd p
+      endif
+    endif
+  endfor
+  diffoff!
+endfunction
+
+function! s:BlurStatus() abort
+  if (&previewwindow || exists('w:fugitive_status')) && get(b:,'fugitive_type', '') ==# 'index'
+    let winnrs = filter([winnr('#')] + range(1, winnr('$')), 's:UsableWin(v:val)')
+    if len(winnrs)
+      exe winnrs[0].'wincmd w'
+    else
+      belowright new
+    endif
+    if &diff
+      call fugitive#DiffClose()
+    endif
+  endif
+endfunction
+
+let s:bang_edits = {'split': 'Git', 'vsplit': 'vert Git', 'tabedit': 'tab Git', 'pedit': 'Git!'}
+function! fugitive#Open(cmd, bang, mods, arg, args) abort
+  if a:bang
+    return 'echoerr ' . string(':G' . a:cmd . '! for temp buffer output has been replaced by :' . get(s:bang_edits, a:cmd, 'Git') . ' --paginate')
+  endif
+
+  let mods = s:Mods(a:mods)
+  try
+    let [file, pre] = s:OpenParse(a:arg, 1)
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if file !~# '^\a\a\+:'
+    let file = s:sub(file, '/$', '')
+  endif
+  if a:cmd ==# 'edit'
+    call s:BlurStatus()
+  endif
+  return mods . a:cmd . pre . ' ' . s:fnameescape(file)
+endfunction
+
+function! s:ReadPrepare(line1, count, range, mods) abort
+  let mods = s:Mods(a:mods)
+  let after = a:count
+  if a:count < 0
+    let delete = 'silent 1,' . line('$') . 'delete_|'
+    let after = line('$')
+  elseif a:range == 2
+    let delete = 'silent ' . a:line1 . ',' . a:count . 'delete_|'
+  else
+    let delete = ''
+  endif
+  if foldlevel(after)
+    let pre = after . 'foldopen!|'
+  else
+    let pre = ''
+  endif
+  return [pre . mods . after . 'read', delete . 'diffupdate' . (a:count < 0 ? '|' . line('.') : '')]
+endfunction
+
+function! s:ReadExec(line1, count, range, mods, env, args, options) abort
+  let [read, post] = s:ReadPrepare(a:line1, a:count, a:range, a:mods)
+  let env = s:BuildEnvPrefix(extend({'COLUMNS': &tw ? &tw : 80}, a:env))
+  silent execute read . '!' escape(env . s:UserCommand(a:options, ['--no-pager'] + a:args), '!#%')
+  execute post
+  call fugitive#ReloadStatus(a:options.dir, 1)
+  return 'redraw|echo '.string(':!'.s:UserCommand(a:options, a:args))
+endfunction
+
+function! fugitive#ReadCommand(line1, count, range, bang, mods, arg, args) abort
+  if a:bang
+    return 'echoerr ' . string(':Gread! for temp buffer output has been replaced by :{range}Git! --paginate')
+  endif
+  let [read, post] = s:ReadPrepare(a:line1, a:count, a:range, a:mods)
+  try
+    let [file, pre] = s:OpenParse(a:arg, 0)
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if file =~# '^fugitive:' && a:count is# 0
+    return 'exe ' .string(s:Mods(a:mods) . fugitive#FileReadCmd(file, 0, pre)) . '|diffupdate'
+  endif
+  return read . ' ' . pre . ' ' . s:fnameescape(file) . '|' . post
+endfunction
+
+function! fugitive#EditComplete(A, L, P) abort
+  if a:A =~# '^>'
+    return map(s:FilterEscape(s:CompleteHeads(s:Dir()), a:A[1:-1]), "'>' . v:val")
+  else
+    return fugitive#CompleteObject(a:A, a:L, a:P)
+  endif
+endfunction
+
+function! fugitive#ReadComplete(A, L, P) abort
+  if a:L =~# '^\w\+!'
+    return fugitive#Complete(a:A, a:L, a:P)
+  else
+    return fugitive#EditComplete(a:A, a:L, a:P)
+  endif
+endfunction
+
+" Section: :Gwrite, :Gwq
+
+function! fugitive#WriteCommand(line1, line2, range, bang, mods, arg, args) abort
+  if s:cpath(expand('%:p'), fugitive#Find('.git/COMMIT_EDITMSG'))
+    return (empty($GIT_INDEX_FILE) ? 'write|bdelete' : 'wq') . (a:bang ? '!' : '')
+  elseif get(b:, 'fugitive_type', '') ==# 'index'
+    return 'Git commit'
+  elseif &buftype ==# 'nowrite' && getline(4) =~# '^[+-]\{3\} '
+    return 'echoerr ' . string('fugitive: :Gwrite from :Git diff has been removed in favor of :Git add --edit')
+  endif
+  let mytab = tabpagenr()
+  let mybufnr = bufnr('')
+  try
+    let file = len(a:arg) ? s:Generate(s:Expand(a:arg)) : fugitive#Real(@%)
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if empty(file)
+    return 'echoerr '.string('fugitive: cannot determine file path')
+  endif
+  if file =~# '^fugitive:'
+    return 'write' . (a:bang ? '! ' : ' ') . s:fnameescape(file)
+  endif
+  exe s:DirCheck()
+  let always_permitted = s:cpath(fugitive#Real(@%), file) && empty(s:DirCommitFile(@%)[1])
+  if !always_permitted && !a:bang && (len(s:TreeChomp('diff', '--name-status', 'HEAD', '--', file)) || len(s:TreeChomp('ls-files', '--others', '--', file)))
+    let v:errmsg = 'fugitive: file has uncommitted changes (use ! to override)'
+    return 'echoerr v:errmsg'
+  endif
+  let treebufnr = 0
+  for nr in range(1,bufnr('$'))
+    if fnamemodify(bufname(nr),':p') ==# file
+      let treebufnr = nr
+    endif
+  endfor
+
+  if treebufnr > 0 && treebufnr != bufnr('')
+    let temp = tempname()
+    silent execute 'keepalt %write '.temp
+    for tab in [mytab] + range(1,tabpagenr('$'))
+      for winnr in range(1,tabpagewinnr(tab,'$'))
+        if tabpagebuflist(tab)[winnr-1] == treebufnr
+          execute 'tabnext '.tab
+          if winnr != winnr()
+            execute winnr.'wincmd w'
+            let restorewinnr = 1
+          endif
+          try
+            let lnum = line('.')
+            let last = line('$')
+            silent execute '$read '.temp
+            silent execute '1,'.last.'delete_'
+            silent write!
+            silent execute lnum
+            diffupdate
+            let did = 1
+          finally
+            if exists('restorewinnr')
+              wincmd p
+            endif
+            execute 'tabnext '.mytab
+          endtry
+          break
+        endif
+      endfor
+    endfor
+    if !exists('did')
+      call writefile(readfile(temp,'b'),file,'b')
+    endif
+  else
+    execute 'write! '.s:fnameescape(file)
+  endif
+
+  if a:bang
+    let [error, exec_error] = s:ChompError(['add', '--force', '--', file])
+  else
+    let [error, exec_error] = s:ChompError(['add', '--', file])
+  endif
+  if exec_error
+    let v:errmsg = 'fugitive: '.error
+    return 'echoerr v:errmsg'
+  endif
+  if s:cpath(fugitive#Real(@%), file) && s:DirCommitFile(@%)[1] =~# '^\d$'
+    setlocal nomodified
+  endif
+
+  let one = s:Generate(':1:'.file)
+  let two = s:Generate(':2:'.file)
+  let three = s:Generate(':3:'.file)
+  for nr in range(1,bufnr('$'))
+    let name = fnamemodify(bufname(nr), ':p')
+    if bufloaded(nr) && !getbufvar(nr,'&modified') && (name ==# one || name ==# two || name ==# three)
+      execute nr.'bdelete'
+    endif
+  endfor
+
+  unlet! restorewinnr
+  let zero = s:Generate(':0:'.file)
+  silent exe s:DoAutocmd('BufWritePost ' . s:fnameescape(zero))
+  for tab in range(1,tabpagenr('$'))
+    for winnr in range(1,tabpagewinnr(tab,'$'))
+      let bufnr = tabpagebuflist(tab)[winnr-1]
+      let bufname = fnamemodify(bufname(bufnr), ':p')
+      if bufname ==# zero && bufnr != mybufnr
+        execute 'tabnext '.tab
+        if winnr != winnr()
+          execute winnr.'wincmd w'
+          let restorewinnr = 1
+        endif
+        try
+          let lnum = line('.')
+          let last = line('$')
+          silent execute '$read '.s:fnameescape(file)
+          silent execute '1,'.last.'delete_'
+          silent execute lnum
+          setlocal nomodified
+          diffupdate
+        finally
+          if exists('restorewinnr')
+            wincmd p
+          endif
+          execute 'tabnext '.mytab
+        endtry
+        break
+      endif
+    endfor
+  endfor
+  call fugitive#ReloadStatus(-1, 1)
+  return 'checktime'
+endfunction
+
+function! fugitive#WqCommand(...) abort
+  let bang = a:4 ? '!' : ''
+  if s:cpath(expand('%:p'), fugitive#Find('.git/COMMIT_EDITMSG'))
+    return 'wq'.bang
+  endif
+  let result = call('fugitive#WriteCommand', a:000)
+  if result =~# '^\%(write\|wq\|echoerr\)'
+    return s:sub(result,'^write','wq')
+  else
+    return result.'|quit'.bang
+  endif
+endfunction
+
+" Section: :Git push, :Git fetch
+
+function! fugitive#PushComplete(A, L, P, ...) abort
+  return s:CompleteSub('push', a:A, a:L, a:P, function('s:CompleteRemote'), a:000)
+endfunction
+
+function! fugitive#FetchComplete(A, L, P, ...) abort
+  return s:CompleteSub('fetch', a:A, a:L, a:P, function('s:CompleteRemote'), a:000)
+endfunction
+
+" Section: :Gdiff
+
+augroup fugitive_diff
+  autocmd!
+  autocmd BufWinLeave * nested
+        \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 2 |
+        \   call s:diffoff_all(s:Dir(+expand('<abuf>'))) |
+        \ endif
+  autocmd BufWinEnter * nested
+        \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 1 |
+        \   call s:diffoff() |
+        \ endif
+augroup END
+
+function! s:can_diffoff(buf) abort
+  return getwinvar(bufwinnr(a:buf), '&diff') &&
+        \ !empty(getwinvar(bufwinnr(a:buf), 'fugitive_diff_restore'))
+endfunction
+
+function! fugitive#CanDiffoff(buf) abort
+  return s:can_diffoff(bufnr(a:buf))
+endfunction
+
+function! s:diff_modifier(count) abort
+  let fdc = matchstr(&diffopt, 'foldcolumn:\zs\d\+')
+  if &diffopt =~# 'horizontal' && &diffopt !~# 'vertical'
+    return ''
+  elseif &diffopt =~# 'vertical'
+    return 'vertical '
+  elseif winwidth(0) <= a:count * ((&tw ? &tw : 80) + (empty(fdc) ? 2 : fdc))
+    return ''
+  else
+    return 'vertical '
+  endif
+endfunction
+
+function! s:diff_window_count() abort
+  let c = 0
+  for nr in range(1,winnr('$'))
+    let c += getwinvar(nr,'&diff')
+  endfor
+  return c
+endfunction
+
+function! s:diff_restore() abort
+  let restore = 'setlocal nodiff noscrollbind'
+        \ . ' scrollopt=' . &l:scrollopt
+        \ . (&l:wrap ? ' wrap' : ' nowrap')
+        \ . ' foldlevel=999'
+        \ . ' foldmethod=' . &l:foldmethod
+        \ . ' foldcolumn=' . &l:foldcolumn
+        \ . ' foldlevel=' . &l:foldlevel
+        \ . (&l:foldenable ? ' foldenable' : ' nofoldenable')
+  if has('cursorbind')
+    let restore .= (&l:cursorbind ? ' ' : ' no') . 'cursorbind'
+  endif
+  return restore
+endfunction
+
+function! s:diffthis() abort
+  if !&diff
+    let w:fugitive_diff_restore = s:diff_restore()
+    diffthis
+  endif
+endfunction
+
+function! s:diffoff() abort
+  if exists('w:fugitive_diff_restore') && v:version < 704
+    execute w:fugitive_diff_restore
+  endif
+  unlet! w:fugitive_diff_restore
+  diffoff
+endfunction
+
+function! s:diffoff_all(dir) abort
+  let curwin = winnr()
+  for nr in range(1,winnr('$'))
+    if getwinvar(nr, '&diff') && !empty(getwinvar(nr, 'fugitive_diff_restore'))
+      if v:version < 704
+        if nr != winnr()
+          execute nr.'wincmd w'
+        endif
+        execute w:fugitive_diff_restore
+      endif
+      call setwinvar(nr, 'fugitive_diff_restore', '')
+    endif
+  endfor
+  if curwin != winnr()
+    execute curwin.'wincmd w'
+  endif
+  diffoff!
+endfunction
+
+function! s:CompareAge(mine, theirs) abort
+  let scores = {':0': 1, ':1': 2, ':2': 3, ':': 4, ':3': 5}
+  let mine = substitute(a:mine, '^:', '', '')
+  let theirs = substitute(a:theirs, '^:', '', '')
+  let my_score    = get(scores, ':'.mine, 0)
+  let their_score = get(scores, ':'.theirs, 0)
+  if my_score || their_score
+    return my_score < their_score ? -1 : my_score != their_score
+  elseif mine ==# theirs
+    return 0
+  endif
+  let base = s:TreeChomp('merge-base', mine, theirs)
+  if base ==# mine
+    return -1
+  elseif base ==# theirs
+    return 1
+  endif
+  let my_time    = +s:TreeChomp('log', '--max-count=1', '--pretty=format:%at', a:mine, '--')
+  let their_time = +s:TreeChomp('log', '--max-count=1', '--pretty=format:%at', a:theirs, '--')
+  return my_time < their_time ? -1 : my_time != their_time
+endfunction
+
+function! s:IsConflicted() abort
+  return len(@%) && !empty(s:ChompDefault('', 'ls-files', '--unmerged', '--', expand('%:p')))
+endfunction
+
+function! fugitive#Diffsplit(autodir, keepfocus, mods, arg, args) abort
+  let args = s:ArgSplit(a:arg)
+  let post = ''
+  if get(args, 0) =~# '^+'
+    let post = remove(args, 0)[1:-1]
+  endif
+  if exists(':DiffGitCached') && empty(args)
+    return s:Mods(a:mods) . 'DiffGitCached' . (len(post) ? '|' . post : '')
+  endif
+  let commit = s:DirCommitFile(@%)[1]
+  if a:mods =~# '\<tab\>'
+    let mods = substitute(a:mods, '\<tab\>', '', 'g')
+    let pre = 'tab split'
+  else
+    let mods = 'keepalt ' . a:mods
+    let pre = ''
+  endif
+  let back = exists('*win_getid') ? 'call win_gotoid(' . win_getid() . ')' : 'wincmd p'
+  if (empty(args) || args[0] ==# ':') && a:keepfocus
+    exe s:DirCheck()
+    if empty(commit) && s:IsConflicted()
+      let parents = [s:Relative(':2:'), s:Relative(':3:')]
+    elseif empty(commit)
+      let parents = [s:Relative(':0:')]
+    elseif commit =~# '^\d\=$'
+      let parents = [s:Relative('HEAD:')]
+    elseif commit =~# '^\x\x\+$'
+      let parents = s:LinesError(['rev-parse', commit . '^@'])[0]
+      call map(parents, 's:Relative(v:val . ":")')
+    endif
+  endif
+  try
+    if exists('parents') && len(parents) > 1
+      exe pre
+      let mods = (a:autodir ? s:diff_modifier(len(parents) + 1) : '') . s:Mods(mods, 'leftabove')
+      let nr = bufnr('')
+      execute mods 'split' s:fnameescape(s:Generate(parents[0]))
+      call s:Map('n', 'dp', ':diffput '.nr.'<Bar>diffupdate<CR>', '<silent>')
+      let nr2 = bufnr('')
+      call s:diffthis()
+      exe back
+      call s:Map('n', 'd2o', ':diffget '.nr2.'<Bar>diffupdate<CR>', '<silent>')
+      let mods = substitute(mods, '\Cleftabove\|rightbelow\|aboveleft\|belowright', '\=submatch(0) =~# "f" ? "rightbelow" : "leftabove"', '')
+      for i in range(len(parents)-1, 1, -1)
+        execute mods 'split' s:fnameescape(s:Generate(parents[i]))
+        call s:Map('n', 'dp', ':diffput '.nr.'<Bar>diffupdate<CR>', '<silent>')
+        let nrx = bufnr('')
+        call s:diffthis()
+        exe back
+        call s:Map('n', 'd' . (i + 2) . 'o', ':diffget '.nrx.'<Bar>diffupdate<CR>', '<silent>')
+      endfor
+      call s:diffthis()
+      if len(parents) > 1
+        wincmd =
+      endif
+      return post
+    elseif len(args)
+      let arg = join(args, ' ')
+      if arg ==# ''
+        return post
+      elseif arg ==# ':/'
+        exe s:DirCheck()
+        let file = s:Relative()
+      elseif arg ==# ':'
+        exe s:DirCheck()
+        let file = s:Relative(':0:')
+      elseif arg =~# '^:\d$'
+        exe s:DirCheck()
+        let file = s:Relative(arg . ':')
+      elseif arg =~# '^[~^]\d*$'
+        return 'echoerr ' . string('fugitive: change ' . arg . ' to !' . arg . ' to diff against ancestor')
+      else
+        try
+          let file = arg =~# '^:/.' ? fugitive#RevParse(arg) . s:Relative(':') : s:Expand(arg)
+        catch /^fugitive:/
+          return 'echoerr ' . string(v:exception)
+        endtry
+      endif
+    elseif exists('parents') && len(parents)
+      let file = parents[-1]
+    elseif len(commit)
+      let file = s:Relative()
+    elseif s:IsConflicted()
+      let file = s:Relative(':1:')
+      let post = 'echohl WarningMsg|echo "Use :Gdiffsplit! for 3 way diff"|echohl NONE|' . post
+    else
+      exe s:DirCheck()
+      let file = s:Relative(':0:')
+    endif
+    let spec = s:Generate(file)
+    if spec =~# '^fugitive:' && empty(s:DirCommitFile(spec)[2])
+      let spec = FugitiveVimPath(spec . s:Relative('/'))
+    endif
+    exe pre
+    let restore = s:diff_restore()
+    let w:fugitive_diff_restore = restore
+    if len(spec) && s:CompareAge(commit, s:DirCommitFile(spec)[1]) < 0
+      let mods = s:Mods(mods, 'rightbelow')
+    else
+      let mods = s:Mods(mods, 'leftabove')
+    endif
+    let mods = (a:autodir ? s:diff_modifier(2) : '') . mods
+    if &diffopt =~# 'vertical'
+      let diffopt = &diffopt
+      set diffopt-=vertical
+    endif
+    execute mods 'diffsplit' s:fnameescape(spec)
+    let &l:readonly = &l:readonly
+    redraw
+    let w:fugitive_diff_restore = restore
+    let winnr = winnr()
+    if getwinvar('#', '&diff')
+      if a:keepfocus
+        exe back
+      endif
+    endif
+    return post
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  finally
+    if exists('diffopt')
+      let &diffopt = diffopt
+    endif
+  endtry
+endfunction
+
+" Section: :GMove, :GRemove
+
+function! s:Move(force, rename, destination) abort
+  let dir = s:Dir()
+  exe s:DirCheck(dir)
+  if s:DirCommitFile(@%)[1] !~# '^0\=$' || empty(@%)
+    return 'echoerr ' . string('fugitive: mv not supported for this buffer')
+  endif
+  if a:destination =~# '^\a\+:\|^/'
+    let destination = a:destination
+  elseif a:destination =~# '^:/:\='
+    let destination = s:Tree(dir) . substitute(a:destination, '^:/:\=', '', '')
+  elseif a:destination =~# '^:(\%(top\|top,literal\|literal,top\))'
+    let destination = s:Tree(dir) . matchstr(a:destination, ')\zs.*')
+  elseif a:destination =~# '^:(literal)'
+    let destination = simplify(getcwd() . '/' . matchstr(a:destination, ')\zs.*'))
+  elseif a:rename
+    let destination = simplify(expand('%:p:s?[\/]$??:h') . '/' . a:destination)
+  elseif a:destination =~# '^\.\.\=\%(/\|$\)'
+    let destination = simplify(getcwd() . '/' . a:destination)
+  else
+    let destination = s:Tree(dir) . '/' . a:destination
+  endif
+  let destination = s:Slash(destination)
+  if isdirectory(@%)
+    setlocal noswapfile
+  endif
+  let [message, exec_error] = s:ChompError(['mv'] + (a:force ? ['-f'] : []) + ['--', expand('%:p'), destination], dir)
+  if exec_error
+    let v:errmsg = 'fugitive: '.message
+    return 'echoerr v:errmsg'
+  endif
+  if isdirectory(destination)
+    let destination = fnamemodify(s:sub(destination,'/$','').'/'.expand('%:t'),':.')
+  endif
+  let reload = '|call fugitive#ReloadStatus(' . string(dir) . ', 1)'
+  if empty(s:DirCommitFile(@%)[1])
+    if isdirectory(destination)
+      return 'keepalt edit '.s:fnameescape(destination) . reload
+    else
+      return 'keepalt saveas! '.s:fnameescape(destination) . reload
+    endif
+  else
+    return 'file '.s:fnameescape(fugitive#Find(':0:'.destination, dir)) . reload
+  endif
+endfunction
+
+function! fugitive#RenameComplete(A,L,P) abort
+  if a:A =~# '^[.:]\=/'
+    return fugitive#CompletePath(a:A)
+  else
+    let pre = s:Slash(fnamemodify(expand('%:p:s?[\/]$??'), ':h')) . '/'
+    return map(fugitive#CompletePath(pre.a:A), 'strpart(v:val, len(pre))')
+  endif
+endfunction
+
+function! fugitive#MoveCommand(line1, line2, range, bang, mods, arg, args) abort
+  return s:Move(a:bang, 0, a:arg)
+endfunction
+
+function! fugitive#RenameCommand(line1, line2, range, bang, mods, arg, args) abort
+  return s:Move(a:bang, 1, a:arg)
+endfunction
+
+function! s:Remove(after, force) abort
+  let dir = s:Dir()
+  exe s:DirCheck(dir)
+  if len(@%) && s:DirCommitFile(@%)[1] ==# ''
+    let cmd = ['rm']
+  elseif s:DirCommitFile(@%)[1] ==# '0'
+    let cmd = ['rm','--cached']
+  else
+    return 'echoerr ' . string('fugitive: rm not supported for this buffer')
+  endif
+  if a:force
+    let cmd += ['--force']
+  endif
+  let [message, exec_error] = s:ChompError(cmd + ['--', expand('%:p')], dir)
+  if exec_error
+    let v:errmsg = 'fugitive: '.s:sub(message,'error:.*\zs\n\(.*-f.*',' (add ! to force)')
+    return 'echoerr '.string(v:errmsg)
+  else
+    return a:after . (a:force ? '!' : ''). '|call fugitive#ReloadStatus(' . string(dir) . ', 1)'
+  endif
+endfunction
+
+function! fugitive#RemoveCommand(line1, line2, range, bang, mods, arg, args) abort
+  return s:Remove('edit', a:bang)
+endfunction
+
+function! fugitive#DeleteCommand(line1, line2, range, bang, mods, arg, args) abort
+  return s:Remove('bdelete', a:bang)
+endfunction
+
+" Section: :Git blame
+
+function! s:Keywordprg() abort
+  let args = ' --git-dir='.escape(s:Dir(),"\\\"' ")
+  if has('gui_running') && !has('win32')
+    return g:fugitive_git_executable . ' --no-pager' . args . ' log -1'
+  else
+    return g:fugitive_git_executable . args . ' show'
+  endif
+endfunction
+
+function! s:linechars(pattern) abort
+  let chars = strlen(s:gsub(matchstr(getline('.'), a:pattern), '.', '.'))
+  if exists('*synconcealed') && &conceallevel > 1
+    for col in range(1, chars)
+      let chars -= synconcealed(line('.'), col)[0]
+    endfor
+  endif
+  return chars
+endfunction
+
+function! s:BlameBufnr(...) abort
+  let state = s:TempState(bufname(a:0 ? a:1 : ''))
+  if get(state, 'filetype', '') ==# 'fugitiveblame'
+    return get(state, 'origin_bufnr', -1)
+  else
+    return -1
+  endif
+endfunction
+
+function! s:BlameCommitFileLnum(...) abort
+  let line = a:0 ? a:1 : getline('.')
+  let state = a:0 ? a:2 : s:TempState()
+  let commit = matchstr(line, '^\^\=[?*]*\zs\x\+')
+  if commit =~# '^0\+$'
+    let commit = ''
+  elseif has_key(state, 'blame_reverse_end')
+    let commit = get(s:LinesError(state.dir, 'rev-list', '--ancestry-path', '--reverse', commit . '..' . state.blame_reverse_end)[0], 0, '')
+  endif
+  let lnum = +matchstr(line, ' \zs\d\+\ze \%((\| *\d\+)\)')
+  let path = matchstr(line, '^\^\=[?*]*\x* \+\%(\d\+ \+\d\+ \+\)\=\zs.\{-\}\ze\s*\d\+ \%((\| *\d\+)\)')
+  if empty(path) && lnum
+    let path = get(state, 'blame_file', '')
+  endif
+  return [commit, path, lnum]
+endfunction
+
+function! s:BlameLeave() abort
+  let bufwinnr = bufwinnr(s:BlameBufnr())
+  if bufwinnr > 0
+    let bufnr = bufnr('')
+    exe bufwinnr . 'wincmd w'
+    return bufnr . 'bdelete'
+  endif
+  return ''
+endfunction
+
+function! s:BlameQuit() abort
+  let cmd = s:BlameLeave()
+  if empty(cmd)
+    return 'bdelete'
+  elseif len(s:DirCommitFile(@%)[1])
+    return cmd . '|Gedit'
+  else
+    return cmd
+  endif
+endfunction
+
+function! fugitive#BlameComplete(A, L, P) abort
+  return s:CompleteSub('blame', a:A, a:L, a:P)
+endfunction
+
+function! s:BlameSubcommand(line1, count, range, bang, mods, options) abort
+  let dir = s:Dir()
+  exe s:DirCheck(dir)
+  let flags = copy(a:options.subcommand_args)
+  let i = 0
+  let raw = 0
+  let commits = []
+  let files = []
+  let ranges = []
+  if a:line1 > 0 && a:count > 0 && a:range != 1
+    call extend(ranges, ['-L', a:line1 . ',' . a:count])
+  endif
+  while i < len(flags)
+    let match = matchlist(flags[i], '^\(-[a-zABDFH-KN-RT-Z]\)\ze\(.*\)')
+    if len(match) && len(match[2])
+      call insert(flags, match[1])
+      let flags[i+1] = '-' . match[2]
+      continue
+    endif
+    let arg = flags[i]
+    if arg =~# '^-p$\|^--\%(help\|porcelain\|line-porcelain\|incremental\)$'
+      let raw = 1
+    elseif arg ==# '--contents' && i + 1 < len(flags)
+      call extend(commits, remove(flags, i, i+1))
+      continue
+    elseif arg ==# '-L' && i + 1 < len(flags)
+      call extend(ranges, remove(flags, i, i+1))
+      continue
+    elseif arg =~# '^--contents='
+      call add(commits, remove(flags, i))
+      continue
+    elseif arg =~# '^-L.'
+      call add(ranges, remove(flags, i))
+      continue
+    elseif arg =~# '^-[GLS]$\|^--\%(date\|encoding\|contents\|ignore-rev\|ignore-revs-file\)$'
+      let i += 1
+      if i == len(flags)
+        echohl ErrorMsg
+        echo s:ChompError(['blame', arg])[0]
+        echohl NONE
+        return ''
+      endif
+    elseif arg ==# '--'
+      if i + 1 < len(flags)
+        call extend(files, remove(flags, i + 1, -1))
+      endif
+      call remove(flags, i)
+      break
+    elseif arg !~# '^-' && (s:HasOpt(flags, '--not') || arg !~# '^\^')
+      if index(flags, '--') >= 0
+        call add(commits, remove(flags, i))
+        continue
+      endif
+      if arg =~# '\.\.' && arg !~# '^\.\.\=\%(/\|$\)' && empty(commits)
+        call add(commits, remove(flags, i))
+        continue
+      endif
+      try
+        let dcf = s:DirCommitFile(fugitive#Find(arg, dir))
+        if len(dcf[1]) && empty(dcf[2])
+          call add(commits, remove(flags, i))
+          continue
+        endif
+      catch /^fugitive:/
+      endtry
+      call add(files, remove(flags, i))
+      continue
+    endif
+    let i += 1
+  endwhile
+  let file = substitute(get(files, 0, get(s:TempState(), 'blame_file', s:Relative('./', dir))), '^\.\%(/\|$\)', '', '')
+  if empty(commits) && len(files) > 1
+    call add(commits, remove(files, 1))
+  endif
+  exe s:BlameLeave()
+  try
+    let cmd = a:options.flags + ['--no-pager', '-c', 'blame.coloring=none', '-c', 'blame.blankBoundary=false', a:options.subcommand, '--show-number']
+    call extend(cmd, filter(copy(flags), 'v:val !~# "\\v^%(-b|--%(no-)=color-.*|--progress)$"'))
+    if a:count > 0 && empty(ranges)
+      let cmd += ['-L', (a:line1 ? a:line1 : line('.')) . ',' . (a:line1 ? a:line1 : line('.'))]
+    endif
+    call extend(cmd, ranges)
+    let tempname = tempname()
+    let temp = tempname . (raw ? '' : '.fugitiveblame')
+    if len(commits)
+      let cmd += commits
+    elseif empty(files) && len(matchstr(s:DirCommitFile(@%)[1], '^\x\x\+$'))
+      let cmd += [matchstr(s:DirCommitFile(@%)[1], '^\x\x\+$')]
+    elseif empty(files) && !s:HasOpt(flags, '--reverse')
+      let cmd += ['--contents', tempname . '.in']
+      silent execute 'keepalt %write ' . s:fnameescape(tempname . '.in')
+      let delete_in = 1
+    endif
+    let basecmd = [{'git': a:options.git, 'dir': dir}] + ['--literal-pathspecs'] + cmd + ['--'] + (len(files) ? files : [file])
+    let [err, exec_error] = s:TempCmd(temp, basecmd)
+    if exists('delete_in')
+      call delete(tempname . '.in')
+    endif
+    redraw
+    try
+      if exec_error
+        let lines = split(err, "\n")
+        if empty(lines)
+          let lines = readfile(temp)
+        endif
+        for i in range(len(lines))
+          if lines[i] =~# '^error: \|^fatal: '
+            echohl ErrorMsg
+            echon lines[i]
+            echohl NONE
+            break
+          else
+            echon lines[i]
+          endif
+          if i != len(lines) - 1
+            echon "\n"
+          endif
+        endfor
+        return ''
+      endif
+      let temp_state = {
+            \ 'dir': dir,
+            \ 'filetype': (raw ? '' : 'fugitiveblame'),
+            \ 'blame_options': a:options,
+            \ 'blame_flags': flags,
+            \ 'blame_file': file}
+      if s:HasOpt(flags, '--reverse')
+        let temp_state.blame_reverse_end = matchstr(get(commits, 0, ''), '\.\.\zs.*')
+      endif
+      if (a:line1 == 0 || a:range == 1) && a:count > 0
+        let edit = s:Mods(a:mods) . get(['edit', 'split', 'pedit', 'vsplit', 'tabedit'], a:count - (a:line1 ? a:line1 : 1), 'split')
+        return s:BlameCommit(edit, get(readfile(temp), 0, ''), temp_state)
+      else
+        let temp = s:Resolve(temp)
+        let s:temp_files[s:cpath(temp)] = temp_state
+        if len(ranges + commits + files) || raw
+          let mods = s:Mods(a:mods)
+          if a:count != 0
+            exe 'silent keepalt' mods 'split' s:fnameescape(temp)
+          elseif !&modified || a:bang || &bufhidden ==# 'hide' || (empty(&bufhidden) && &hidden)
+            exe 'silent' mods 'edit' . (a:bang ? '! ' : ' ') . s:fnameescape(temp)
+          else
+            return mods . 'edit ' . s:fnameescape(temp)
+          endif
+          return ''
+        endif
+        if a:mods =~# '\<tab\>'
+          silent tabedit %
+        endif
+        let bufnr = bufnr('')
+        let temp_state.origin_bufnr = bufnr
+        let restore = []
+        let mods = substitute(a:mods, '\<tab\>', '', 'g')
+        for winnr in range(winnr('$'),1,-1)
+          if getwinvar(winnr, '&scrollbind')
+            if !&l:scrollbind
+              call setwinvar(winnr, '&scrollbind', 0)
+            elseif winnr != winnr() && getwinvar(winnr, '&foldenable')
+              call setwinvar(winnr, '&foldenable', 0)
+              call add(restore, 'call setwinvar(bufwinnr('.winbufnr(winnr).'),"&foldenable",1)')
+            endif
+          endif
+          if exists('+cursorbind') && !&l:cursorbind && getwinvar(winnr, '&cursorbind')
+            call setwinvar(winnr, '&cursorbind', 0)
+          endif
+          if s:BlameBufnr(winbufnr(winnr)) > 0
+            execute winbufnr(winnr).'bdelete'
+          endif
+        endfor
+        let restore_winnr = 'bufwinnr(' . bufnr . ')'
+        if !&l:scrollbind
+          call add(restore, 'call setwinvar(' . restore_winnr . ',"&scrollbind",0)')
+        endif
+        if exists('+cursorbind') && !&l:cursorbind
+          call add(restore, 'call setwinvar(' . restore_winnr . ',"&cursorbind",0)')
+        endif
+        if &l:wrap
+          call add(restore, 'call setwinvar(' . restore_winnr . ',"&wrap",1)')
+        endif
+        if &l:foldenable
+          call add(restore, 'call setwinvar(' . restore_winnr . ',"&foldenable",1)')
+        endif
+        setlocal scrollbind nowrap nofoldenable
+        if exists('+cursorbind')
+          setlocal cursorbind
+        endif
+        let top = line('w0') + &scrolloff
+        let current = line('.')
+        exe 'silent keepalt' (a:bang ? s:Mods(mods) . 'split' : s:Mods(mods, 'leftabove') . 'vsplit') s:fnameescape(temp)
+        let w:fugitive_leave = join(restore, '|')
+        execute top
+        normal! zt
+        execute current
+        if exists('+cursorbind')
+          setlocal cursorbind
+        endif
+        setlocal nonumber scrollbind nowrap foldcolumn=0 nofoldenable winfixwidth
+        if exists('+relativenumber')
+          setlocal norelativenumber
+        endif
+        if exists('+signcolumn')
+          setlocal signcolumn=no
+        endif
+        execute "vertical resize ".(s:linechars('.\{-\}\s\+\d\+\ze)')+1)
+        call s:Map('n', 'A', ":<C-u>exe 'vertical resize '.(<SID>linechars('.\\{-\\}\\ze [0-9:/+-][0-9:/+ -]* \\d\\+)')+1+v:count)<CR>", '<silent>')
+        call s:Map('n', 'C', ":<C-u>exe 'vertical resize '.(<SID>linechars('^\\S\\+')+1+v:count)<CR>", '<silent>')
+        call s:Map('n', 'D', ":<C-u>exe 'vertical resize '.(<SID>linechars('.\\{-\\}\\ze\\d\\ze\\s\\+\\d\\+)')+1-v:count)<CR>", '<silent>')
+        redraw
+        syncbind
+      endif
+    endtry
+    return ''
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+endfunction
+
+function! s:BlameCommit(cmd, ...) abort
+  let line = a:0 ? a:1 : getline('.')
+  let state = a:0 ? a:2 : s:TempState()
+  let sigil = has_key(state, 'blame_reverse_end') ? '-' : '+'
+  let mods = (s:BlameBufnr() < 0 ? '' : &splitbelow ? "botright " : "topleft ")
+  let [commit, path, lnum] = s:BlameCommitFileLnum(line, state)
+  if empty(commit) && len(path) && has_key(state, 'blame_reverse_end')
+    let path = (len(state.blame_reverse_end) ? state.blame_reverse_end . ':' : ':(top)') . path
+    return fugitive#Open(mods . a:cmd, 0, '', '+' . lnum . ' ' . s:fnameescape(path), ['+' . lnum, path])
+  endif
+  if commit =~# '^0*$'
+    return 'echoerr ' . string('fugitive: no commit')
+  endif
+  if line =~# '^\^' && !has_key(state, 'blame_reverse_end')
+    let path = commit . ':' . path
+    return fugitive#Open(mods . a:cmd, 0, '', '+' . lnum . ' ' . s:fnameescape(path), ['+' . lnum, path])
+  endif
+  let cmd = fugitive#Open(mods . a:cmd, 0, '', commit, [commit])
+  if cmd =~# '^echoerr'
+    return cmd
+  endif
+  execute cmd
+  if a:cmd ==# 'pedit' || empty(path)
+    return ''
+  endif
+  if search('^diff .* b/\M'.escape(path,'\').'$','W')
+    call search('^+++')
+    let head = line('.')
+    while search('^@@ \|^diff ') && getline('.') =~# '^@@ '
+      let top = +matchstr(getline('.'),' ' . sigil .'\zs\d\+')
+      let len = +matchstr(getline('.'),' ' . sigil . '\d\+,\zs\d\+')
+      if lnum >= top && lnum <= top + len
+        let offset = lnum - top
+        if &scrolloff
+          +
+          normal! zt
+        else
+          normal! zt
+          +
+        endif
+        while offset > 0 && line('.') < line('$')
+          +
+          if getline('.') =~# '^[ ' . sigil . ']'
+            let offset -= 1
+          endif
+        endwhile
+        return 'normal! zv'
+      endif
+    endwhile
+    execute head
+    normal! zt
+  endif
+  return ''
+endfunction
+
+function! s:BlameJump(suffix, ...) abort
+  let suffix = a:suffix
+  let [commit, path, lnum] = s:BlameCommitFileLnum()
+  if empty(path)
+    return 'echoerr ' . string('fugitive: could not determine filename for blame')
+  endif
+  if commit =~# '^0*$'
+    let commit = 'HEAD'
+    let suffix = ''
+  endif
+  let offset = line('.') - line('w0')
+  let state = s:TempState()
+  let flags = get(state, 'blame_flags', [])
+  if a:0 && a:1
+    if s:HasOpt(flags, '--reverse')
+      call remove(flags, '--reverse')
+    else
+      call add(flags, '--reverse')
+    endif
+  endif
+  let blame_bufnr = s:BlameBufnr()
+  if blame_bufnr > 0
+    let bufnr = bufnr('')
+    let winnr = bufwinnr(blame_bufnr)
+    if winnr > 0
+      exe winnr.'wincmd w'
+      exe bufnr.'bdelete'
+    endif
+    execute 'Gedit' s:fnameescape(commit . suffix . ':' . path)
+    execute lnum
+  endif
+  let my_bufnr = bufnr('')
+  if blame_bufnr < 0
+    let blame_args = flags + [commit . suffix, '--', path]
+    let result = s:BlameSubcommand(0, 0, 0, 0, '', extend({'subcommand_args': blame_args}, state.blame_options, 'keep'))
+  else
+    let blame_args = flags
+    let result = s:BlameSubcommand(-1, -1, 0, 0, '', extend({'subcommand_args': blame_args}, state.blame_options, 'keep'))
+  endif
+  if bufnr('') == my_bufnr
+    return result
+  endif
+  execute result
+  execute lnum
+  let delta = line('.') - line('w0') - offset
+  if delta > 0
+    execute 'normal! '.delta."\<C-E>"
+  elseif delta < 0
+    execute 'normal! '.(-delta)."\<C-Y>"
+  endif
+  keepjumps syncbind
+  redraw
+  echo ':Git blame' s:fnameescape(blame_args)
+  return ''
+endfunction
+
+let s:hash_colors = {}
+
+function! fugitive#BlameSyntax() abort
+  let conceal = has('conceal') ? ' conceal' : ''
+  let flags = get(s:TempState(), 'blame_flags', [])
+  syn spell notoplevel
+  syn match FugitiveblameBlank                      "^\s\+\s\@=" nextgroup=FugitiveblameAnnotation,FugitiveblameScoreDebug,FugitiveblameOriginalFile,FugitiveblameOriginalLineNumber skipwhite
+  syn match FugitiveblameHash       "\%(^\^\=[?*]*\)\@<=\<\x\{7,\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameScoreDebug,FugitiveblameOriginalLineNumber,FugitiveblameOriginalFile skipwhite
+  syn match FugitiveblameUncommitted "\%(^\^\=\)\@<=\<0\{7,\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameScoreDebug,FugitiveblameOriginalLineNumber,FugitiveblameOriginalFile skipwhite
+  if s:HasOpt(flags, '-b') || FugitiveConfigGet('blame.blankBoundary') =~# '^1$\|^true$'
+    syn match FugitiveblameBoundaryIgnore "^\^[*?]*\x\{7,\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameScoreDebug,FugitiveblameOriginalLineNumber,FugitiveblameOriginalFile skipwhite
+  else
+    syn match FugitiveblameBoundary "^\^"
+  endif
+  syn match FugitiveblameScoreDebug        " *\d\+\s\+\d\+\s\@=" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile contained skipwhite
+  syn region FugitiveblameAnnotation matchgroup=FugitiveblameDelimiter start="(" end="\%(\s\d\+\)\@<=)" contained keepend oneline
+  syn match FugitiveblameTime "\<[0-9:/+-][0-9:/+ -]*[0-9:/+-]\%(\s\+\d\+)\)\@=" contained containedin=FugitiveblameAnnotation
+  exec 'syn match FugitiveblameLineNumber         "\s[[:digit:][:space:]]\{0,' . (len(line('$'))-1). '\}\d)\@=" contained containedin=FugitiveblameAnnotation' conceal
+  exec 'syn match FugitiveblameOriginalFile       "\s\%(\f\+\D\@<=\|\D\@=\f\+\)\%(\%(\s\+\d\+\)\=\s\%((\|\s*\d\+)\)\)\@=" contained nextgroup=FugitiveblameOriginalLineNumber,FugitiveblameAnnotation skipwhite' (s:HasOpt(flags, '--show-name', '-f') ? '' : conceal)
+  exec 'syn match FugitiveblameOriginalLineNumber "\s*\d\+\%(\s(\)\@=" contained nextgroup=FugitiveblameAnnotation skipwhite' (s:HasOpt(flags, '--show-number', '-n') ? '' : conceal)
+  exec 'syn match FugitiveblameOriginalLineNumber "\s*\d\+\%(\s\+\d\+)\)\@=" contained nextgroup=FugitiveblameShort skipwhite' (s:HasOpt(flags, '--show-number', '-n') ? '' : conceal)
+  syn match FugitiveblameShort              " \d\+)" contained contains=FugitiveblameLineNumber
+  syn match FugitiveblameNotCommittedYet "(\@<=Not Committed Yet\>" contained containedin=FugitiveblameAnnotation
+  hi def link FugitiveblameBoundary           Keyword
+  hi def link FugitiveblameHash               Identifier
+  hi def link FugitiveblameBoundaryIgnore     Ignore
+  hi def link FugitiveblameUncommitted        Ignore
+  hi def link FugitiveblameScoreDebug         Debug
+  hi def link FugitiveblameTime               PreProc
+  hi def link FugitiveblameLineNumber         Number
+  hi def link FugitiveblameOriginalFile       String
+  hi def link FugitiveblameOriginalLineNumber Float
+  hi def link FugitiveblameShort              FugitiveblameDelimiter
+  hi def link FugitiveblameDelimiter          Delimiter
+  hi def link FugitiveblameNotCommittedYet    Comment
+  if !get(g:, 'fugitive_dynamic_colors', 1) && !s:HasOpt(flags, '--color-lines') || s:HasOpt(flags, '--no-color-lines')
+    return
+  endif
+  let seen = {}
+  for lnum in range(1, line('$'))
+    let hash = matchstr(getline(lnum), '^\^\=\zs\x\{6\}')
+    if hash ==# '' || hash ==# '000000' || has_key(seen, hash)
+      continue
+    endif
+    let seen[hash] = 1
+    if &t_Co > 16 && get(g:, 'CSApprox_loaded') && !empty(findfile('autoload/csapprox/per_component.vim', escape(&rtp, ' ')))
+          \ && empty(get(s:hash_colors, hash))
+      let [s, r, g, b; __] = map(matchlist(hash, '\(\x\x\)\(\x\x\)\(\x\x\)'), 'str2nr(v:val,16)')
+      let color = csapprox#per_component#Approximate(r, g, b)
+      if color == 16 && &background ==# 'dark'
+        let color = 8
+      endif
+      let s:hash_colors[hash] = ' ctermfg='.color
+    else
+      let s:hash_colors[hash] = ''
+    endif
+    exe 'syn match FugitiveblameHash'.hash.'       "\%(^\^\=\)\@<='.hash.'\x\{1,34\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite'
+  endfor
+  call s:BlameRehighlight()
+endfunction
+
+function! s:BlameRehighlight() abort
+  for [hash, cterm] in items(s:hash_colors)
+    if !empty(cterm) || has('gui_running') || has('termguicolors') && &termguicolors
+      exe 'hi FugitiveblameHash'.hash.' guifg=#'.hash.get(s:hash_colors, hash, '')
+    else
+      exe 'hi link FugitiveblameHash'.hash.' Identifier'
+    endif
+  endfor
+endfunction
+
+function! s:BlameFileType() abort
+  setlocal nomodeline
+  setlocal foldmethod=manual
+  if len(s:Dir())
+    let &l:keywordprg = s:Keywordprg()
+  endif
+  let b:undo_ftplugin = 'setl keywordprg= foldmethod<'
+  if exists('+concealcursor')
+    setlocal concealcursor=nc conceallevel=2
+    let b:undo_ftplugin .= ' concealcursor< conceallevel<'
+  endif
+  if &modifiable
+    return ''
+  endif
+  call s:Map('n', '<F1>', ':help :Git_blame<CR>', '<silent>')
+  call s:Map('n', 'g?',   ':help :Git_blame<CR>', '<silent>')
+  if mapcheck('q', 'n') =~# '^$\|bdelete'
+    call s:Map('n', 'q',  ':exe <SID>BlameQuit()<Bar>echohl WarningMsg<Bar>echo ":Git blame q is deprecated in favor of gq"<Bar>echohl NONE<CR>', '<silent>')
+  endif
+  call s:Map('n', 'gq',   ':exe <SID>BlameQuit()<CR>', '<silent>')
+  call s:Map('n', '<2-LeftMouse>', ':<C-U>exe <SID>BlameCommit("exe <SID>BlameLeave()<Bar>edit")<CR>', '<silent>')
+  call s:Map('n', '<CR>', ':<C-U>exe <SID>BlameCommit("exe <SID>BlameLeave()<Bar>edit")<CR>', '<silent>')
+  call s:Map('n', '-',    ':<C-U>exe <SID>BlameJump("")<CR>', '<silent>')
+  call s:Map('n', 'P',    ':<C-U>exe <SID>BlameJump("^".v:count1)<CR>', '<silent>')
+  call s:Map('n', '~',    ':<C-U>exe <SID>BlameJump("~".v:count1)<CR>', '<silent>')
+  call s:Map('n', 'i',    ':<C-U>exe <SID>BlameCommit("exe <SID>BlameLeave()<Bar>edit")<CR>', '<silent>')
+  call s:Map('n', 'o',    ':<C-U>exe <SID>BlameCommit("split")<CR>', '<silent>')
+  call s:Map('n', 'O',    ':<C-U>exe <SID>BlameCommit("tabedit")<CR>', '<silent>')
+  call s:Map('n', 'p',    ':<C-U>exe <SID>BlameCommit("pedit")<CR>', '<silent>')
+endfunction
+
+augroup fugitive_blame
+  autocmd!
+  autocmd FileType fugitiveblame call s:BlameFileType()
+  autocmd ColorScheme,GUIEnter * call s:BlameRehighlight()
+  autocmd BufWinLeave * execute getwinvar(+bufwinnr(+expand('<abuf>')), 'fugitive_leave')
+augroup END
+
+" Section: :GBrowse
+
+let s:redirects = {}
+
+function! fugitive#BrowseCommand(line1, count, range, bang, mods, arg, args) abort
+  let dir = s:Dir()
+  exe s:DirCheck(dir)
+  try
+    let validremote = '\.\|\.\=/.*\|[[:alnum:]_-]\+\%(://.\{-\}\)\='
+    if a:arg ==# '-'
+      if a:count >= 0
+        return 'echoerr ' . string('fugitive: ''-'' no longer required to get persistent URL if range given')
+      else
+        return 'echoerr ' . string('fugitive: use :0GBrowse instead of :GBrowse -')
+      endif
+    elseif len(a:arg)
+      let remote = matchstr(a:arg, '@\zs\%('.validremote.'\)$')
+      let rev = substitute(a:arg, '@\%('.validremote.'\)$','','')
+    else
+      let remote = ''
+      let rev = ''
+    endif
+    if rev ==# ''
+      let rev = s:DirRev(@%)[1]
+    endif
+    if rev =~# '^:\=$'
+      let expanded = s:Relative()
+    else
+      let expanded = s:Expand(rev)
+    endif
+    let cdir = FugitiveVimPath(fugitive#CommonDir(dir))
+    for subdir in ['tags/', 'heads/', 'remotes/']
+      if expanded !~# '^[./]' && filereadable(cdir . '/refs/' . subdir . expanded)
+        let expanded = '.git/refs/' . subdir . expanded
+      endif
+    endfor
+    let full = fugitive#Find(expanded, dir)
+    let commit = ''
+    if full =~? '^fugitive:'
+      let [pathdir, commit, path] = s:DirCommitFile(full)
+      if commit =~# '^:\=\d$'
+        let commit = ''
+      endif
+      if commit =~ '..'
+        let type = s:TreeChomp('cat-file','-t',commit.s:sub(path,'^/',':'))
+        let branch = matchstr(expanded, '^[^:]*')
+      else
+        let type = 'blob'
+      endif
+      let path = path[1:-1]
+    elseif full =~? '^\a\a\+:[\/][\/]'
+      let path = s:Slash(full)
+      let type = 'url'
+    elseif empty(s:Tree(dir))
+      let path = '.git/' . full[strlen(dir)+1:-1]
+      let type = ''
+    else
+      let path = fugitive#Path(full, '/')[1:-1]
+      if path =~# '^\.git/'
+        let type = ''
+      elseif isdirectory(full) || empty(path)
+        let type = 'tree'
+      else
+        let type = 'blob'
+      endif
+    endif
+    if type ==# 'tree' && !empty(path)
+      let path = s:sub(path, '/\=$', '/')
+    endif
+    if path =~# '^\.git/.*HEAD$' && filereadable(dir . '/' . path[5:-1])
+      let body = readfile(dir . '/' . path[5:-1])[0]
+      if body =~# '^\x\{40,\}$'
+        let commit = body
+        let type = 'commit'
+        let path = ''
+      elseif body =~# '^ref: refs/'
+        let path = '.git/' . matchstr(body,'ref: \zs.*')
+      endif
+    endif
+
+    let merge = ''
+    if path =~# '^\.git/refs/remotes/.'
+      if empty(remote)
+        let remote = matchstr(path, '^\.git/refs/remotes/\zs[^/]\+')
+        let branch = matchstr(path, '^\.git/refs/remotes/[^/]\+/\zs.\+')
+      else
+        let merge = matchstr(path, '^\.git/refs/remotes/[^/]\+/\zs.\+')
+        let path = '.git/refs/heads/'.merge
+      endif
+    elseif path =~# '^\.git/refs/heads/.'
+      let branch = path[16:-1]
+    elseif !exists('branch')
+      let branch = FugitiveHead()
+    endif
+    if !empty(branch)
+      let r = fugitive#Config('branch.'.branch.'.remote')
+      let m = fugitive#Config('branch.'.branch.'.merge')[11:-1]
+      if r ==# '.' && !empty(m)
+        let r2 = fugitive#Config('branch.'.m.'.remote')
+        if r2 !~# '^\.\=$'
+          let r = r2
+          let m = fugitive#Config('branch.'.m.'.merge')[11:-1]
+        endif
+      endif
+      if empty(remote)
+        let remote = r
+      endif
+      if r ==# '.' || r ==# remote
+        let merge = m
+        if path =~# '^\.git/refs/heads/.'
+          let path = '.git/refs/heads/'.merge
+        endif
+      endif
+    endif
+
+    let line1 = a:count > 0 ? a:line1 : 0
+    let line2 = a:count > 0 ? a:count : 0
+    if empty(commit) && path !~# '^\.git/'
+      if a:count < 0 && !empty(merge)
+        let commit = merge
+      else
+        let commit = ''
+        if len(merge)
+          let owner = s:Owner(@%)
+          let [commit, exec_error] = s:ChompError(['merge-base', 'refs/remotes/' . remote . '/' . merge, empty(owner) ? 'HEAD' : owner, '--'])
+          if exec_error
+            let commit = ''
+          endif
+          if a:count > 0 && empty(a:arg) && commit =~# '^\x\{40,\}$'
+            let blame_list = tempname()
+            call writefile([commit, ''], blame_list, 'b')
+            let blame_in = tempname()
+            silent exe '%write' blame_in
+            let [blame, exec_error] = s:LinesError(['-c', 'blame.coloring=none', 'blame', '--contents', blame_in, '-L', a:line1.','.a:count, '-S', blame_list, '-s', '--show-number', './' . path])
+            if !exec_error
+              let blame_regex = '^\^\x\+\s\+\zs\d\+\ze\s'
+              if get(blame, 0) =~# blame_regex && get(blame, -1) =~# blame_regex
+                let line1 = +matchstr(blame[0], blame_regex)
+                let line2 = +matchstr(blame[-1], blame_regex)
+              else
+                call s:throw("Can't browse to uncommitted change")
+              endif
+            endif
+          endif
+        endif
+      endif
+      if empty(commit)
+        let commit = readfile(fugitive#Find('.git/HEAD', dir), '', 1)[0]
+      endif
+      let i = 0
+      while commit =~# '^ref: ' && i < 10
+        let ref_file = cdir . '/' . commit[5:-1]
+        if getfsize(ref_file) > 0
+          let commit = readfile(ref_file, '', 1)[0]
+        else
+          let commit = fugitive#RevParse(commit[5:-1], dir)
+        endif
+        let i -= 1
+      endwhile
+    endif
+
+    if empty(remote)
+      let remote = '.'
+    endif
+    let raw = fugitive#RemoteUrl(remote)
+    if empty(raw)
+      let raw = remote
+    endif
+
+    if raw =~# '^https\=://' && s:executable('curl')
+      if !has_key(s:redirects, raw)
+        let s:redirects[raw] = matchstr(system('curl -I ' .
+              \ s:shellesc(raw . '/info/refs?service=git-upload-pack')),
+              \ 'Location: \zs\S\+\ze/info/refs?')
+      endif
+      if len(s:redirects[raw])
+        let raw = s:redirects[raw]
+      endif
+    endif
+
+    let opts = {
+          \ 'dir': dir,
+          \ 'repo': fugitive#repo(dir),
+          \ 'remote': raw,
+          \ 'revision': 'No longer provided',
+          \ 'commit': commit,
+          \ 'path': path,
+          \ 'type': type,
+          \ 'line1': line1,
+          \ 'line2': line2}
+
+    if type ==# 'url'
+      let url = path
+    else
+      let url = ''
+      for Handler in get(g:, 'fugitive_browse_handlers', [])
+        let url = call(Handler, [copy(opts)])
+        if !empty(url)
+          break
+        endif
+      endfor
+    endif
+
+    if empty(url)
+      call s:throw("No GBrowse handler installed for '".raw."'")
+    endif
+
+    let url = s:gsub(url, '[ <>]', '\="%".printf("%02X",char2nr(submatch(0)))')
+    if a:bang
+      if has('clipboard')
+        let @+ = url
+      endif
+      return 'echomsg '.string(url)
+    elseif exists(':Browse') == 2
+      return 'echomsg '.string(url).'|Browse '.url
+    elseif exists(':OpenBrowser') == 2
+      return 'echomsg '.string(url).'|OpenBrowser '.url
+    else
+      if !exists('g:loaded_netrw')
+        runtime! autoload/netrw.vim
+      endif
+      if exists('*netrw#BrowseX')
+        return 'echomsg '.string(url).'|call netrw#BrowseX('.string(url).', 0)'
+      elseif exists('*netrw#NetrwBrowseX')
+        return 'echomsg '.string(url).'|call netrw#NetrwBrowseX('.string(url).', 0)'
+      else
+        return 'echoerr ' . string('Netrw not found. Define your own :Browse to use :GBrowse')
+      endif
+    endif
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+endfunction
+
+" Section: Go to file
+
+let s:ref_header = '\%(Merge\|Rebase\|Upstream\|Pull\|Push\)'
+
+nnoremap <SID>: :<C-U><C-R>=v:count ? v:count : ''<CR>
+function! fugitive#MapCfile(...) abort
+  exe 'cnoremap <buffer> <expr> <Plug><cfile>' (a:0 ? a:1 : 'fugitive#Cfile()')
+  let b:undo_ftplugin = get(b:, 'undo_ftplugin', 'exe') . '|sil! exe "cunmap <buffer> <Plug><cfile>"'
+  if !exists('g:fugitive_no_maps')
+    call s:Map('n', 'gf',          '<SID>:find <Plug><cfile><CR>', '<silent><unique>', 1)
+    call s:Map('n', '<C-W>f',     '<SID>:sfind <Plug><cfile><CR>', '<silent><unique>', 1)
+    call s:Map('n', '<C-W><C-F>', '<SID>:sfind <Plug><cfile><CR>', '<silent><unique>', 1)
+    call s:Map('n', '<C-W>gf',  '<SID>:tabfind <Plug><cfile><CR>', '<silent><unique>', 1)
+    call s:Map('c', '<C-R><C-F>', '<Plug><cfile>', '<silent><unique>', 1)
+  endif
+endfunction
+
+function! s:ContainingCommit() abort
+  let commit = s:Owner(@%)
+  return empty(commit) ? 'HEAD' : commit
+endfunction
+
+function! s:SquashArgument(...) abort
+  if &filetype == 'fugitive'
+    let commit = matchstr(getline('.'), '^\%(\%(\x\x\x\)\@!\l\+\s\+\)\=\zs[0-9a-f]\{4,\}\ze \|^' . s:ref_header . ': \zs\S\+')
+  elseif has_key(s:temp_files, s:cpath(expand('%:p')))
+    let commit = matchstr(getline('.'), '\<\x\{4,\}\>')
+  else
+    let commit = s:Owner(@%)
+  endif
+  return len(commit) && a:0 ? printf(a:1, commit) : commit
+endfunction
+
+function! s:RebaseArgument() abort
+  return s:SquashArgument(' %s^')
+endfunction
+
+function! s:NavigateUp(count) abort
+  let rev = substitute(s:DirRev(@%)[1], '^$', ':', 'g')
+  let c = a:count
+  while c
+    if rev =~# ':.*/.'
+      let rev = matchstr(rev, '.*\ze/.\+', '')
+    elseif rev =~# '.:.'
+      let rev = matchstr(rev, '^.[^:]*:')
+    elseif rev =~# '^:'
+      let rev = 'HEAD^{}'
+    elseif rev =~# ':$'
+      let rev = rev[0:-2]
+    else
+      return rev.'~'.c
+    endif
+    let c -= 1
+  endwhile
+  return rev
+endfunction
+
+function! s:MapMotion(lhs, rhs) abort
+  call s:Map('n', a:lhs, ":<C-U>" . a:rhs . "<CR>", "<silent>")
+  call s:Map('o', a:lhs, ":<C-U>" . a:rhs . "<CR>", "<silent>")
+  call s:Map('x', a:lhs, ":<C-U>exe 'normal! gv'<Bar>" . a:rhs . "<CR>", "<silent>")
+endfunction
+
+function! fugitive#MapJumps(...) abort
+  if !&modifiable
+    if get(b:, 'fugitive_type', '') ==# 'blob'
+      let blame_map = 'Git blame<C-R>=v:count ? " --reverse" : ""<CR><CR>'
+      call s:Map('n', '<2-LeftMouse>', ':<C-U>0,1' . blame_map, '<silent>')
+      call s:Map('n', '<CR>', ':<C-U>0,1' . blame_map, '<silent>')
+      call s:Map('n', 'o',    ':<C-U>0,2' . blame_map, '<silent>')
+      call s:Map('n', 'p',    ':<C-U>0,3' . blame_map, '<silent>')
+      call s:Map('n', 'gO',   ':<C-U>0,4' . blame_map, '<silent>')
+      call s:Map('n', 'O',    ':<C-U>0,5' . blame_map, '<silent>')
+
+      call s:Map('n', 'D',  ":<C-U>call fugitive#DiffClose()<Bar>Gdiffsplit!<Bar>redraw<Bar>echohl WarningMsg<Bar> echo ':Gstatus D is deprecated in favor of dd'<Bar>echohl NONE<CR>", '<silent>')
+      call s:Map('n', 'dd', ":<C-U>call fugitive#DiffClose()<Bar>Gdiffsplit!<CR>", '<silent>')
+      call s:Map('n', 'dh', ":<C-U>call fugitive#DiffClose()<Bar>Ghdiffsplit!<CR>", '<silent>')
+      call s:Map('n', 'ds', ":<C-U>call fugitive#DiffClose()<Bar>Ghdiffsplit!<CR>", '<silent>')
+      call s:Map('n', 'dv', ":<C-U>call fugitive#DiffClose()<Bar>Gvdiffsplit!<CR>", '<silent>')
+      call s:Map('n', 'd?', ":<C-U>help fugitive_d<CR>", '<silent>')
+
+    else
+      call s:Map('n', '<2-LeftMouse>', ':<C-U>exe <SID>GF("edit")<CR>', '<silent>')
+      call s:Map('n', '<CR>', ':<C-U>exe <SID>GF("edit")<CR>', '<silent>')
+      call s:Map('n', 'o',    ':<C-U>exe <SID>GF("split")<CR>', '<silent>')
+      call s:Map('n', 'gO',   ':<C-U>exe <SID>GF("vsplit")<CR>', '<silent>')
+      call s:Map('n', 'O',    ':<C-U>exe <SID>GF("tabedit")<CR>', '<silent>')
+      call s:Map('n', 'p',    ':<C-U>exe <SID>GF("pedit")<CR>', '<silent>')
+
+      if !exists('g:fugitive_no_maps')
+        if exists(':CtrlP') && get(g:, 'ctrl_p_map') =~? '^<c-p>$'
+          nnoremap <buffer> <silent> <C-P> :<C-U>execute line('.') == 1 ? 'CtrlP ' . fnameescape(<SID>Tree()) : <SID>PreviousItem(v:count1)<CR>
+        else
+          nnoremap <buffer> <silent> <C-P> :<C-U>execute <SID>PreviousItem(v:count1)<CR>
+        endif
+        nnoremap <buffer> <silent> <C-N> :<C-U>execute <SID>NextItem(v:count1)<CR>
+      endif
+      call s:MapMotion('(', 'exe <SID>PreviousItem(v:count1)')
+      call s:MapMotion(')', 'exe <SID>NextItem(v:count1)')
+      call s:MapMotion('K', 'exe <SID>PreviousHunk(v:count1)')
+      call s:MapMotion('J', 'exe <SID>NextHunk(v:count1)')
+      call s:MapMotion('[c', 'exe <SID>PreviousHunk(v:count1)')
+      call s:MapMotion(']c', 'exe <SID>NextHunk(v:count1)')
+      call s:MapMotion('[/', 'exe <SID>PreviousFile(v:count1)')
+      call s:MapMotion(']/', 'exe <SID>NextFile(v:count1)')
+      call s:MapMotion('[m', 'exe <SID>PreviousFile(v:count1)')
+      call s:MapMotion(']m', 'exe <SID>NextFile(v:count1)')
+      call s:MapMotion('[[', 'exe <SID>PreviousSection(v:count1)')
+      call s:MapMotion(']]', 'exe <SID>NextSection(v:count1)')
+      call s:MapMotion('[]', 'exe <SID>PreviousSectionEnd(v:count1)')
+      call s:MapMotion('][', 'exe <SID>NextSectionEnd(v:count1)')
+      call s:Map('nxo', '*', '<SID>PatchSearchExpr(0)', '<expr>')
+      call s:Map('nxo', '#', '<SID>PatchSearchExpr(1)', '<expr>')
+    endif
+    call s:Map('n', 'S',    ':<C-U>echoerr "Use gO"<CR>', '<silent>')
+    call s:Map('n', 'dq', ":<C-U>call fugitive#DiffClose()<CR>", '<silent>')
+    call s:Map('n', '-', ":<C-U>exe 'Gedit ' . <SID>fnameescape(<SID>NavigateUp(v:count1))<Bar> if getline(1) =~# '^tree \x\{40,\}$' && empty(getline(2))<Bar>call search('^'.escape(expand('#:t'),'.*[]~\').'/\=$','wc')<Bar>endif<CR>", '<silent>')
+    call s:Map('n', 'P',     ":<C-U>exe 'Gedit ' . <SID>fnameescape(<SID>ContainingCommit().'^'.v:count1.<SID>Relative(':'))<CR>", '<silent>')
+    call s:Map('n', '~',     ":<C-U>exe 'Gedit ' . <SID>fnameescape(<SID>ContainingCommit().'~'.v:count1.<SID>Relative(':'))<CR>", '<silent>')
+    call s:Map('n', 'C',     ":<C-U>exe 'Gedit ' . <SID>fnameescape(<SID>ContainingCommit())<CR>", '<silent>')
+    call s:Map('n', 'cp',    ":<C-U>echoerr 'Use gC'<CR>", '<silent>')
+    call s:Map('n', 'gC',    ":<C-U>exe 'Gpedit ' . <SID>fnameescape(<SID>ContainingCommit())<CR>", '<silent>')
+    call s:Map('n', 'gc',    ":<C-U>exe 'Gpedit ' . <SID>fnameescape(<SID>ContainingCommit())<CR>", '<silent>')
+    call s:Map('n', 'gi',    ":<C-U>exe 'Gsplit' (v:count ? '.gitignore' : '.git/info/exclude')<CR>", '<silent>')
+    call s:Map('x', 'gi',    ":<C-U>exe 'Gsplit' (v:count ? '.gitignore' : '.git/info/exclude')<CR>", '<silent>')
+
+    call s:Map('n', 'c<Space>', ':Git commit<Space>')
+    call s:Map('n', 'c<CR>', ':Git commit<CR>')
+    call s:Map('n', 'cv<Space>', ':tab Git commit -v<Space>')
+    call s:Map('n', 'cv<CR>', ':tab Git commit -v<CR>')
+    call s:Map('n', 'ca', ':<C-U>Git commit --amend<CR>', '<silent>')
+    call s:Map('n', 'cc', ':<C-U>Git commit<CR>', '<silent>')
+    call s:Map('n', 'ce', ':<C-U>Git commit --amend --no-edit<CR>', '<silent>')
+    call s:Map('n', 'cw', ':<C-U>Git commit --amend --only<CR>', '<silent>')
+    call s:Map('n', 'cva', ':<C-U>tab Git commit -v --amend<CR>', '<silent>')
+    call s:Map('n', 'cvc', ':<C-U>tab Git commit -v<CR>', '<silent>')
+    call s:Map('n', 'cRa', ':<C-U>Git commit --reset-author --amend<CR>', '<silent>')
+    call s:Map('n', 'cRe', ':<C-U>Git commit --reset-author --amend --no-edit<CR>', '<silent>')
+    call s:Map('n', 'cRw', ':<C-U>Git commit --reset-author --amend --only<CR>', '<silent>')
+    call s:Map('n', 'cf', ':<C-U>Git commit --fixup=<C-R>=<SID>SquashArgument()<CR>')
+    call s:Map('n', 'cF', ':<C-U><Bar>Git -c sequence.editor=true rebase --interactive --autosquash<C-R>=<SID>RebaseArgument()<CR><Home>Git commit --fixup=<C-R>=<SID>SquashArgument()<CR>')
+    call s:Map('n', 'cs', ':<C-U>Git commit --no-edit --squash=<C-R>=<SID>SquashArgument()<CR>')
+    call s:Map('n', 'cS', ':<C-U><Bar>Git -c sequence.editor=true rebase --interactive --autosquash<C-R>=<SID>RebaseArgument()<CR><Home>Git commit --no-edit --squash=<C-R>=<SID>SquashArgument()<CR>')
+    call s:Map('n', 'cA', ':<C-U>Git commit --edit --squash=<C-R>=<SID>SquashArgument()<CR>')
+    call s:Map('n', 'c?', ':<C-U>help fugitive_c<CR>', '<silent>')
+
+    call s:Map('n', 'cr<Space>', ':Git revert<Space>')
+    call s:Map('n', 'cr<CR>', ':Git revert<CR>')
+    call s:Map('n', 'crc', ':<C-U>Git revert <C-R>=<SID>SquashArgument()<CR><CR>', '<silent>')
+    call s:Map('n', 'crn', ':<C-U>Git revert --no-commit <C-R>=<SID>SquashArgument()<CR><CR>', '<silent>')
+    call s:Map('n', 'cr?', ':<C-U>help fugitive_cr<CR>', '<silent>')
+
+    call s:Map('n', 'cm<Space>', ':Git merge<Space>')
+    call s:Map('n', 'cm<CR>', ':Git merge<CR>')
+    call s:Map('n', 'cmt', ':Git mergetool')
+    call s:Map('n', 'cm?', ':<C-U>help fugitive_cm<CR>', '<silent>')
+
+    call s:Map('n', 'cz<Space>', ':Git stash<Space>')
+    call s:Map('n', 'cz<CR>', ':Git stash<CR>')
+    call s:Map('n', 'cza', ':<C-U>Git stash apply --quiet --index stash@{<C-R>=v:count<CR>}<CR>')
+    call s:Map('n', 'czA', ':<C-U>Git stash apply --quiet stash@{<C-R>=v:count<CR>}<CR>')
+    call s:Map('n', 'czp', ':<C-U>Git stash pop --quiet --index stash@{<C-R>=v:count<CR>}<CR>')
+    call s:Map('n', 'czP', ':<C-U>Git stash pop --quiet stash@{<C-R>=v:count<CR>}<CR>')
+    call s:Map('n', 'czv', ':<C-U>exe "Gedit" fugitive#RevParse("stash@{" . v:count . "}")<CR>', '<silent>')
+    call s:Map('n', 'czw', ':<C-U>Git stash --keep-index<C-R>=v:count > 1 ? " --all" : v:count ? " --include-untracked" : ""<CR><CR>')
+    call s:Map('n', 'czz', ':<C-U>Git stash <C-R>=v:count > 1 ? " --all" : v:count ? " --include-untracked" : ""<CR><CR>')
+    call s:Map('n', 'cz?', ':<C-U>help fugitive_cz<CR>', '<silent>')
+
+    call s:Map('n', 'co<Space>', ':Git checkout<Space>')
+    call s:Map('n', 'co<CR>', ':Git checkout<CR>')
+    call s:Map('n', 'coo', ':<C-U>Git checkout <C-R>=<SID>SquashArgument()<CR> --<CR>')
+    call s:Map('n', 'co?', ':<C-U>help fugitive_co<CR>', '<silent>')
+
+    call s:Map('n', 'cb<Space>', ':Git branch<Space>')
+    call s:Map('n', 'cb<CR>', ':Git branch<CR>')
+    call s:Map('n', 'cb?', ':<C-U>help fugitive_cb<CR>', '<silent>')
+
+    call s:Map('n', 'r<Space>', ':Git rebase<Space>')
+    call s:Map('n', 'r<CR>', ':Git rebase<CR>')
+    call s:Map('n', 'ri', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><CR>', '<silent>')
+    call s:Map('n', 'rf', ':<C-U>Git -c sequence.editor=true rebase --interactive --autosquash<C-R>=<SID>RebaseArgument()<CR><CR>', '<silent>')
+    call s:Map('n', 'ru', ':<C-U>Git rebase --interactive @{upstream}<CR>', '<silent>')
+    call s:Map('n', 'rp', ':<C-U>Git rebase --interactive @{push}<CR>', '<silent>')
+    call s:Map('n', 'rw', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/reword/e<CR>', '<silent>')
+    call s:Map('n', 'rm', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/edit/e<CR>', '<silent>')
+    call s:Map('n', 'rd', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/drop/e<CR>', '<silent>')
+    call s:Map('n', 'rk', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/drop/e<CR>', '<silent>')
+    call s:Map('n', 'rx', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/drop/e<CR>', '<silent>')
+    call s:Map('n', 'rr', ':<C-U>Git rebase --continue<CR>', '<silent>')
+    call s:Map('n', 'rs', ':<C-U>Git rebase --skip<CR>', '<silent>')
+    call s:Map('n', 're', ':<C-U>Git rebase --edit-todo<CR>', '<silent>')
+    call s:Map('n', 'ra', ':<C-U>Git rebase --abort<CR>', '<silent>')
+    call s:Map('n', 'r?', ':<C-U>help fugitive_r<CR>', '<silent>')
+
+    call s:Map('n', '.',     ":<C-U> <C-R>=<SID>fnameescape(fugitive#Real(@%))<CR><Home>")
+    call s:Map('x', '.',     ":<C-U> <C-R>=<SID>fnameescape(fugitive#Real(@%))<CR><Home>")
+    call s:Map('n', 'g?',    ":<C-U>help fugitive-map<CR>", '<silent>')
+    call s:Map('n', '<F1>',  ":<C-U>help fugitive-map<CR>", '<silent>')
+  endif
+
+  let old_browsex = maparg('<Plug>NetrwBrowseX', 'n')
+  let new_browsex = substitute(old_browsex, '\Cnetrw#CheckIfRemote(\%(netrw#GX()\)\=)', '0', 'g')
+  let new_browsex = substitute(new_browsex, 'netrw#GX()\|expand((exists("g:netrw_gx")? g:netrw_gx : ''<cfile>''))', 'fugitive#GX()', 'g')
+  if new_browsex !=# old_browsex
+    exe 'nnoremap <silent> <buffer> <Plug>NetrwBrowseX' new_browsex
+  endif
+endfunction
+
+function! fugitive#GX() abort
+  try
+    let results = &filetype ==# 'fugitive' ? s:StatusCfile() : &filetype ==# 'git' ? s:cfile() : []
+    if len(results) && len(results[0])
+      return FugitiveReal(s:Generate(results[0]))
+    endif
+  catch /^fugitive:/
+  endtry
+  return expand(get(g:, 'netrw_gx', expand('<cfile>')))
+endfunction
+
+function! s:StatusCfile(...) abort
+  let tree = s:Tree()
+  if empty(tree)
+    return ['']
+  endif
+  let lead = s:cpath(tree, getcwd()) ? './' : tree . '/'
+  let info = s:StageInfo()
+  let line = getline('.')
+  if len(info.sigil) && len(info.section) && len(info.paths)
+    if info.section ==# 'Unstaged' && info.sigil !=# '-'
+      return [lead . info.relative[0], info.offset, 'normal!zv']
+    elseif info.section ==# 'Staged' && info.sigil ==# '-'
+      return ['@:' . info.relative[0], info.offset, 'normal!zv']
+    else
+      return [':0:' . info.relative[0], info.offset, 'normal!zv']
+    endif
+  elseif len(info.paths)
+    return [lead . info.relative[0]]
+  elseif len(info.commit)
+    return [info.commit]
+  elseif line =~# '^' . s:ref_header . ': \|^Head: '
+    return [matchstr(line, ' \zs.*')]
+  else
+    return ['']
+  endif
+endfunction
+
+function! fugitive#StatusCfile() abort
+  let file = s:Generate(s:StatusCfile()[0])
+  return empty(file) ? fugitive#Cfile() : s:fnameescape(file)
+endfunction
+
+function! s:MessageCfile(...) abort
+  let tree = s:Tree()
+  if empty(tree)
+    return ''
+  endif
+  let lead = s:cpath(tree, getcwd()) ? './' : tree . '/'
+  if getline('.') =~# '^.\=\trenamed:.* -> '
+    return lead . matchstr(getline('.'),' -> \zs.*')
+  elseif getline('.') =~# '^.\=\t\(\k\| \)\+\p\?: *.'
+    return lead . matchstr(getline('.'),': *\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$')
+  elseif getline('.') =~# '^.\=\t.'
+    return lead . matchstr(getline('.'),'\t\zs.*')
+  elseif getline('.') =~# ': needs merge$'
+    return lead . matchstr(getline('.'),'.*\ze: needs merge$')
+  elseif getline('.') =~# '^\%(. \)\=Not currently on any branch.$'
+    return 'HEAD'
+  elseif getline('.') =~# '^\%(. \)\=On branch '
+    return 'refs/heads/'.getline('.')[12:]
+  elseif getline('.') =~# "^\\%(. \\)\=Your branch .*'"
+    return matchstr(getline('.'),"'\\zs\\S\\+\\ze'")
+  else
+    return ''
+  endif
+endfunction
+
+function! fugitive#MessageCfile() abort
+  let file = s:Generate(s:MessageCfile())
+  return empty(file) ? fugitive#Cfile() : s:fnameescape(file)
+endfunction
+
+function! s:cfile() abort
+  if empty(FugitiveGitDir())
+    return []
+  endif
+  try
+    let myhash = s:DirRev(@%)[1]
+    if len(myhash)
+      try
+        let myhash = fugitive#RevParse(myhash)
+      catch /^fugitive:/
+        let myhash = ''
+      endtry
+    endif
+    if empty(myhash) && get(s:TempState(), 'filetype', '') ==# 'git'
+      let lnum = line('.')
+      while lnum > 0
+        if getline(lnum) =~# '^\%(commit\|tag\) \w'
+          let myhash = matchstr(getline(lnum),'^\w\+ \zs\S\+')
+          break
+        endif
+        let lnum -= 1
+      endwhile
+    endif
+
+    let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
+
+    let treebase = substitute(s:DirCommitFile(@%)[1], '^\d$', ':&', '') . ':' .
+          \ s:Relative('') . (s:Relative('') =~# '^$\|/$' ? '' : '/')
+
+    if getline('.') =~# '^\d\{6\} \l\{3,8\} \x\{40,\}\t'
+      return [treebase . s:sub(matchstr(getline('.'),'\t\zs.*'),'/$','')]
+    elseif showtree
+      return [treebase . s:sub(getline('.'),'/$','')]
+
+    else
+
+      let dcmds = []
+
+      " Index
+      if getline('.') =~# '^\d\{6\} \x\{40,\} \d\t'
+        let ref = matchstr(getline('.'),'\x\{40,\}')
+        let file = ':'.s:sub(matchstr(getline('.'),'\d\t.*'),'\t',':')
+        return [file]
+      endif
+
+      if getline('.') =~# '^ref: '
+        let ref = strpart(getline('.'),5)
+
+      elseif getline('.') =~# '^commit \x\{40,\}\>'
+        let ref = matchstr(getline('.'),'\x\{40,\}')
+        return [ref]
+
+      elseif getline('.') =~# '^parent \x\{40,\}\>'
+        let ref = matchstr(getline('.'),'\x\{40,\}')
+        let line = line('.')
+        let parent = 0
+        while getline(line) =~# '^parent '
+          let parent += 1
+          let line -= 1
+        endwhile
+        return [ref]
+
+      elseif getline('.') =~# '^tree \x\{40,\}$'
+        let ref = matchstr(getline('.'),'\x\{40,\}')
+        if len(myhash) && fugitive#RevParse(myhash.':') ==# ref
+          let ref = myhash.':'
+        endif
+        return [ref]
+
+      elseif getline('.') =~# '^object \x\{40,\}$' && getline(line('.')+1) =~ '^type \%(commit\|tree\|blob\)$'
+        let ref = matchstr(getline('.'),'\x\{40,\}')
+        let type = matchstr(getline(line('.')+1),'type \zs.*')
+
+      elseif getline('.') =~# '^\l\{3,8\} '.myhash.'$'
+        let ref = s:DirRev(@%)[1]
+
+      elseif getline('.') =~# '^\l\{3,8\} \x\{40,\}\>'
+        let ref = matchstr(getline('.'),'\x\{40,\}')
+        echoerr "warning: unknown context ".matchstr(getline('.'),'^\l*')
+
+      elseif getline('.') =~# '^[+-]\{3\} [abciow12]\=/'
+        let ref = getline('.')[4:]
+
+      elseif getline('.') =~# '^[+-]' && search('^@@ -\d\+\%(,\d\+\)\= +\d\+','bnW')
+        let type = getline('.')[0]
+        let lnum = line('.') - 1
+        let offset = 0
+        while getline(lnum) !~# '^@@ -\d\+\%(,\d\+\)\= +\d\+'
+          if getline(lnum) =~# '^[ '.type.']'
+            let offset += 1
+          endif
+          let lnum -= 1
+        endwhile
+        let offset += matchstr(getline(lnum), type.'\zs\d\+')
+        let ref = getline(search('^'.type.'\{3\} [abciow12]/','bnW'))[4:-1]
+        let dcmds = [offset, 'normal!zv']
+
+      elseif getline('.') =~# '^rename from '
+        let ref = 'a/'.getline('.')[12:]
+      elseif getline('.') =~# '^rename to '
+        let ref = 'b/'.getline('.')[10:]
+
+      elseif getline('.') =~# '^@@ -\d\+\%(,\d\+\)\= +\d\+'
+        let diff = getline(search('^diff --git \%([abciow12]/.*\|/dev/null\) \%([abciow12]/.*\|/dev/null\)', 'bcnW'))
+        let offset = matchstr(getline('.'), '+\zs\d\+')
+
+        let dref = matchstr(diff, '\Cdiff --git \zs\%([abciow12]/.*\|/dev/null\)\ze \%([abciow12]/.*\|/dev/null\)')
+        let ref = matchstr(diff, '\Cdiff --git \%([abciow12]/.*\|/dev/null\) \zs\%([abciow12]/.*\|/dev/null\)')
+        let dcmd = 'Gdiffsplit! +'.offset
+
+      elseif getline('.') =~# '^diff --git \%([abciow12]/.*\|/dev/null\) \%([abciow12]/.*\|/dev/null\)'
+        let dref = matchstr(getline('.'),'\Cdiff --git \zs\%([abciow12]/.*\|/dev/null\)\ze \%([abciow12]/.*\|/dev/null\)')
+        let ref = matchstr(getline('.'),'\Cdiff --git \%([abciow12]/.*\|/dev/null\) \zs\%([abciow12]/.*\|/dev/null\)')
+        let dcmd = 'Gdiffsplit!'
+
+      elseif getline('.') =~# '^index ' && getline(line('.')-1) =~# '^diff --git \%([abciow12]/.*\|/dev/null\) \%([abciow12]/.*\|/dev/null\)'
+        let line = getline(line('.')-1)
+        let dref = matchstr(line,'\Cdiff --git \zs\%([abciow12]/.*\|/dev/null\)\ze \%([abciow12]/.*\|/dev/null\)')
+        let ref = matchstr(line,'\Cdiff --git \%([abciow12]/.*\|/dev/null\) \zs\%([abciow12]/.*\|/dev/null\)')
+        let dcmd = 'Gdiffsplit!'
+
+      elseif line('$') == 1 && getline('.') =~ '^\x\{40,\}$'
+        let ref = getline('.')
+
+      elseif expand('<cword>') =~# '^\x\{7,\}\>'
+        return [expand('<cword>')]
+
+      else
+        let ref = ''
+      endif
+
+      let prefixes = {
+            \ '1': '',
+            \ '2': '',
+            \ 'b': ':0:',
+            \ 'i': ':0:',
+            \ 'o': '',
+            \ 'w': ''}
+
+      if len(myhash)
+        let prefixes.a = myhash.'^:'
+        let prefixes.b = myhash.':'
+      endif
+      let ref = substitute(ref, '^\(\w\)/', '\=get(prefixes, submatch(1), "HEAD:")', '')
+      if exists('dref')
+        let dref = substitute(dref, '^\(\w\)/', '\=get(prefixes, submatch(1), "HEAD:")', '')
+      endif
+
+      if ref ==# '/dev/null'
+        " Empty blob
+        let ref = 'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391'
+      endif
+
+      if exists('dref')
+        return [ref, dcmd . ' ' . s:fnameescape(dref)] + dcmds
+      elseif ref != ""
+        return [ref] + dcmds
+      endif
+
+    endif
+    return []
+  endtry
+endfunction
+
+function! s:GF(mode) abort
+  try
+    let results = &filetype ==# 'fugitive' ? s:StatusCfile() : &filetype ==# 'gitcommit' ? [s:MessageCfile()] : s:cfile()
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if len(results) > 1
+    return 'G' . a:mode .
+          \ ' +' . escape(results[1], ' ') . ' ' .
+          \ s:fnameescape(results[0]) . join(map(results[2:-1], '"|" . v:val'), '')
+  elseif len(results) && len(results[0])
+    return 'G' . a:mode . ' ' . s:fnameescape(results[0])
+  else
+    return ''
+  endif
+endfunction
+
+function! fugitive#Cfile() abort
+  let pre = ''
+  let results = s:cfile()
+  if empty(results)
+    let cfile = expand('<cfile>')
+    if &includeexpr =~# '\<v:fname\>'
+      sandbox let cfile = eval(substitute(&includeexpr, '\C\<v:fname\>', '\=string(cfile)', 'g'))
+    endif
+    return cfile
+  elseif len(results) > 1
+    let pre = '+' . join(map(results[1:-1], 'escape(v:val, " ")'), '\|') . ' '
+  endif
+  return pre . s:fnameescape(s:Generate(results[0]))
+endfunction
+
+" Section: Statusline
+
+function! fugitive#Statusline(...) abort
+  let dir = s:Dir(bufnr(''))
+  if empty(dir)
+    return ''
+  endif
+  let status = ''
+  let commit = s:DirCommitFile(@%)[1]
+  if len(commit)
+    let status .= ':' . commit[0:6]
+  endif
+  let status .= '('.FugitiveHead(7, dir).')'
+  return '[Git'.status.']'
+endfunction
+
+function! fugitive#statusline(...) abort
+  return fugitive#Statusline()
+endfunction
+
+function! fugitive#head(...) abort
+  if empty(s:Dir())
+    return ''
+  endif
+
+  return fugitive#Head(a:0 ? a:1 : 0)
+endfunction
+
+" Section: Folding
+
+function! fugitive#Foldtext() abort
+  if &foldmethod !=# 'syntax'
+    return foldtext()
+  endif
+
+  let line_foldstart = getline(v:foldstart)
+  if line_foldstart =~# '^diff '
+    let [add, remove] = [-1, -1]
+    let filename = ''
+    for lnum in range(v:foldstart, v:foldend)
+      let line = getline(lnum)
+      if filename ==# '' && line =~# '^[+-]\{3\} [abciow12]/'
+        let filename = line[6:-1]
+      endif
+      if line =~# '^+'
+        let add += 1
+      elseif line =~# '^-'
+        let remove += 1
+      elseif line =~# '^Binary '
+        let binary = 1
+      endif
+    endfor
+    if filename ==# ''
+      let filename = matchstr(line_foldstart, '^diff .\{-\} [abciow12]/\zs.*\ze [abciow12]/')
+    endif
+    if filename ==# ''
+      let filename = line_foldstart[5:-1]
+    endif
+    if exists('binary')
+      return 'Binary: '.filename
+    else
+      return (add<10&&remove<100?' ':'') . add . '+ ' . (remove<10&&add<100?' ':'') . remove . '- ' . filename
+    endif
+  elseif line_foldstart =~# '^# .*:$'
+    let lines = getline(v:foldstart, v:foldend)
+    call filter(lines, 'v:val =~# "^#\t"')
+    cal map(lines, "s:sub(v:val, '^#\t%(modified: +|renamed: +)=', '')")
+    cal map(lines, "s:sub(v:val, '^([[:alpha:] ]+): +(.*)', '\\2 (\\1)')")
+    return line_foldstart.' '.join(lines, ', ')
+  endif
+  return foldtext()
+endfunction
+
+function! fugitive#foldtext() abort
+  return fugitive#Foldtext()
+endfunction
+
+" Section: Initialization
+
+function! fugitive#Init() abort
+  throw 'Third party code is using fugitive#Init() which has been removed. Contact the author if you have a reason to still use it'
+endfunction
+
+function! fugitive#is_git_dir(path) abort
+  throw 'Third party code is using fugitive#is_git_dir() which has been removed. Change it to FugitiveIsGitDir()'
+endfunction
+
+function! fugitive#extract_git_dir(path) abort
+  throw 'Third party code is using fugitive#extract_git_dir() which has been removed. Change it to FugitiveExtractGitDir()'
+endfunction
+
+function! fugitive#detect(path) abort
+  throw 'Third party code is using fugitive#detect() which has been removed. Contact the author if you have a reason to still use it'
+endfunction
+
+" Section: End
diff --git a/vim/bundle/vim-fugitive/doc/fugitive.txt b/vim/bundle/vim-fugitive/doc/fugitive.txt
index b591803..07f605d 100644
--- a/vim/bundle/vim-fugitive/doc/fugitive.txt
+++ b/vim/bundle/vim-fugitive/doc/fugitive.txt
@@ -15,145 +15,132 @@ COMMANDS                                        *fugitive-commands*
 These commands are local to the buffers in which they work (generally, buffers
 that are part of Git repositories).
 
-                                                *fugitive-:Git*
-:Git [args]             Run an arbitrary git command. Similar to :!git [args]
-                        but chdir to the repository tree first.
+                                                *:Git* *fugitive-:G*
+:Git {args}             Run an arbitrary git command and display any output.
+:G {args}               On UNIX this uses a pty and on other platforms it uses
+                        a pipe, which will cause some behavior differences
+                        such as the absence of progress bars.  Any file the
+                        command edits (for example, a commit message) will be
+                        loaded into a split window.  Closing that window will
+                        resume running the command.  A few Git subcommands
+                        have different behavior; these are documented below.
+
+                                                *:Git_--paginate* *:Git_-p*
+:Git --paginate {args}  Run an arbitrary git command, capture output to a temp
+:Git -p {args}          file, and |:split| that temp file.  Use :0Git to
+:G --paginate {args}    |:edit| the temp file instead.  A temp file is always
+:G -p {args}            used for commands like diff and log that typically
+                        user a pager, and for any command that has the
+                        pager.<cmd> Git configuration option set.
+
+                                                *fugitive-summary*
+:Git                    With no arguments, bring up a summary window vaguely
+:G                      akin to git-status.  Press g? or see |fugitive-maps|
+                        for usage.
+
+                                                *:Git_blame*
+:Git blame [flags]      Run git-blame [flags] on the current file and open the
+                        results in a scroll-bound vertical split.  The
+                        following maps, which work on the cursor line commit
+                        where sensible, are provided:
 
-                                                *fugitive-:Git!*
-:Git! [args]            Like |:Git|, but capture the output into a temp file,
-                        and edit that temp file.
+                        g?    show this help
+                        A     resize to end of author column
+                        C     resize to end of commit column
+                        D     resize to end of date/time column
+                        gq    close blame, then |:Gedit| to return to work
+                              tree version
+                        <CR>  close blame, and jump to patch that added line
+                              (or directly to blob for boundary commit)
+                        o     jump to patch or blob in horizontal split
+                        O     jump to patch or blob in new tab
+                        p     jump to patch or blob in preview window
+                        -     reblame at commit
+                        ~     reblame at [count]th first grandparent
+                        P     reblame at [count]th parent (like HEAD^[count])
 
-                                                *fugitive-:Gcd*
-:Gcd [directory]        |:cd| relative to the repository.
+:[range]Git blame [...] If a range is given, just that part of the file will
+:Git blame [...] {file} be blamed, and a horizontal split without
+                        scrollbinding is used.  You can also give an arbitrary
+                        filename.
 
-                                                *fugitive-:Glcd*
-:Glcd [directory]       |:lcd| relative to the repository.
+                                                *:Git_difftool*
+:Git[!] difftool [args] Invoke `git diff [args]` and load the changes into the
+                        quickfix list.  Each changed hunk gets a separate
+                        quickfix entry unless you pass an option like
+                        --name-only or --name-status.  Jumps to the first
+                        change unless [!] is given.
 
-                                                *fugitive-:Gstatus*
-:Gstatus                Bring up the output of git-status in the preview
-                        window.  The following maps, which work on the cursor
-                        line file where sensible, are provided:
+:Git difftool -y [args] Invoke `git diff [args]`, open each changed file in a
+                        new tab, and invoke |:Gdiffsplit!| against the
+                        appropriate commit.
 
-                        g?    show this help
-                        <C-N> next file
-                        <C-P> previous file
-                        <CR>  |:Gedit|
-                        -     |:Git| add
-                        -     |:Git| reset (staged files)
-                        a     Show alternative format
-                        cA    |:Gcommit| --amend --reuse-message=HEAD
-                        ca    |:Gcommit| --amend
-                        cc    |:Gcommit|
-                        cva   |:Gcommit| --amend --verbose
-                        cvc   |:Gcommit| --verbose
-                        D     |:Gdiff|
-                        ds    |:Gsdiff|
-                        dp    |:Git!| diff (p for patch; use :Gw to apply)
-                        dp    |:Git| add --intent-to-add (untracked files)
-                        dv    |:Gvdiff|
-                        O     |:Gtabedit|
-                        o     |:Gsplit|
-                        p     |:Git| add --patch
-                        p     |:Git| reset --patch (staged files)
-                        q     close status
-                        r     reload status
-                        S     |:Gvsplit|
-                        U     |:Git| checkout
-                        U     |:Git| checkout HEAD (staged files)
-                        U     |:Git| clean (untracked files)
-                        U     |:Git| rm (unmerged files)
-
-                                                *fugitive-:Gcommit*
-:Gcommit [args]         A wrapper around git-commit.  If there is nothing
-                        to commit, |:Gstatus| is called instead.  Unless the
-                        arguments given would skip the invocation of an editor
-                        (e.g., -m), a split window will be used to obtain a
-                        commit message, or a new tab if -v is given.  Write
-                        and close that window (:wq or |:Gwrite|) to finish the
-                        commit.  Unlike when running the actual git-commit
-                        command, it is possible (but unadvisable) to alter the
-                        index with commands like git-add and git-reset while a
-                        commit message is pending.
-
-                                                *fugitive-:Gmerge*
-:Gmerge [args]          Calls git-merge and loads errors and conflicted files
-                        into the quickfix list.  Opens a |:Gcommit| style
-                        split window for the commit message if the merge
-                        succeeds.  If called during a merge conflict, the
-                        conflicted files from the current index are loaded
-                        into the quickfix list.
-
-                                                *fugitive-:Gpull*
-:Gpull [args]           Like |:Gmerge|, but for git-pull.
-
-                                                *fugitive-:Gpush*
-:Gpush [args]           Invoke git-push, load the results into the quickfix
-                        list, and invoke |:cwindow| to reveal any errors.
-                        |:Dispatch| is used if available for asynchronous
-                        invocation.
-
-                                                *fugitive-:Gfetch*
-:Gfetch [args]          Like |:Gpush|, but for git-fetch.
-
-                                                *fugitive-:Ggrep*
+                                                *:Git_mergetool*
+:Git mergetool [args]   Like |:Git_difftool|, but target merge conflicts.
+
+                                                *:Ggrep* *:Gcgrep* *:Git_grep*
 :Ggrep[!] [args]        |:grep|[!] with git-grep as 'grepprg'.
+:Git[!] grep [args]
 
-                                                *fugitive-:Glgrep*
+                                                *:Glgrep*
 :Glgrep[!] [args]       |:lgrep|[!] with git-grep as 'grepprg'.
+:0Git[!] grep [args]
+
+                                                 *:Gclog*
+:Gclog[!] [args]        Use git-log [args] to load the commit history into the
+                        |quickfix| list.  Jumps to the first commit unless [!]
+                        is given.
 
-                                                *fugitive-:Glog*
-:Glog [args]            Load all previous revisions of the current file into
-                        the quickfix list.  Additional git-log arguments can
-                        be given (for example, --reverse).  If "--" appears as
-                        an argument, no file specific filtering is done, and
-                        previous commits rather than previous file revisions
-                        are loaded.
+                        The quickfix list can be awkward for many use cases
+                        and exhibits extremely poor performance with larger
+                        data sets.  Consider using |:Git| log instead.
 
-:{range}Glog [args]     Use git-log -L to load previous revisions of the given
-                        range of the current file into the quickfix list.  The
-                        cursor is positioned on the first line of the first
-                        diff hunk for each commit.
+:{range}Gclog[!] [args] Use git-log -L to load previous revisions of the given
+                        range of the current file into the |quickfix| list.
+                        The cursor is positioned on the first line of the
+                        first diff hunk for each commit.  Use :0Gclog to
+                        target the entire file.
 
-                                                *fugitive-:Gllog*
-:Gllog [args]           Like |:Glog|, but use the location list instead of the
-                        quickfix list.
+                                                *:Gllog*
+:Gllog [args]           Like |:Gclog|, but use the location list instead of the
+                        |quickfix| list.
 
-                                        *fugitive-:Gedit* *fugitive-:Ge*
-:Gedit [revision]       |:edit| a |fugitive-revision|.
+                                                *:Gcd*
+:Gcd [directory]        |:cd| relative to the repository.
+
+                                                *:Glcd*
+:Glcd [directory]       |:lcd| relative to the repository.
 
-                                                *fugitive-:Gsplit*
-:Gsplit [revision]      |:split| a |fugitive-revision|.
+                                                *:Gedit* *fugitive-:Ge*
+:Gedit [object]         |:edit| a |fugitive-object|.
 
-                                                *fugitive-:Gvsplit*
-:Gvsplit [revision]     |:vsplit| a |fugitive-revision|.
+                                                *:Gsplit*
+:Gsplit [object]        |:split| a |fugitive-object|.
 
-                                                *fugitive-:Gtabedit*
-:Gtabedit [revision]    |:tabedit| a |fugitive-revision|.
+                                                *:Gvsplit*
+:Gvsplit [object]       |:vsplit| a |fugitive-object|.
 
-                                                *fugitive-:Gpedit*
-:Gpedit [revision]      |:pedit| a |fugitive-revision|.
+                                                *:Gtabedit*
+:Gtabedit [object]      |:tabedit| a |fugitive-object|.
 
-:Gsplit! [args]                 *fugitive-:Gsplit!* *fugitive-:Gvsplit!*
-:Gvsplit! [args]                *fugitive-:Gtabedit!* *fugitive-:Gpedit!*
-:Gtabedit! [args]       Like |:Git!|, but open the resulting temp file in a
-:Gpedit! [args]         split, tab, or preview window.
+                                                *:Gpedit*
+:Gpedit [object]        |:pedit| a |fugitive-object|.
 
-                                                *fugitive-:Gread*
-:Gread [revision]       Empty the buffer and |:read| a |fugitive-revision|.
+                                                *:Gread* *fugitive-:Gr*
+:Gread [object]         Empty the buffer and |:read| a |fugitive-object|.
                         When the argument is omitted, this is similar to
                         git-checkout on a work tree file or git-add on a stage
                         file, but without writing anything to disk.
 
-:{range}Gread [revision]
-                        |:read| in a |fugitive-revision| after {range}.
+:{range}Gread [object]  |:read| in a |fugitive-object| after {range}.
 
-                                                *fugitive-:Gread!*
+                                                *:Gread!* *fugitive-:Gr!*
 :Gread! [args]          Empty the buffer and |:read| the output of a Git
                         command.  For example, :Gread! show HEAD:%.
 
-:{range}Gread! [args]  |:read| the output of a Git command after {range}.
+:{range}Gread! [args]   |:read| the output of a Git command after {range}.
 
-                                        *fugitive-:Gw* *fugitive-:Gwrite*
+                                                *:Gwrite* *fugitive-:Gw*
 :Gwrite                 Write to the current file's path and stage the results.
                         When run in a work tree file, it is effectively git
                         add.  Elsewhere, it is effectively git-checkout.  A
@@ -163,74 +150,61 @@ that are part of Git repositories).
 
 :Gwrite {path}          You can give |:Gwrite| an explicit path of where in
                         the work tree to write.  You can also give a path like
-                        :0:foo.txt or even :0 to write to just that stage in
+                        :0:foo.txt or :0:% to write to just that stage in
                         the index.
 
-                                                *fugitive-:Gwq*
+                                                *:Gwq*
 :Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
                         succeeded.
 
 :Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
                         succeeded.
 
-                                                *fugitive-:Gdiff*
-:Gdiff [revision]       Perform a |vimdiff| against the current file in the
-                        given revision.  With no argument, the version in the
-                        index is used (which means a three-way diff during a
-                        merge conflict, making it a git-mergetool
-                        alternative).  The newer of the two files is placed
-                        to the right or bottom, depending on 'diffopt' and
-                        the width of the window relative to 'textwidth'.  Use
-                        |do| and |dp| and write to the index file to simulate
-                        "git add --patch". For the three-way diff, there is
-                        also d2o and d3o pulling the hunk to the middle from
-                        the left or the right window, respectively.
-
-                                                *fugitive-:Gsdiff*
-:Gsdiff [revision]      Like |:Gdiff|, but always split horizontally.
-
-                                                *fugitive-:Gvdiff*
-:Gvdiff [revision]      Like |:Gdiff|, but always split vertically.
-
-                                                *fugitive-:Gmove*
-:Gmove {destination}    Wrapper around git-mv that renames the buffer
-                        afterward.  The destination is relative to the current
-                        directory except when started with a /, in which case
-                        it is relative to the work tree.  Add a ! to pass -f.
-
-                                                *fugitive-:Gdelete*
-:Gdelete                Wrapper around git-rm that deletes the buffer
+                                                *:Gdiffsplit*
+:Gdiffsplit [object]    Perform a |vimdiff| against the given file, or if a
+                        commit is given, the current file in that commit.
+                        With no argument, the version in the index or work
+                        tree is used.  The newer of the two files is placed to
+                        the right or bottom, depending on 'diffopt' and the
+                        width of the window relative to 'textwidth'.  Use
+                        Vim's |do| and |dp| to stage and unstage changes.
+
+                                                *:Gdiffsplit!*
+:Gdiffsplit!            Diff against any and all direct ancestors, retaining
+                        focus on the current window.  During a merge conflict,
+                        this is a three-way diff against the "ours" and
+                        "theirs" ancestors.  Additional d2o and d3o maps are
+                        provided to obtain the hunk from the "ours" or
+                        "theirs" ancestor, respectively.
+
+:Gdiffsplit! {object}   Like |:Gdiffsplit|, but retain focus on the current
+                        window.
+
+                                                *:Gvdiffsplit*
+:Gvdiffsplit [object]   Like |:Gdiffsplit|, but always split vertically.
+
+                                                *:Ghdiffsplit*
+:Ghdiffsplit [object]   Like |:Gdiffsplit|, but always split horizontally.
+
+                                                *:GMove*
+:GMove {destination}    Wrapper around git-mv that renames the buffer
+                        afterward.  Add a ! to pass -f.
+
+                                                *:GRename*
+:GRename {destination}  Like |:GMove| but operates relative to the parent
+                        directory of the current file.
+
+                                                *:GDelete*
+:GDelete                Wrapper around git-rm that deletes the buffer
                         afterward.  When invoked in an index file, --cached is
                         passed.  Add a ! to pass -f and forcefully discard the
                         buffer.
 
-                                                *fugitive-:Gremove*
-:Gremove                Like :Gdelete, but keep the (now empty) buffer around.
+                                                *:GRemove*
+:GRemove                Like |:GDelete|, but keep the (now empty) buffer around.
 
-                                                *fugitive-:Gblame*
-:Gblame [flags]         Run git-blame on the file and open the results in a
-                        scroll bound vertical split.  You can give any of
-                        ltfnsewMC as flags and they will be passed along to
-                        git-blame.  The following maps, which work on the
-                        cursor line commit where sensible, are provided:
-
-                        g?    show this help
-                        A     resize to end of author column
-                        C     resize to end of commit column
-                        D     resize to end of date/time column
-                        q     close blame and return to blamed window
-                        gq    q, then |:Gedit| to return to work tree version
-                        <CR>  q, then open commit
-                        o     open commit in horizontal split
-                        O     open commit in new tab
-                        -     reblame at commit
-                        ~     reblame at [count]th first grandparent
-                        P     reblame at [count]th parent (like HEAD^[count])
-
-:[range]Gblame [flags]  Run git-blame on the given range.
-
-                                                *fugitive-:Gbrowse*
-:Gbrowse                Open the current file, blob, tree, commit, or tag
+                                                *:GBrowse*
+:GBrowse                Open the current file, blob, tree, commit, or tag
                         in your browser at the upstream hosting provider.
                         If a range is given, it is appropriately appended to
                         the URL as an anchor.
@@ -240,122 +214,429 @@ that are part of Git repositories).
                         supported by installing rhubarb.vim, available at
                         <https://github.com/tpope/vim-rhubarb>.
 
-                        The hosting provider is determined by looking at the
-                        remote for the current or specified branch and falls
-                        back to "origin".  In the special case of a "."
-                        remote, a local instance of git-instaweb will be
-                        started and used.
-
-:Gbrowse {revision}     Like :Gbrowse, but for a given |fugitive-revision|.  A
-                        useful value here is -, which ties the URL to the
-                        latest commit rather than a volatile branch.
+:GBrowse {object}       Like :GBrowse, but for a given |fugitive-object|.
 
-:Gbrowse [...]@{remote} Force using the given remote rather than the remote
+:GBrowse [...]@{remote} Force using the given remote rather than the remote
                         for the current branch.  The remote is used to
-                        determine which GitHub repository to link to.
+                        determine which upstream repository to link to.
 
-:{range}Gbrowse [args]  Appends an anchor to the URL that emphasizes the
-                        selected lines.  You almost certainly want to give a
-                        "-" argument in this case to force the URL to include
-                        an exact revision.
+:{range}GBrowse [args]  Appends an anchor to the URL that emphasizes the
+                        selected lines. This also forces the URL to include a
+                        commit rather than a branch name so it remains valid
+                        if the file changes.  You can give a range of "0" to
+                        force this behavior without including an anchor.
 
-:[range]Gbrowse! [args] Like :Gbrowse, but put the URL on the clipboard rather
+:[range]GBrowse! [args] Like :GBrowse, but put the URL on the clipboard rather
                         than opening it.
 
-MAPPINGS                                        *fugitive-mappings*
+MAPS                                            *fugitive-maps*
 
-These maps are available everywhere.
+These maps are available in both the |fugitive-summary| buffer and Fugitive
+object buffers, although not all maps make sense in all buffers.  Mappings
+that operate on the file or hunk under the cursor are generally available in
+visual mode to operate on multiple files or partial hunks.
 
-                                                *fugitive-c_CTRL-R_CTRL-G*
-<C-R><C-G>              On the command line, recall the path to the current
-                        object (that is, a representation of the object
-                        recognized by |:Gedit|).
+                                                *fugitive-staging-maps*
+Staging/unstaging maps ~
+
+                                                *fugitive_s*
+s                       Stage (add) the file or hunk under the cursor.
+
+                                                *fugitive_u*
+u                       Unstage (reset) the file or hunk under the cursor.
+
+                                                *fugitive_-*
+-                       Stage or unstage the file or hunk under the cursor.
+
+                                                *fugitive_U*
+U                       Unstage everything.
+
+                                                *fugitive_X*
+X                       Discard the change under the cursor.  This uses
+                        `checkout` or `clean` under the hood.  A command is
+                        echoed that shows how to undo the change.  Consult
+                        `:messages` to see it again.  During a merge conflict,
+                        use 2X to call `checkout --ours` or 3X to call
+                        `checkout --theirs` .
+
+                                                *fugitive_=*
+=                       Toggle an inline diff of the file under the cursor.
+
+                                                *fugitive_>*
+>                       Insert an inline diff of the file under the cursor.
+
+                                                *fugitive_<*
+<                       Remove the inline diff of the file under the cursor.
+
+                                                *fugitive_gI*
+gI                      Open .git/info/exclude in a split and add the file
+                        under the cursor.  Use a count to open .gitignore.
+
+                                                *fugitive_I*
+I                       Invoke |:Git| add --patch or reset --patch on the file
+P                       under the cursor. On untracked files, this instead
+                        calls |:Git| add --intent-to-add.
+
+                                                *fugitive_d*
+Diff maps ~
+                                                *fugitive_dp*
+dp                      Invoke |:Git| diff on the file under the cursor.
+                        Deprecated in favor of inline diffs.
+
+                                                *fugitive_dd*
+dd                      Perform a |:Gdiffsplit| on the file under the cursor.
+
+                                                *fugitive_dv*
+dv                      Perform a |:Gvdiffsplit| on the file under the cursor.
+
+                                                *fugitive_ds* *fugitive_dh*
+ds                      Perform a |:Ghdiffsplit| on the file under the cursor.
+dh
+                                                *fugitive_dq*
+dq                      Close all but one diff buffer, and |:diffoff|! the
+                        last one.
+
+                                                *fugitive_d?*
+d?                      Show this help.
+
+                                                *fugitive-navigation-maps*
+Navigation maps ~
+
+                                                *fugitive_<CR>*
+<CR>                    Open the file or |fugitive-object| under the cursor.
+                        in a blob, this and similar maps jump to the patch
+                        from the diff where this was added, or where it was
+                        removed if a count was given.  If the line is still in
+                        the work tree version, passing a count takes you to
+                        it.
+
+                                                *fugitive_o*
+o                       Open the file or |fugitive-object| under the cursor in
+                        a new split.
+
+                                                *fugitive_gO*
+gO                      Open the file or |fugitive-object| under the cursor in
+                        a new vertical split.
+
+                                                *fugitive_O*
+O                       Open the file or |fugitive-object| under the cursor in
+                        a new tab.
+
+                                                *fugitive_p*
+p                       Open the file or |fugitive-object| under the cursor in
+                        a preview window.  In the status buffer, 1p is
+                        required to bypass the legacy usage instructions.
+
+                                                *fugitive_~*
+~                       Open the current file in the [count]th first ancestor.
+
+                                                *fugitive_P*
+P                       Open the current file in the [count]th parent.
+
+                                                *fugitive_C*
+C                       Open the commit containing the current file.
+
+                                                *fugitive_CTRL-P* *fugitive_(*
+(                       Jump to the previous file, hunk, or revision.
+
+                                                *fugitive_CTRL-N* *fugitive_)*
+)                       Jump to the next file, hunk, or revision.
+
+                                                *fugitive_[c*
+[c                      Jump to previous hunk, expanding inline diffs
+                        automatically.  (This shadows the Vim built-in |[c|
+                        that provides a similar operation in |diff| mode.)
+
+                                                *fugitive_]c*
+]c                      Jump to next hunk, expanding inline diffs
+                        automatically.  (This shadows the Vim built-in |]c|
+                        that provides a similar operation in |diff| mode.)
+
+                                                *fugitive_[/* *fugitive_[m*
+[/                      Jump to previous file, collapsing inline diffs
+[m                      automatically.  (Mnemonic: "/" appears in filenames,
+                        "m" appears in "filenames".)
+
+                                                *fugitive_]/* *fugitive_]m*
+]/                      Jump to next file, collapsing inline diffs
+]m                      automatically.  (Mnemonic: "/" appears in filenames,
+                        "m" appears in "filenames".)
 
-                                                *fugitive-y_CTRL-G*
-["x]y<C-G>              Yank the commit SHA and path to the current object.
+                                                *fugitive_i*
+i                       Jump to the next file or hunk, expanding inline diffs
+                        automatically.
 
-These maps are available in Git objects.
+                                                *fugitive_[[*
+[[                      Jump [count] sections backward.
 
-                                                *fugitive-<CR>*
-<CR>                    Jump to the revision under the cursor.
+                                                *fugitive_]]*
+]]                      Jump [count] sections forward.
 
-                                                *fugitive-o*
-o                       Jump to the revision under the cursor in a new split.
+                                                *fugitive_[]*
+[]                      Jump [count] section ends backward.
 
-                                                *fugitive-S*
-S                       Jump to the revision under the cursor in a new
-                        vertical split.
+                                                *fugitive_][*
+][                      Jump [count] section ends forward.
 
-                                                *fugitive-O*
-O                       Jump to the revision under the cursor in a new tab.
+                                                *fugitive_star*
+*                       On the first column of a + or - diff line, search for
+                        the corresponding - or + line.  Otherwise, defer to
+                        built-in |star|.
 
-                                                *fugitive--*
--                       Go to the tree containing the current tree or blob.
+                                                *fugitive_#*
+#                       Same as "*", but search backward.
 
-                                                *fugitive-~*
-~                       Go to the current file in the [count]th first
-                        ancestor.
+                                                *fugitive_gu*
+gu                      Jump to file [count] in the "Untracked" or "Unstaged"
+                        section.
 
-                                                *fugitive-P*
-P                       Go to the current file in the [count]th parent.
+                                                *fugitive_gU*
+gU                      Jump to file [count] in the "Unstaged" section.
 
-                                                *fugitive-C*
-C                       Go to the commit containing the current file.
+                                                *fugitive_gs*
+gs                      Jump to file [count] in the "Staged" section.
 
-                                                *fugitive-.*
-.                       Start a |:| command line with the current revision
-                        prepopulated at the end of the line.
+                                                *fugitive_gp*
+gp                      Jump to file [count] in the "Unpushed" section.
 
-                                                *fugitive-a*
-a                       Show the current tag, commit, or tree in an alternate
-                        format.
+                                                *fugitive_gP*
+gP                      Jump to file [count] in the "Unpulled" section.
 
-SPECIFYING REVISIONS                            *fugitive-revision*
+                                                *fugitive_gr*
+gr                      Jump to file [count] in the "Rebasing" section.
 
-Fugitive revisions are similar to Git revisions as defined in the "SPECIFYING
-REVISIONS" section in the git-rev-parse man page.  For commands that accept an
-optional revision, the default is the file in the index for work tree files
-and the work tree file for everything else.  Example revisions follow.
+                                                *fugitive_gi*
+gi                      Open .git/info/exclude in a split.  Use a count to
+                        open .gitignore.
 
-Revision        Meaning ~
-HEAD            .git/HEAD
-master          .git/refs/heads/master
-HEAD^{}         The commit referenced by HEAD
-HEAD^           The parent of the commit referenced by HEAD
-HEAD:           The tree referenced by HEAD
-/HEAD           The file named HEAD in the work tree
+                                                *fugitive_c*
+Commit maps ~
+
+cc                      Create a commit.
+
+ca                      Amend the last commit and edit the message.
+
+ce                      Amend the last commit without editing the message.
+
+cw                      Reword the last commit.
+
+cvc                     Create a commit with -v.
+
+cva                     Amend the last commit with -v
+
+cf                      Create a `fixup!` commit for the commit under the
+                        cursor.
+
+cF                      Create a `fixup!` commit for the commit under the
+                        cursor and immediately rebase it.
+
+cs                      Create a `squash!` commit for the commit under the
+                        cursor.
+
+cS                      Create a `squash!` commit for the commit under the
+                        cursor and immediately rebase it.
+
+cA                      Create a `squash!` commit for the commit under the
+                        cursor and edit the message.
+
+c<Space>                Populate command line with ":Git commit ".
+
+                                                *fugitive_cr*
+crc                     Revert the commit under the cursor.
+
+crn                     Revert the commit under the cursor in the index and
+                        work tree, but do not actually commit the changes.
+
+cr<Space>               Populate command line with ":Git revert ".
+
+                                                *fugitive_cm*
+cm<Space>               Populate command line with ":Git merge ".
+
+c?                      Show this help.
+
+                                                *fugitive_cb*
+                                                *fugitive_co*
+Checkout/branch maps ~
+
+coo                     Check out the commit under the cursor.
+
+cb<Space>               Populate command line with ":Git branch ".
+
+co<Space>               Populate command line with ":Git checkout ".
+
+cb?                     Show this help.
+co?
+
+                                                *fugitive_cz*
+Stash maps ~
+
+czz                     Push stash.  Pass a [count] of 1 to add
+                        `--include-untracked` or 2 to add `--all`.
+
+czw                     Push stash of worktree.  Like `czz` with
+                        `--keep-index`.
+
+czA                     Apply topmost stash, or stash@{count}.
+
+cza                     Apply topmost stash, or stash@{count}, preserving the
+                        index.
+
+czP                     Pop topmost stash, or stash@{count}.
+
+czp                     Pop topmost stash, or stash@{count}, preserving the
+                        index.
+
+cz<Space>               Populate command line with ":Git stash ".
+
+cz?                     Show this help.
+
+                                                *fugitive_r*
+Rebase maps ~
+
+ri                      Perform an interactive rebase.  Uses ancestor of
+u                       commit under cursor as upstream if available.
+
+rf                      Perform an autosquash rebase without editing the todo
+                        list.  Uses ancestor of commit under cursor as
+                        upstream if available.
+
+ru                      Perform an interactive rebase against @{upstream}.
+
+rp                      Perform an interactive rebase against @{push}.
+
+rr                      Continue the current rebase.
+
+rs                      Skip the current commit and continue the current
+                        rebase.
+
+ra                      Abort the current rebase.
+
+re                      Edit the current rebase todo list.
+
+rw                      Perform an interactive rebase with the commit under
+                        the cursor set to `reword`.
+
+rm                      Perform an interactive rebase with the commit under
+                        the cursor set to `edit`.
+
+rd                      Perform an interactive rebase with the commit under
+                        the cursor set to `drop`.
+
+r<Space>                Populate command line with ":Git rebase ".
+
+r?                      Show this help.
+
+                                                *fugitive-misc-maps*
+Miscellaneous maps ~
+
+                                                *fugitive_gq* *fugitive_q*
+gq                      Close the status buffer.
+
+                                                *fugitive_.*
+.                       Start a |:| command line with the file under the
+                        cursor prepopulated.
+
+                                                *fugitive_g?*
+g?                      Show help for |fugitive-maps|.
+
+                                                *fugitive-global-maps*
+Global maps ~
+
+                                                *fugitive_c_CTRL-R_CTRL-G*
+<C-R><C-G>              On the command line, recall the path to the current
+                        |fugitive-object| (that is, a representation of the
+                        object recognized by |:Gedit|).
+
+                                                *fugitive_y_CTRL-G*
+["x]y<C-G>              Yank the path to the current |fugitive-object|.
+
+                                                *g:fugitive_no_maps*
+Global maps can be disabled with the g:fugitive_no_maps option.
+>
+        let g:fugitive_no_maps = 1
+<
+SPECIFYING OBJECTS                      *fugitive-object* *fugitive-revision*
+
+Fugitive objects are either work tree files or Git revisions as defined in the
+"SPECIFYING REVISIONS" section in the git-rev-parse man page, with expansions
+inspired by |cmdline-special| layered on top.  For commands that accept an
+optional object, the default is the file in the index for work tree files and
+the work tree file for everything else.  Example objects follow.
+
+Object          Meaning ~
+@               The commit referenced by @ aka HEAD
+master          The commit referenced by master
+master^         The parent of the commit referenced by master
+master...other  The merge base of master and other
+master:         The tree referenced by master
+./master        The file named master in the working directory
+:(top)master    The file named master in the work tree
 Makefile        The file named Makefile in the work tree
-HEAD^:Makefile  The file named Makefile in the parent of HEAD
+@^:Makefile     The file named Makefile in the parent of HEAD
 :Makefile       The file named Makefile in the index (writable)
--               The current file in HEAD
-^               The current file in the previous commit
-~3              The current file 3 commits ago
-:               .git/index (Same as |:Gstatus|)
-:0              The current file in the index
-:1              The current file's common ancestor during a conflict
-:2              The current file in the target branch during a conflict
-:3              The current file in the merged branch during a conflict
-:/foo           The most recent commit with "foo" in the message
+@~2:%           The current file in the grandparent of HEAD
+:%              The current file in the index
+:1:%            The current file's common ancestor during a conflict
+:2:#            The alternate file in the target branch during a conflict
+:3:#5           The file from buffer #5 in the merged branch during a conflict
+!               The commit owning the current file
+!:Makefile      The file named Makefile in the commit owning the current file
+!3^2            The second parent of the commit owning buffer #3
+.git/config     The repo config file
+:               The |fugitive-summary| buffer.
 
 STATUSLINE                                      *fugitive-statusline*
 
-                                                *fugitive#statusline()*
-Add %{fugitive#statusline()} to your statusline to get an indicator including
+                                *FugitiveStatusline()* *fugitive#statusline()*
+Add %{FugitiveStatusline()} to your statusline to get an indicator including
 the current branch and the currently edited file's commit.  If you don't have
 a statusline, this one matches the default when 'ruler' is set:
 >
-    set statusline=%<%f\ %h%m%r%{fugitive#statusline()}%=%-14.(%l,%c%V%)\ %P
+        set statusline=%<%f\ %h%m%r%{FugitiveStatusline()}%=%-14.(%l,%c%V%)\ %P
 <
-                                                *fugitive#head(...)*
-Use fugitive#head() to return the name of the current branch. If the current
-HEAD is detached, fugitive#head() will return the empty string, unless the
+                                *FugitiveHead(...)* *fugitive#head(...)*
+Use FugitiveHead() to return the name of the current branch. If the current
+HEAD is detached, FugitiveHead() will return the empty string, unless the
 optional argument is given, in which case the hash of the current commit will
 be truncated to the given number of characters.
 
+DEPRECATIONS                                    *fugitive-deprecated*
+
+The following commands are softly deprecated in favor of replacements that
+adhere to a new naming scheme.  They will eventually be removed, but probably
+not in the near future.
+
+Remember that |:Git| can be shortened to |:G|, so replacements using it are
+just one space character longer than the legacy version.
+
+*:Gremove*      Superseded by |:GRemove|.
+*:Gdelete*      Superseded by |:GDelete|.
+*:Gmove*        Superseded by |:GMove|.
+*:Grename*      Superseded by |:GRename|.
+*:Gbrowse*      Superseded by |:GBrowse|.
+*:Gdiff*        Superseded by |:Gdiffsplit|
+*:Gsdiff*       Superseded by |:Ghdiffsplit|
+*:Gvdiff*       Superseded by |:Gvdiffsplit| or |:vert| |:Gdiffsplit|.
+*:Gblame*       Superseded by |:Git_blame|.
+*:Gcommit*      Superseded by |:Git| commit.
+*:Gmerge*       Superseded by |:Git| merge and |:Git_mergetool|.
+*:Gpull*        Superseded by |:Git| pull.
+*:Grebase*      Superseded by |:Git| rebase.
+*:Grevert*      Superseded by |:Git| revert.
+*:Gpush*        Superseded by |:Git| push.
+*:Gfetch*       Superseded by |:Git| fetch.
+*:Glog*         Superseded by |:Gclog|.
+*:Gstatus*      Superseded by |:Git| (with no arguments).
+*:Git!*         Superseded by |:Git_--paginate|.
+*:Gsplit!*      Superseded by |:Git_--paginate|.
+*:Gvsplit!*     Superseded by :vert Git --paginate.
+*:Gtabsplit!*   Superseded by :tab Git --paginate.
+*:Gpedit!*      Superseded by :Git! --paginate.
+
 ABOUT                                           *fugitive-about*
 
 Grab the latest version or report a bug on GitHub:
 
-http://github.com/tpope/vim-fugitive
+https://github.com/tpope/vim-fugitive
 
  vim:tw=78:et:ft=help:norl:
diff --git a/vim/bundle/vim-fugitive/ftdetect/fugitive.vim b/vim/bundle/vim-fugitive/ftdetect/fugitive.vim
new file mode 100644
index 0000000..d2bda26
--- /dev/null
+++ b/vim/bundle/vim-fugitive/ftdetect/fugitive.vim
@@ -0,0 +1 @@
+autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame
diff --git a/vim/bundle/vim-fugitive/plugin/fugitive.vim b/vim/bundle/vim-fugitive/plugin/fugitive.vim
index 81b519e..ec85721 100644
--- a/vim/bundle/vim-fugitive/plugin/fugitive.vim
+++ b/vim/bundle/vim-fugitive/plugin/fugitive.vim
@@ -1,186 +1,266 @@
 " fugitive.vim - A Git wrapper so awesome, it should be illegal
 " Maintainer:   Tim Pope <http://tpo.pe/>
-" Version:      2.2
+" Version:      3.2
 " GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim
 
-if exists('g:loaded_fugitive') || &cp
+if exists('g:loaded_fugitive')
   finish
 endif
 let g:loaded_fugitive = 1
 
-if !exists('g:fugitive_git_executable')
-  let g:fugitive_git_executable = 'git'
-endif
-
-" Section: Utility
-
-function! s:function(name) abort
-  return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),''))
-endfunction
-
-function! s:sub(str,pat,rep) abort
-  return substitute(a:str,'\v\C'.a:pat,a:rep,'')
+function! FugitiveGitDir(...) abort
+  if !a:0 || type(a:1) == type(0) && a:1 < 0
+    if exists('g:fugitive_event')
+      return g:fugitive_event
+    endif
+    let dir = get(b:, 'git_dir', '')
+    if empty(dir) && (empty(bufname('')) || &buftype =~# '^\%(nofile\|acwrite\|quickfix\|prompt\)$')
+      return FugitiveExtractGitDir(getcwd())
+    endif
+    return dir
+  elseif type(a:1) == type(0)
+    return getbufvar(a:1, 'git_dir')
+  elseif type(a:1) == type('')
+    return substitute(s:Slash(a:1), '/$', '', '')
+  else
+    return ''
+  endif
 endfunction
 
-function! s:gsub(str,pat,rep) abort
-  return substitute(a:str,'\v\C'.a:pat,a:rep,'g')
+" FugitiveReal() takes a fugitive:// URL and returns the corresponding path in
+" the work tree.  This may be useful to get a cleaner path for inclusion in
+" the statusline, for example.  Note that the file and its parent directories
+" are not guaranteed to exist.
+"
+" This is intended as an abstract API to be used on any "virtual" path.  For a
+" buffer named foo://bar, check for a function named FooReal(), and if it
+" exists, call FooReal("foo://bar").
+function! FugitiveReal(...) abort
+  let file = a:0 ? a:1 : @%
+  if file =~# '^\a\a\+:' || a:0 > 1
+    return call('fugitive#Real', [file] + a:000[1:-1])
+  elseif file =~# '^/\|^\a:\|^$'
+    return file
+  else
+    return fnamemodify(file, ':p' . (file =~# '[\/]$' ? '' : ':s?[\/]$??'))
+  endif
 endfunction
 
-function! s:winshell() abort
-  return &shell =~? 'cmd' || exists('+shellslash') && !&shellslash
+" FugitiveFind() takes a Fugitive object and returns the appropriate Vim
+" buffer name.  You can use this to generate Fugitive URLs ("HEAD:README") or
+" to get the absolute path to a file in the Git dir (".git/HEAD"), the common
+" dir (".git/config"), or the work tree (":(top)Makefile").
+"
+" An optional second argument provides the Git dir, or the buffer number of a
+" buffer with a Git dir.  The default is the current buffer.
+function! FugitiveFind(...) abort
+  return fugitive#Find(a:0 ? a:1 : bufnr(''), FugitiveGitDir(a:0 > 1 ? a:2 : -1))
 endfunction
 
-function! s:shellesc(arg) abort
-  if a:arg =~ '^[A-Za-z0-9_/.-]\+$'
-    return a:arg
-  elseif s:winshell()
-    return '"'.s:gsub(s:gsub(a:arg, '"', '""'), '\%', '"%"').'"'
+function! FugitivePath(...) abort
+  if a:0 > 1
+    return fugitive#Path(a:1, a:2, FugitiveGitDir(a:0 > 2 ? a:3 : -1))
   else
-    return shellescape(a:arg)
+    return FugitiveReal(a:0 ? a:1 : @%)
   endif
 endfunction
 
-function! s:fnameescape(file) abort
-  if exists('*fnameescape')
-    return fnameescape(a:file)
-  else
-    return escape(a:file," \t\n*?[{`$\\%#'\"|!<")
+" FugitiveParse() takes a fugitive:// URL and returns a 2 element list
+" containing an object name ("commit:file") and the Git dir.  It's effectively
+" the inverse of FugitiveFind().
+function! FugitiveParse(...) abort
+  let path = s:Slash(a:0 ? a:1 : @%)
+  if path !~# '^fugitive:'
+    return ['', '']
   endif
-endfunction
-
-function! s:throw(string) abort
-  let v:errmsg = 'fugitive: '.a:string
+  let vals = matchlist(path, '\c^fugitive:\%(//\)\=\(.\{-\}\)\%(//\|::\)\(\x\{40,\}\|[0-3]\)\(/.*\)\=$')
+  if len(vals)
+    return [(vals[2] =~# '^.$' ? ':' : '') . vals[2] . substitute(vals[3], '^/', ':', ''), vals[1]]
+  endif
+  let v:errmsg = 'fugitive: invalid Fugitive URL ' . path
   throw v:errmsg
 endfunction
 
-function! s:warn(str) abort
-  echohl WarningMsg
-  echomsg a:str
-  echohl None
-  let v:warningmsg = a:str
+" FugitivePrepare() constructs a Git command string which can be executed with
+" functions like system() and commands like :!.  Integer arguments will be
+" treated as buffer numbers, and the appropriate relative path inserted in
+" their place.
+"
+" If the first argument is a string that looks like a path or an empty string,
+" it will be used as the Git dir.  If it's a buffer number, the Git dir for
+" that buffer will be used.  The default is the current buffer.
+function! FugitivePrepare(...) abort
+  return call('fugitive#Prepare', a:000)
 endfunction
 
-function! s:shellslash(path) abort
-  if s:winshell()
-    return s:gsub(a:path,'\\','/')
+function! FugitiveConfig(...) abort
+  if a:0 == 2 && type(a:2) != type({})
+    return fugitive#Config(a:1, FugitiveGitDir(a:2))
+  elseif a:0 == 1 && a:1 !~# '^[[:alnum:]-]\+\.'
+    return fugitive#Config(FugitiveGitDir(a:1))
   else
-    return a:path
+    return call('fugitive#Config', a:000)
   endif
 endfunction
 
-let s:executables = {}
+" Retrieve a Git configuration value.  An optional second argument provides
+" the Git dir as with FugitiveFind().  Pass a blank string to limit to the
+" global config.
+function! FugitiveConfigGet(name, ...) abort
+  return call('FugitiveConfig', [a:name] + a:000)
+endfunction
 
-function! s:executable(binary) abort
-  if !has_key(s:executables, a:binary)
-    let s:executables[a:binary] = executable(a:binary)
+" Like FugitiveConfigGet(), but return a list of all values.
+function! FugitiveConfigGetAll(name, ...) abort
+  if a:0 && type(a:1) ==# type({})
+    let config = a:1
+  else
+    let config = fugitive#Config(FugitiveGitDir(a:0 ? a:1 : -1))
   endif
-  return s:executables[a:binary]
+  let name = substitute(a:name, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+  return copy(get(config, name, []))
 endfunction
 
-let s:git_versions = {}
-
-function! s:git_command() abort
-  return get(g:, 'fugitive_git_command', g:fugitive_git_executable)
+function! FugitiveRemoteUrl(...) abort
+  return fugitive#RemoteUrl(a:0 ? a:1 : '', FugitiveGitDir(a:0 > 1 ? a:2 : -1))
 endfunction
 
-function! fugitive#git_version(...) abort
-  if !has_key(s:git_versions, g:fugitive_git_executable)
-    let s:git_versions[g:fugitive_git_executable] = matchstr(system(g:fugitive_git_executable.' --version'), "\\S\\+\n")
+function! FugitiveHead(...) abort
+  let dir = FugitiveGitDir(a:0 > 1 ? a:2 : -1)
+  if empty(dir)
+    return ''
   endif
-  return s:git_versions[g:fugitive_git_executable]
+  return fugitive#Head(a:0 ? a:1 : 0, dir)
 endfunction
 
-function! s:recall() abort
-  let rev = s:sub(s:buffer().rev(), '^/', '')
-  if rev ==# ':'
-    return matchstr(getline('.'),'^#\t\%([[:alpha:] ]\+: *\)\=\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$\|^\d\{6} \x\{40\} \d\t\zs.*')
-  elseif s:buffer().type('tree')
-    let file = matchstr(getline('.'), '\t\zs.*')
-    if empty(file) && line('.') > 2
-      let file = s:sub(getline('.'), '/$', '')
-    endif
-    if !empty(file) && rev !~# ':$'
-      return rev . '/' . file
-    else
-      return rev . file
-    endif
+function! FugitiveStatusline(...) abort
+  if !exists('b:git_dir')
+    return ''
   endif
-  return rev
-endfunction
-
-function! s:add_methods(namespace, method_names) abort
-  for name in a:method_names
-    let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name)
-  endfor
+  return fugitive#Statusline()
 endfunction
 
-let s:commands = []
-function! s:command(definition) abort
-  let s:commands += [a:definition]
+function! FugitiveCommonDir(...) abort
+  let dir = FugitiveGitDir(a:0 ? a:1 : -1)
+  if empty(dir)
+    return ''
+  endif
+  return fugitive#CommonDir(dir)
 endfunction
 
-function! s:define_commands() abort
-  for command in s:commands
-    exe 'command! -buffer '.command
-  endfor
+function! FugitiveWorkTree(...) abort
+  return s:Tree(FugitiveGitDir(a:0 ? a:1 : -1))
 endfunction
 
-let s:abstract_prototype = {}
-
-" Section: Initialization
-
-function! fugitive#is_git_dir(path) abort
-  let path = s:sub(a:path, '[\/]$', '') . '/'
-  return getfsize(path.'HEAD') > 10 && (
+function! FugitiveIsGitDir(path) abort
+  let path = substitute(a:path, '[\/]$', '', '') . '/'
+  return len(a:path) && getfsize(path.'HEAD') > 10 && (
         \ isdirectory(path.'objects') && isdirectory(path.'refs') ||
         \ getftype(path.'commondir') ==# 'file')
 endfunction
 
-function! fugitive#extract_git_dir(path) abort
-  if s:shellslash(a:path) =~# '^fugitive://.*//'
-    return matchstr(s:shellslash(a:path), '\C^fugitive://\zs.\{-\}\ze//')
+let s:worktree_for_dir = {}
+let s:dir_for_worktree = {}
+function! s:Tree(path) abort
+  let dir = a:path
+  if dir =~# '/\.git$'
+    return len(dir) ==# 5 ? '/' : dir[0:-6]
+  elseif dir ==# ''
+    return ''
+  endif
+  if !has_key(s:worktree_for_dir, dir)
+    let s:worktree_for_dir[dir] = ''
+    let config_file = dir . '/config'
+    if filereadable(config_file)
+      let config = readfile(config_file,'',10)
+      call filter(config,'v:val =~# "^\\s*worktree *="')
+      if len(config) == 1
+        let worktree = FugitiveVimPath(matchstr(config[0], '= *\zs.*'))
+      endif
+    elseif filereadable(dir . '/gitdir')
+      let worktree = fnamemodify(FugitiveVimPath(readfile(dir . '/gitdir')[0]), ':h')
+      if worktree ==# '.'
+        unlet! worktree
+      endif
+    endif
+    if exists('worktree')
+      let s:worktree_for_dir[dir] = s:Slash(resolve(worktree))
+      let s:dir_for_worktree[s:worktree_for_dir[dir]] = dir
+    endif
+  endif
+  if s:worktree_for_dir[dir] =~# '^\.'
+    return simplify(dir . '/' . s:worktree_for_dir[dir])
+  else
+    return s:worktree_for_dir[dir]
+  endif
+endfunction
+
+function! s:CeilingDirectories() abort
+  if !exists('s:ceiling_directories')
+    let s:ceiling_directories = []
+    let resolve = 1
+    for dir in split($GIT_CEILING_DIRECTORIES, has('win32') ? ';' : ':', 1)
+      if empty(dir)
+        let resolve = 0
+      elseif resolve
+        call add(s:ceiling_directories, resolve(dir))
+      else
+        call add(s:ceiling_directories, dir)
+      endif
+    endfor
   endif
-  if isdirectory(a:path)
-    let path = fnamemodify(a:path, ':p:s?[\/]$??')
+  return s:ceiling_directories + get(g:, 'ceiling_directories', [])
+endfunction
+
+function! FugitiveExtractGitDir(path) abort
+  let path = s:Slash(a:path)
+  if path =~# '^fugitive:'
+    return matchstr(path, '\C^fugitive:\%(//\)\=\zs.\{-\}\ze\%(//\|::\|$\)')
+  elseif empty(path)
+    return ''
+  elseif isdirectory(path)
+    let path = fnamemodify(path, ':p:s?/$??')
   else
-    let path = fnamemodify(a:path, ':p:h:s?[\/]$??')
+    let path = fnamemodify(path, ':p:h:s?/$??')
+  endif
+  let pre = substitute(matchstr(path, '^\a\a\+\ze:'), '^.', '\u&', '')
+  if len(pre) && exists('*' . pre . 'Real')
+    let path = s:Slash({pre}Real(path))
+  endif
+  let root = resolve(path)
+  if root !=# path
+    silent! exe (haslocaldir() ? 'lcd' : exists(':tcd') && haslocaldir(-1) ? 'tcd' : 'cd') '.'
   endif
-  let root = s:shellslash(resolve(path))
   let previous = ""
+  let env_git_dir = len($GIT_DIR) ? s:Slash(simplify(fnamemodify(FugitiveVimPath($GIT_DIR), ':p:s?[\/]$??'))) : ''
+  call s:Tree(env_git_dir)
   while root !=# previous
     if root =~# '\v^//%([^/]+/?)?$'
-      " This is for accessing network shares from Cygwin Vim. There won't be
-      " any git directory called //.git or //serverName/.git so let's avoid
-      " checking for them since such checks are extremely slow.
       break
     endif
-    if index(split($GIT_CEILING_DIRECTORIES, ':'), root) >= 0
+    if index(s:CeilingDirectories(), root) >= 0
       break
     endif
-    if root ==# $GIT_WORK_TREE && fugitive#is_git_dir($GIT_DIR)
-      return simplify(fnamemodify(expand($GIT_DIR), ':p:s?[\/]$??'))
-    endif
-    if fugitive#is_git_dir($GIT_DIR)
-      " Ensure that we've cached the worktree
-      call s:configured_tree(simplify(fnamemodify(expand($GIT_DIR), ':p:s?[\/]$??')))
-      if has_key(s:dir_for_worktree, root)
-        return s:dir_for_worktree[root]
-      endif
+    if root ==# $GIT_WORK_TREE && FugitiveIsGitDir(env_git_dir)
+      return env_git_dir
+    elseif has_key(s:dir_for_worktree, root)
+      return s:dir_for_worktree[root]
     endif
-    let dir = s:sub(root, '[\/]$', '') . '/.git'
+    let dir = substitute(root, '[\/]$', '', '') . '/.git'
     let type = getftype(dir)
-    if type ==# 'dir' && fugitive#is_git_dir(dir)
+    if type ==# 'dir' && FugitiveIsGitDir(dir)
       return dir
-    elseif type ==# 'link' && fugitive#is_git_dir(dir)
+    elseif type ==# 'link' && FugitiveIsGitDir(dir)
       return resolve(dir)
     elseif type !=# '' && filereadable(dir)
       let line = get(readfile(dir, '', 1), 0, '')
-      if line =~# '^gitdir: \.' && fugitive#is_git_dir(root.'/'.line[8:-1])
-        return simplify(root.'/'.line[8:-1])
-      elseif line =~# '^gitdir: ' && fugitive#is_git_dir(line[8:-1])
-        return line[8:-1]
+      let file_dir = s:Slash(FugitiveVimPath(matchstr(line, '^gitdir: \zs.*')))
+      if file_dir !~# '^/\|^\a:' && FugitiveIsGitDir(root . '/' . file_dir)
+        return simplify(root . '/' . file_dir)
+      elseif len(file_dir) && FugitiveIsGitDir(file_dir)
+        return file_dir
       endif
-    elseif fugitive#is_git_dir(root)
+    elseif FugitiveIsGitDir(root)
       return root
     endif
     let previous = root
@@ -189,2940 +269,256 @@ function! fugitive#extract_git_dir(path) abort
   return ''
 endfunction
 
-function! fugitive#detect(path) abort
-  if exists('b:git_dir') && (b:git_dir ==# '' || b:git_dir =~# '/$')
+function! FugitiveDetect(path) abort
+  if exists('b:git_dir') && b:git_dir =~# '^$\|/$\|^fugitive:'
     unlet b:git_dir
   endif
   if !exists('b:git_dir')
-    let dir = fugitive#extract_git_dir(a:path)
+    let dir = FugitiveExtractGitDir(a:path)
     if dir !=# ''
       let b:git_dir = dir
-      if empty(fugitive#buffer().path())
-        silent! exe haslocaldir() ? 'lcd .' : 'cd .'
-      endif
     endif
   endif
-  if exists('b:git_dir')
-    if exists('#User#FugitiveBoot')
-      try
-        let [save_mls, &modelines] = [&mls, 0]
-        doautocmd User FugitiveBoot
-      finally
-        let &mls = save_mls
-      endtry
-    endif
-    if !exists('g:fugitive_no_maps')
-      cnoremap <buffer> <expr> <C-R><C-G> fnameescape(<SID>recall())
-      nnoremap <buffer> <silent> y<C-G> :call setreg(v:register, <SID>recall())<CR>
-    endif
-    let buffer = fugitive#buffer()
-    if expand('%:p') =~# '://'
-      call buffer.setvar('&path', s:sub(buffer.getvar('&path'), '^\.%(,|$)', ''))
-    endif
-    if stridx(buffer.getvar('&tags'), escape(b:git_dir, ', ')) == -1
-      if filereadable(b:git_dir.'/tags')
-        call buffer.setvar('&tags', escape(b:git_dir.'/tags', ', ').','.buffer.getvar('&tags'))
-      endif
-      if &filetype !=# '' && filereadable(b:git_dir.'/'.&filetype.'.tags')
-        call buffer.setvar('&tags', escape(b:git_dir.'/'.&filetype.'.tags', ', ').','.buffer.getvar('&tags'))
-      endif
-    endif
+  if !exists('b:git_dir') || !exists('#User#Fugitive')
+    return ''
+  endif
+  if v:version >= 704 || (v:version == 703 && has('patch442'))
+    doautocmd <nomodeline> User Fugitive
+  elseif &modelines > 0
+    let modelines = &modelines
     try
-      let [save_mls, &modelines] = [&mls, 0]
-      call s:define_commands()
+      set modelines=0
       doautocmd User Fugitive
     finally
-      let &mls = save_mls
+      let &modelines = modelines
     endtry
-  endif
-endfunction
-
-augroup fugitive
-  autocmd!
-  autocmd BufNewFile,BufReadPost * call fugitive#detect(expand('%:p'))
-  autocmd FileType           netrw call fugitive#detect(expand('%:p'))
-  autocmd User NERDTreeInit,NERDTreeNewRoot call fugitive#detect(b:NERDTree.root.path.str())
-  autocmd VimEnter * if expand('<amatch>')==''|call fugitive#detect(getcwd())|endif
-  autocmd CmdWinEnter * call fugitive#detect(expand('#:p'))
-  autocmd BufWinLeave * execute getwinvar(+bufwinnr(+expand('<abuf>')), 'fugitive_leave')
-augroup END
-
-" Section: Repository
-
-let s:repo_prototype = {}
-let s:repos = {}
-let s:worktree_for_dir = {}
-let s:dir_for_worktree = {}
-
-function! s:repo(...) abort
-  let dir = a:0 ? a:1 : (exists('b:git_dir') && b:git_dir !=# '' ? b:git_dir : fugitive#extract_git_dir(expand('%:p')))
-  if dir !=# ''
-    if has_key(s:repos, dir)
-      let repo = get(s:repos, dir)
-    else
-      let repo = {'git_dir': dir}
-      let s:repos[dir] = repo
-    endif
-    return extend(extend(repo, s:repo_prototype, 'keep'), s:abstract_prototype, 'keep')
-  endif
-  call s:throw('not a git repository: '.expand('%:p'))
-endfunction
-
-function! fugitive#repo(...) abort
-  return call('s:repo', a:000)
-endfunction
-
-function! s:repo_dir(...) dict abort
-  return join([self.git_dir]+a:000,'/')
-endfunction
-
-function! s:configured_tree(git_dir) abort
-  if !has_key(s:worktree_for_dir, a:git_dir)
-    let s:worktree_for_dir[a:git_dir] = ''
-    let config_file = a:git_dir . '/config'
-    if filereadable(config_file)
-      let config = readfile(config_file,'',10)
-      call filter(config,'v:val =~# "^\\s*worktree *="')
-      if len(config) == 1
-        let worktree = matchstr(config[0], '= *\zs.*')
-      endif
-    elseif filereadable(a:git_dir . '/gitdir')
-      let worktree = fnamemodify(readfile(a:git_dir . '/gitdir')[0], ':h')
-      if worktree ==# '.'
-        unlet! worktree
-      endif
-    endif
-    if exists('worktree')
-      let s:worktree_for_dir[a:git_dir] = worktree
-      let s:dir_for_worktree[s:worktree_for_dir[a:git_dir]] = a:git_dir
-    endif
-  endif
-  if s:worktree_for_dir[a:git_dir] =~# '^\.'
-    return simplify(a:git_dir . '/' . s:worktree_for_dir[a:git_dir])
-  else
-    return s:worktree_for_dir[a:git_dir]
-  endif
-endfunction
-
-function! s:repo_tree(...) dict abort
-  if self.dir() =~# '/\.git$'
-    let dir = self.dir()[0:-6]
-    if dir !~# '/'
-      let dir .= '/'
-    endif
-  else
-    let dir = s:configured_tree(self.git_dir)
-  endif
-  if dir ==# ''
-    call s:throw('no work tree')
-  else
-    return join([dir]+a:000,'/')
-  endif
-endfunction
-
-function! s:repo_bare() dict abort
-  if self.dir() =~# '/\.git$'
-    return 0
   else
-    return s:configured_tree(self.git_dir) ==# ''
+    doautocmd User Fugitive
   endif
+  return ''
 endfunction
 
-function! s:repo_translate(spec) dict abort
-  let refs = self.dir('refs/')
-  if filereadable(self.dir('commondir'))
-    let refs = simplify(self.dir(get(readfile(self.dir('commondir'), 1), 0, ''))) . '/refs/'
-  endif
-  if a:spec ==# '.' || a:spec ==# '/.'
-    return self.bare() ? self.dir() : self.tree()
-  elseif a:spec =~# '^/\=\.git$' && self.bare()
-    return self.dir()
-  elseif a:spec =~# '^/\=\.git/'
-    return self.dir(s:sub(a:spec, '^/=\.git/', ''))
-  elseif a:spec =~# '^/'
-    return self.tree().a:spec
-  elseif a:spec =~# '^:[0-3]:'
-    return 'fugitive://'.self.dir().'//'.a:spec[1].'/'.a:spec[3:-1]
-  elseif a:spec ==# ':'
-    if $GIT_INDEX_FILE =~# '/[^/]*index[^/]*\.lock$' && fnamemodify($GIT_INDEX_FILE,':p')[0:strlen(self.dir())] ==# self.dir('') && filereadable($GIT_INDEX_FILE)
-      return fnamemodify($GIT_INDEX_FILE,':p')
-    else
-      return self.dir('index')
-    endif
-  elseif a:spec =~# '^:/'
-    let ref = self.rev_parse(matchstr(a:spec,'.[^:]*'))
-    return 'fugitive://'.self.dir().'//'.ref
-  elseif a:spec =~# '^:'
-    return 'fugitive://'.self.dir().'//0/'.a:spec[1:-1]
-  elseif a:spec ==# '@'
-    return self.dir('HEAD')
-  elseif a:spec =~# 'HEAD\|^refs/' && a:spec !~ ':' && filereadable(refs . '../' . a:spec)
-    return simplify(refs . '../' . a:spec)
-  elseif filereadable(refs.a:spec)
-    return refs.a:spec
-  elseif filereadable(refs.'tags/'.a:spec)
-    return refs.'tags/'.a:spec
-  elseif filereadable(refs.'heads/'.a:spec)
-    return refs.'heads/'.a:spec
-  elseif filereadable(refs.'remotes/'.a:spec)
-    return refs.'remotes/'.a:spec
-  elseif filereadable(refs.'remotes/'.a:spec.'/HEAD')
-    return refs.'remotes/'.a:spec.'/HEAD'
+function! FugitiveVimPath(path) abort
+  if exists('+shellslash') && !&shellslash
+    return tr(a:path, '/', '\')
   else
-    try
-      let ref = self.rev_parse(matchstr(a:spec,'[^:]*'))
-      let path = s:sub(matchstr(a:spec,':.*'),'^:','/')
-      return 'fugitive://'.self.dir().'//'.ref.path
-    catch /^fugitive:/
-      return self.tree(a:spec)
-    endtry
+    return a:path
   endif
 endfunction
 
-function! s:repo_head(...) dict abort
-    let head = s:repo().head_ref()
-
-    if head =~# '^ref: '
-      let branch = s:sub(head,'^ref: %(refs/%(heads/|remotes/|tags/)=)=','')
-    elseif head =~# '^\x\{40\}$'
-      " truncate hash to a:1 characters if we're in detached head mode
-      let len = a:0 ? a:1 : 0
-      let branch = len ? head[0:len-1] : ''
-    else
-      return ''
-    endif
-
-    return branch
-endfunction
-
-call s:add_methods('repo',['dir','tree','bare','translate','head'])
-
-function! s:repo_git_command(...) dict abort
-  let git = s:git_command() . ' --git-dir='.s:shellesc(self.git_dir)
-  return git.join(map(copy(a:000),'" ".s:shellesc(v:val)'),'')
-endfunction
-
-function! s:repo_git_chomp(...) dict abort
-  let git = g:fugitive_git_executable . ' --git-dir='.s:shellesc(self.git_dir)
-  let output = git.join(map(copy(a:000),'" ".s:shellesc(v:val)'),'')
-  return s:sub(system(output),'\n$','')
+function! FugitiveGitPath(path) abort
+  return s:Slash(a:path)
 endfunction
 
-function! s:repo_git_chomp_in_tree(...) dict abort
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let dir = getcwd()
-  try
-    execute cd s:fnameescape(s:repo().tree())
-    return call(s:repo().git_chomp, a:000, s:repo())
-  finally
-    execute cd s:fnameescape(dir)
-  endtry
-endfunction
+if exists('+shellslash')
+  function! s:Slash(path) abort
+    return tr(a:path, '\', '/')
+  endfunction
+else
+  function! s:Slash(path) abort
+    return a:path
+  endfunction
+endif
 
-function! s:repo_rev_parse(rev) dict abort
-  let hash = self.git_chomp('rev-parse','--verify',a:rev)
-  if hash =~ '\<\x\{40\}$'
-    return matchstr(hash,'\<\x\{40\}$')
+function! s:ProjectionistDetect() abort
+  let file = s:Slash(get(g:, 'projectionist_file', ''))
+  let dir = FugitiveExtractGitDir(file)
+  let base = matchstr(file, '^fugitive://.\{-\}//\x\+')
+  if empty(base)
+    let base = s:Tree(dir)
   endif
-  call s:throw('rev-parse '.a:rev.': '.hash)
-endfunction
-
-call s:add_methods('repo',['git_command','git_chomp','git_chomp_in_tree','rev_parse'])
-
-function! s:repo_dirglob(base) dict abort
-  let base = s:sub(a:base,'^/','')
-  let matches = split(glob(self.tree(s:gsub(base,'/','*&').'*/')),"\n")
-  call map(matches,'v:val[ strlen(self.tree())+(a:base !~ "^/") : -1 ]')
-  return matches
-endfunction
-
-function! s:repo_superglob(base) dict abort
-  if a:base =~# '^/' || a:base !~# ':'
-    let results = []
-    if a:base !~# '^/'
-      let heads = ["HEAD","ORIG_HEAD","FETCH_HEAD","MERGE_HEAD"]
-      let heads += sort(split(s:repo().git_chomp("rev-parse","--symbolic","--branches","--tags","--remotes"),"\n"))
-      " Add any stashes.
-      if filereadable(s:repo().dir('refs/stash'))
-        let heads += ["stash"]
-        let heads += sort(split(s:repo().git_chomp("stash","list","--pretty=format:%gd"),"\n"))
-      endif
-      call filter(heads,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
-      let results += heads
-    endif
-    if !self.bare()
-      let base = s:sub(a:base,'^/','')
-      let matches = split(glob(self.tree(s:gsub(base,'/','*&').'*')),"\n")
-      call map(matches,'s:shellslash(v:val)')
-      call map(matches,'v:val !~ "/$" && isdirectory(v:val) ? v:val."/" : v:val')
-      call map(matches,'v:val[ strlen(self.tree())+(a:base !~ "^/") : -1 ]')
-      let results += matches
+  if len(base)
+    if exists('+shellslash') && !&shellslash
+      let base = tr(base, '/', '\')
     endif
-    return results
-
-  elseif a:base =~# '^:'
-    let entries = split(self.git_chomp('ls-files','--stage'),"\n")
-    call map(entries,'s:sub(v:val,".*(\\d)\\t(.*)",":\\1:\\2")')
-    if a:base !~# '^:[0-3]\%(:\|$\)'
-      call filter(entries,'v:val[1] == "0"')
-      call map(entries,'v:val[2:-1]')
+    let file = FugitiveCommonDir(dir) . '/info/projections.json'
+    if filereadable(file)
+      call projectionist#append(base, file)
     endif
-    call filter(entries,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
-    return entries
-
-  else
-    let tree = matchstr(a:base,'.*[:/]')
-    let entries = split(self.git_chomp('ls-tree',tree),"\n")
-    call map(entries,'s:sub(v:val,"^04.*\\zs$","/")')
-    call map(entries,'tree.s:sub(v:val,".*\t","")')
-    return filter(entries,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
-  endif
-endfunction
-
-call s:add_methods('repo',['dirglob','superglob'])
-
-function! s:repo_config(conf) dict abort
-  return matchstr(s:repo().git_chomp('config',a:conf),"[^\r\n]*")
-endfun
-
-function! s:repo_user() dict abort
-  let username = s:repo().config('user.name')
-  let useremail = s:repo().config('user.email')
-  return username.' <'.useremail.'>'
-endfun
-
-function! s:repo_aliases() dict abort
-  if !has_key(self,'_aliases')
-    let self._aliases = {}
-    for line in split(self.git_chomp('config','-z','--get-regexp','^alias[.]'),"\1")
-      let self._aliases[matchstr(line, '\.\zs.\{-}\ze\n')] = matchstr(line, '\n\zs.*')
-    endfor
-  endif
-  return self._aliases
-endfunction
-
-call s:add_methods('repo',['config', 'user', 'aliases'])
-
-function! s:repo_keywordprg() dict abort
-  let args = ' --git-dir='.escape(self.dir(),"\\\"' ")
-  if has('gui_running') && !has('win32')
-    return s:git_command() . ' --no-pager' . args . ' log -1'
-  else
-    return s:git_command() . args . ' show'
-  endif
-endfunction
-
-call s:add_methods('repo',['keywordprg'])
-
-" Section: Buffer
-
-let s:buffer_prototype = {}
-
-function! s:buffer(...) abort
-  let buffer = {'#': bufnr(a:0 ? a:1 : '%')}
-  call extend(extend(buffer,s:buffer_prototype,'keep'),s:abstract_prototype,'keep')
-  if buffer.getvar('git_dir') !=# ''
-    return buffer
-  endif
-  call s:throw('not a git repository: '.expand('%:p'))
-endfunction
-
-function! fugitive#buffer(...) abort
-  return s:buffer(a:0 ? a:1 : '%')
-endfunction
-
-function! s:buffer_getvar(var) dict abort
-  return getbufvar(self['#'],a:var)
-endfunction
-
-function! s:buffer_setvar(var,value) dict abort
-  return setbufvar(self['#'],a:var,a:value)
-endfunction
-
-function! s:buffer_getline(lnum) dict abort
-  return get(getbufline(self['#'], a:lnum), 0, '')
-endfunction
-
-function! s:buffer_repo() dict abort
-  return s:repo(self.getvar('git_dir'))
-endfunction
-
-function! s:buffer_type(...) dict abort
-  if self.getvar('fugitive_type') != ''
-    let type = self.getvar('fugitive_type')
-  elseif fnamemodify(self.spec(),':p') =~# '.\git/refs/\|\.git/\w*HEAD$'
-    let type = 'head'
-  elseif self.getline(1) =~ '^tree \x\{40\}$' && self.getline(2) == ''
-    let type = 'tree'
-  elseif self.getline(1) =~ '^\d\{6\} \w\{4\} \x\{40\}\>\t'
-    let type = 'tree'
-  elseif self.getline(1) =~ '^\d\{6\} \x\{40\}\> \d\t'
-    let type = 'index'
-  elseif isdirectory(self.spec())
-    let type = 'directory'
-  elseif self.spec() == ''
-    let type = 'null'
-  else
-    let type = 'file'
-  endif
-  if a:0
-    return !empty(filter(copy(a:000),'v:val ==# type'))
-  else
-    return type
   endif
 endfunction
 
-if has('win32')
-
-  function! s:buffer_spec() dict abort
-    let bufname = bufname(self['#'])
-    let retval = ''
-    for i in split(bufname,'[^:]\zs\\')
-      let retval = fnamemodify((retval==''?'':retval.'\').i,':.')
-    endfor
-    return s:shellslash(fnamemodify(retval,':p'))
-  endfunction
-
-else
-
-  function! s:buffer_spec() dict abort
-    let bufname = bufname(self['#'])
-    return s:shellslash(bufname == '' ? '' : fnamemodify(bufname,':p'))
-  endfunction
-
+if v:version + has('patch061') < 703
+  runtime! autoload/fugitive.vim
 endif
+let g:io_fugitive = {
+      \ 'simplify': function('fugitive#simplify'),
+      \ 'resolve': function('fugitive#resolve'),
+      \ 'getftime': function('fugitive#getftime'),
+      \ 'getfsize': function('fugitive#getfsize'),
+      \ 'getftype': function('fugitive#getftype'),
+      \ 'filereadable': function('fugitive#filereadable'),
+      \ 'filewritable': function('fugitive#filewritable'),
+      \ 'isdirectory': function('fugitive#isdirectory'),
+      \ 'getfperm': function('fugitive#getfperm'),
+      \ 'setfperm': function('fugitive#setfperm'),
+      \ 'readfile': function('fugitive#readfile'),
+      \ 'writefile': function('fugitive#writefile'),
+      \ 'glob': function('fugitive#glob'),
+      \ 'delete': function('fugitive#delete'),
+      \ 'Real': function('FugitiveReal')}
 
-function! s:buffer_name() dict abort
-  return self.spec()
-endfunction
-
-function! s:buffer_commit() dict abort
-  return matchstr(self.spec(),'^fugitive://.\{-\}//\zs\w*')
-endfunction
+augroup fugitive
+  autocmd!
 
-function! s:cpath(path) abort
-  if exists('+fileignorecase') && &fileignorecase
-    return tolower(a:path)
-  else
-    return a:path
-  endif
-endfunction
+  autocmd BufNewFile,BufReadPost * call FugitiveDetect(expand('<amatch>:p'))
+  autocmd FileType           netrw call FugitiveDetect(fnamemodify(get(b:, 'netrw_curdir', expand('<amatch>')), ':p'))
 
-function! s:buffer_path(...) dict abort
-  let rev = matchstr(self.spec(),'^fugitive://.\{-\}//\zs.*')
-  if rev != ''
-    let rev = s:sub(rev,'\w*','')
-  elseif s:cpath(self.spec()[0 : len(self.repo().dir())]) ==#
-        \ s:cpath(self.repo().dir() . '/')
-    let rev = '/.git'.self.spec()[strlen(self.repo().dir()) : -1]
-  elseif !self.repo().bare() &&
-        \ s:cpath(self.spec()[0 : len(self.repo().tree())]) ==#
-        \ s:cpath(self.repo().tree() . '/')
-    let rev = self.spec()[strlen(self.repo().tree()) : -1]
-  endif
-  return s:sub(s:sub(rev,'.\zs/$',''),'^/',a:0 ? a:1 : '')
-endfunction
+  autocmd FileType git
+        \ call fugitive#MapCfile()
+  autocmd FileType gitcommit
+        \ call fugitive#MapCfile('fugitive#MessageCfile()')
+  autocmd FileType git,gitcommit
+        \ if &foldtext ==# 'foldtext()' |
+        \    setlocal foldtext=fugitive#Foldtext() |
+        \ endif
+  autocmd FileType fugitive
+        \ call fugitive#MapCfile('fugitive#StatusCfile()')
+  autocmd FileType gitrebase
+        \ let &l:include = '^\%(pick\|squash\|edit\|reword\|fixup\|drop\|[pserfd]\)\>' |
+        \ if &l:includeexpr !~# 'Fugitive' |
+        \   let &l:includeexpr = 'v:fname =~# ''^\x\{4,\}$'' && len(FugitiveGitDir()) ? FugitiveFind(v:fname) : ' .
+        \     (len(&l:includeexpr) ? &l:includeexpr : 'v:fname') |
+        \ endif |
+        \ let b:undo_ftplugin = get(b:, 'undo_ftplugin', 'exe') . '|setl inex= inc='
+
+  autocmd BufReadCmd index{,.lock}
+        \ if FugitiveIsGitDir(expand('<amatch>:p:h')) |
+        \   let b:git_dir = s:Slash(expand('<amatch>:p:h')) |
+        \   exe fugitive#BufReadStatus() |
+        \ elseif filereadable(expand('<amatch>')) |
+        \   silent doautocmd BufReadPre |
+        \   keepalt read <amatch> |
+        \   1delete_ |
+        \   silent doautocmd BufReadPost |
+        \ else |
+        \   silent doautocmd BufNewFile |
+        \ endif
 
-function! s:buffer_rev() dict abort
-  let rev = matchstr(self.spec(),'^fugitive://.\{-\}//\zs.*')
-  if rev =~ '^\x/'
-    return ':'.rev[0].':'.rev[2:-1]
-  elseif rev =~ '.'
-    return s:sub(rev,'/',':')
-  elseif self.spec() =~ '\.git/index$'
-    return ':'
-  elseif self.spec() =~ '\.git/refs/\|\.git/.*HEAD$'
-    return self.spec()[strlen(self.repo().dir())+1 : -1]
-  else
-    return self.path('/')
+  autocmd BufReadCmd    fugitive://*//*             exe fugitive#BufReadCmd() |
+        \ if &path =~# '^\.\%(,\|$\)' |
+        \   let &l:path = substitute(&path, '^\.,\=', '', '') |
+        \ endif
+  autocmd BufWriteCmd   fugitive://*//[0-3]/*       exe fugitive#BufWriteCmd()
+  autocmd FileReadCmd   fugitive://*//*             exe fugitive#FileReadCmd()
+  autocmd FileWriteCmd  fugitive://*//[0-3]/*       exe fugitive#FileWriteCmd()
+  if exists('##SourceCmd')
+    autocmd SourceCmd     fugitive://*//*    nested exe fugitive#SourceCmd()
   endif
-endfunction
 
-function! s:buffer_sha1() dict abort
-  if self.spec() =~ '^fugitive://' || self.spec() =~ '\.git/refs/\|\.git/.*HEAD$'
-    return self.repo().rev_parse(self.rev())
-  else
-    return ''
-  endif
-endfunction
+  autocmd User Flags call Hoist('buffer', function('FugitiveStatusline'))
 
-function! s:buffer_expand(rev) dict abort
-  if a:rev =~# '^:[0-3]$'
-    let file = a:rev.self.path(':')
-  elseif a:rev =~# '^[-:]/$'
-    let file = '/'.self.path()
-  elseif a:rev =~# '^-'
-    let file = 'HEAD^{}'.a:rev[1:-1].self.path(':')
-  elseif a:rev =~# '^@{'
-    let file = 'HEAD'.a:rev.self.path(':')
-  elseif a:rev =~# '^[~^]'
-    let commit = s:sub(self.commit(),'^\d=$','HEAD')
-    let file = commit.a:rev.self.path(':')
-  else
-    let file = a:rev
-  endif
-  return s:sub(substitute(file,
-        \ '%$\|\\\([[:punct:]]\)','\=len(submatch(1)) ? submatch(1) : self.path()','g'),
-        \ '\.\@<=/$','')
-endfunction
+  autocmd User ProjectionistDetect call s:ProjectionistDetect()
+augroup END
 
-function! s:buffer_containing_commit() dict abort
-  if self.commit() =~# '^\d$'
-    return ':'
-  elseif self.commit() =~# '.'
-    return self.commit()
-  else
-    return 'HEAD'
-  endif
-endfunction
+let s:addr_other = has('patch-8.1.560') ? '-addr=other' : ''
+let s:addr_tabs  = has('patch-7.4.542') ? '-addr=tabs' : ''
+let s:addr_wins  = has('patch-7.4.542') ? '-addr=windows' : ''
 
-function! s:buffer_up(...) dict abort
-  let rev = self.rev()
-  let c = a:0 ? a:1 : 1
-  while c
-    if rev =~# '^[/:]$'
-      let rev = 'HEAD'
-    elseif rev =~# '^:'
-      let rev = ':'
-    elseif rev =~# '^refs/[^^~:]*$\|^[^^~:]*HEAD$'
-      let rev .= '^{}'
-    elseif rev =~# '^/\|:.*/'
-      let rev = s:sub(rev, '.*\zs/.*', '')
-    elseif rev =~# ':.'
-      let rev = matchstr(rev, '^[^:]*:')
-    elseif rev =~# ':$'
-      let rev = rev[0:-2]
-    else
-      return rev.'~'.c
-    endif
-    let c -= 1
-  endwhile
-  return rev
-endfunction
+if exists(':G') != 2
+  command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#Complete G   exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)
+endif
+command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#Complete Git exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)
 
-call s:add_methods('buffer',['getvar','setvar','getline','repo','type','spec','name','commit','path','rev','sha1','expand','containing_commit','up'])
+if exists(':Gstatus') !=# 2
+  exe 'command! -bang -bar     -range=-1' s:addr_other 'Gstatus exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+endif
 
-" Section: Git
+for s:cmd in ['Commit', 'Revert', 'Merge', 'Rebase', 'Pull', 'Push', 'Fetch', 'Blame']
+  if exists(':G' . tolower(s:cmd)) != 2
+    exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#' . s:cmd . 'Complete G' . tolower(s:cmd)
+          \ 'echohl WarningMSG|echo ":G' . tolower(s:cmd) . ' is deprecated in favor of :Git ' . tolower(s:cmd) . '\n"|echohl NONE|'
+          \ 'exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "' . tolower(s:cmd) . ' " . <q-args>)'
+  endif
+endfor
+unlet s:cmd
+
+exe "command! -bar -bang -nargs=? -complete=customlist,fugitive#CdComplete Gcd  exe fugitive#Cd(<q-args>, 0)"
+exe "command! -bar -bang -nargs=? -complete=customlist,fugitive#CdComplete Glcd exe fugitive#Cd(<q-args>, 1)"
+
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Ggrep  exe fugitive#GrepCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Gcgrep exe fugitive#GrepCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Glgrep exe fugitive#GrepCommand(0, <count> > 0 ? <count> : 0, +"<range>", <bang>0, "<mods>", <q-args>)'
+
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Glog  :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Gclog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "c")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete GcLog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "c")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Gllog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "l")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete GlLog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "l")'
+
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Ge       exe fugitive#Open("edit<bang>", 0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Gedit    exe fugitive#Open("edit<bang>", 0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#ReadComplete   Gpedit   exe fugitive#Open("pedit", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_other '-complete=customlist,fugitive#ReadComplete   Gsplit   exe fugitive#Open((<count> > 0 ? <count> : "").(<count> ? "split" : "edit"), <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_other '-complete=customlist,fugitive#ReadComplete   Gvsplit  exe fugitive#Open((<count> > 0 ? <count> : "").(<count> ? "vsplit" : "edit!"), <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_tabs  '-complete=customlist,fugitive#ReadComplete   Gtabedit exe fugitive#Open((<count> >= 0 ? <count> : "")."tabedit", <bang>0, "<mods>", <q-args>, [<f-args>])'
+
+if exists(':Gr') != 2
+  exe 'command! -bar -bang -nargs=* -range=-1                -complete=customlist,fugitive#ReadComplete   Gr     exe fugitive#ReadCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
+exe 'command! -bar -bang -nargs=* -range=-1                -complete=customlist,fugitive#ReadComplete   Gread    exe fugitive#ReadCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gdiffsplit  exe fugitive#Diffsplit(1, <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Ghdiffsplit exe fugitive#Diffsplit(0, <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gvdiffsplit exe fugitive#Diffsplit(0, <bang>0, "vert <mods>", <q-args>, [<f-args>])'
+
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gw     exe fugitive#WriteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gwrite exe fugitive#WriteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gwq    exe fugitive#WqCommand(   <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+
+exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject GRemove exe fugitive#RemoveCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject GDelete exe fugitive#DeleteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#CompleteObject GMove   exe fugitive#MoveCommand(  <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#RenameComplete GRename exe fugitive#RenameCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+if exists(':Gremove') != 2
+  exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject Gremove exe fugitive#RemoveCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
+if exists(':Gdelete') != 2
+  exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject Gdelete exe fugitive#DeleteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
+if exists(':Gmove') != 2
+  exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#CompleteObject Gmove   exe fugitive#MoveCommand(  <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
+if exists(':Grename') != 2
+  exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#RenameComplete Grename exe fugitive#RenameCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
 
-call s:command("-bang -nargs=? -complete=customlist,s:GitComplete Git :execute s:Git(<bang>0,<q-args>)")
+exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject GBrowse exe fugitive#BrowseCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+if exists(':Gbrowse') != 2
+  exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject Gbrowse exe fugitive#BrowseCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
 
-function! s:ExecuteInTree(cmd) abort
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let dir = getcwd()
-  try
-    execute cd s:fnameescape(s:repo().tree())
-    execute a:cmd
-  finally
-    execute cd s:fnameescape(dir)
-  endtry
-endfunction
+if get(g:, 'fugitive_no_maps')
+  finish
+endif
 
-function! s:Git(bang, args) abort
-  if a:bang
-    return s:Edit('edit', 1, a:args)
-  endif
-  let git = s:git_command()
-  if has('gui_running') && !has('win32')
-    let git .= ' --no-pager'
-  endif
-  let args = matchstr(a:args,'\v\C.{-}%($|\\@<!%(\\\\)*\|)@=')
-  if exists(':terminal') && has('nvim')
-    let dir = s:repo().tree()
-    if expand('%') != ''
-      -tabedit %
-    else
-      -tabnew
-    endif
-    execute 'lcd' fnameescape(dir)
-    execute 'terminal' git args
-  else
-    call s:ExecuteInTree('!'.git.' '.args)
-    if has('win32')
-      call fugitive#reload_status()
+let s:nowait = v:version >= 704 ? '<nowait>' : ''
+
+function! s:Map(mode, lhs, rhs, ...) abort
+  for mode in split(a:mode, '\zs')
+    let flags = (a:0 ? a:1 : '') . (a:rhs =~# '<Plug>' ? '' : '<script>')
+    let head = a:lhs
+    let tail = ''
+    let keys = get(g:, mode.'remap', {})
+    if type(keys) == type([])
+      return
+    endif
+    while !empty(head)
+      if has_key(keys, head)
+        let head = keys[head]
+        if empty(head)
+          return
+        endif
+        break
+      endif
+      let tail = matchstr(head, '<[^<>]*>$\|.$') . tail
+      let head = substitute(head, '<[^<>]*>$\|.$', '', '')
+    endwhile
+    if flags !~# '<unique>' || empty(mapcheck(head.tail, mode))
+      exe mode.'map' s:nowait flags head.tail a:rhs
     endif
-  endif
-  return matchstr(a:args, '\v\C\\@<!%(\\\\)*\|\zs.*')
-endfunction
-
-function! fugitive#git_commands() abort
-  if !exists('s:exec_path')
-    let s:exec_path = s:sub(system(g:fugitive_git_executable.' --exec-path'),'\n$','')
-  endif
-  return map(split(glob(s:exec_path.'/git-*'),"\n"),'s:sub(v:val[strlen(s:exec_path)+5 : -1],"\\.exe$","")')
-endfunction
-
-function! s:GitComplete(A, L, P) abort
-  if strpart(a:L, 0, a:P) !~# ' [[:alnum:]-]\+ '
-    let cmds = fugitive#git_commands()
-    return filter(sort(cmds+keys(s:repo().aliases())), 'strpart(v:val, 0, strlen(a:A)) ==# a:A')
-  else
-    return s:repo().superglob(a:A)
-  endif
-endfunction
-
-" Section: Gcd, Glcd
-
-function! s:DirComplete(A,L,P) abort
-  let matches = s:repo().dirglob(a:A)
-  return matches
+  endfor
 endfunction
 
-call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Gcd  :exe 'cd<bang>'  s:fnameescape(s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>))")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Glcd :exe 'lcd<bang>' s:fnameescape(s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>))")
-
-" Section: Gstatus
-
-call s:command("-bar Gstatus :execute s:Status()")
-augroup fugitive_status
-  autocmd!
-  if !has('win32')
-    autocmd FocusGained,ShellCmdPost * call fugitive#reload_status()
-    autocmd BufDelete term://* call fugitive#reload_status()
-  endif
-augroup END
-
-function! s:Status() abort
-  try
-    Gpedit :
-    wincmd P
-    setlocal foldmethod=syntax foldlevel=1
-    nnoremap <buffer> <silent> q    :<C-U>bdelete<CR>
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-  return ''
-endfunction
-
-function! fugitive#reload_status() abort
-  if exists('s:reloading_status')
-    return
-  endif
-  try
-    let s:reloading_status = 1
-    let mytab = tabpagenr()
-    for tab in [mytab] + range(1,tabpagenr('$'))
-      for winnr in range(1,tabpagewinnr(tab,'$'))
-        if getbufvar(tabpagebuflist(tab)[winnr-1],'fugitive_type') ==# 'index'
-          execute 'tabnext '.tab
-          if winnr != winnr()
-            execute winnr.'wincmd w'
-            let restorewinnr = 1
-          endif
-          try
-            if !&modified
-              call s:BufReadIndex()
-            endif
-          finally
-            if exists('restorewinnr')
-              wincmd p
-            endif
-            execute 'tabnext '.mytab
-          endtry
-        endif
-      endfor
-    endfor
-  finally
-    unlet! s:reloading_status
-  endtry
-endfunction
-
-function! s:stage_info(lnum) abort
-  let filename = matchstr(getline(a:lnum),'^#\t\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$')
-  let lnum = a:lnum
-  if has('multi_byte_encoding')
-    let colon = '\%(:\|\%uff1a\)'
-  else
-    let colon = ':'
-  endif
-  while lnum && getline(lnum) !~# colon.'$'
-    let lnum -= 1
-  endwhile
-  if !lnum
-    return ['', '']
-  elseif (getline(lnum+1) =~# '^# .*\<git \%(reset\|rm --cached\) ' && getline(lnum+2) ==# '#') || getline(lnum) ==# '# Changes to be committed:'
-    return [matchstr(filename, colon.' *\zs.*'), 'staged']
-  elseif (getline(lnum+1) =~# '^# .*\<git add ' && getline(lnum+2) ==# '#' && getline(lnum+3) !~# colon.'  ') || getline(lnum) ==# '# Untracked files:'
-    return [filename, 'untracked']
-  elseif getline(lnum+2) =~# '^# .*\<git checkout ' || getline(lnum) ==# '# Changes not staged for commit:'
-    return [matchstr(filename, colon.' *\zs.*'), 'unstaged']
-  elseif getline(lnum+2) =~# '^# .*\<git \%(add\|rm\)' || getline(lnum) ==# '# Unmerged paths:'
-    return [matchstr(filename, colon.' *\zs.*'), 'unmerged']
-  else
-    return ['', 'unknown']
-  endif
-endfunction
-
-function! s:StageNext(count) abort
-  for i in range(a:count)
-    call search('^#\t.*','W')
-  endfor
-  return '.'
-endfunction
-
-function! s:StagePrevious(count) abort
-  if line('.') == 1 && exists(':CtrlP') && get(g:, 'ctrl_p_map') =~? '^<c-p>$'
-    return 'CtrlP '.fnameescape(s:repo().tree())
-  else
-    for i in range(a:count)
-      call search('^#\t.*','Wbe')
-    endfor
-    return '.'
-  endif
-endfunction
-
-function! s:StageReloadSeek(target,lnum1,lnum2) abort
-  let jump = a:target
-  let f = matchstr(getline(a:lnum1-1),'^#\t\%([[:alpha:] ]\+: *\|.*\%uff1a *\)\=\zs.*')
-  if f !=# '' | let jump = f | endif
-  let f = matchstr(getline(a:lnum2+1),'^#\t\%([[:alpha:] ]\+: *\|.*\%uff1a *\)\=\zs.*')
-  if f !=# '' | let jump = f | endif
-  silent! edit!
-  1
-  redraw
-  call search('^#\t\%([[:alpha:] ]\+: *\|.*\%uff1a *\)\=\V'.jump.'\%( ([^()[:digit:]]\+)\)\=\$','W')
-endfunction
-
-function! s:StageUndo() abort
-  let [filename, section] = s:stage_info(line('.'))
-  if empty(filename)
-    return ''
-  endif
-  let repo = s:repo()
-  let hash = repo.git_chomp('hash-object', '-w', filename)
-  if !empty(hash)
-    if section ==# 'untracked'
-      call repo.git_chomp_in_tree('clean', '-f', '--', filename)
-    elseif section ==# 'unmerged'
-      call repo.git_chomp_in_tree('rm', '--', filename)
-    elseif section ==# 'unstaged'
-      call repo.git_chomp_in_tree('checkout', '--', filename)
-    else
-      call repo.git_chomp_in_tree('checkout', 'HEAD', '--', filename)
-    endif
-    call s:StageReloadSeek(filename, line('.'), line('.'))
-    let @" = hash
-    return 'checktime|redraw|echomsg ' .
-          \ string('To restore, :Git cat-file blob '.hash[0:6].' > '.filename)
-  endif
-endfunction
-
-function! s:StageDiff(diff) abort
-  let [filename, section] = s:stage_info(line('.'))
-  if filename ==# '' && section ==# 'staged'
-    return 'Git! diff --no-ext-diff --cached'
-  elseif filename ==# ''
-    return 'Git! diff --no-ext-diff'
-  elseif filename =~# ' -> '
-    let [old, new] = split(filename,' -> ')
-    execute 'Gedit '.s:fnameescape(':0:'.new)
-    return a:diff.' HEAD:'.s:fnameescape(old)
-  elseif section ==# 'staged'
-    execute 'Gedit '.s:fnameescape(':0:'.filename)
-    return a:diff.' -'
-  else
-    execute 'Gedit '.s:fnameescape('/'.filename)
-    return a:diff
-  endif
-endfunction
-
-function! s:StageDiffEdit() abort
-  let [filename, section] = s:stage_info(line('.'))
-  let arg = (filename ==# '' ? '.' : filename)
-  if section ==# 'staged'
-    return 'Git! diff --no-ext-diff --cached '.s:shellesc(arg)
-  elseif section ==# 'untracked'
-    let repo = s:repo()
-    call repo.git_chomp_in_tree('add','--intent-to-add',arg)
-    if arg ==# '.'
-      silent! edit!
-      1
-      if !search('^# .*:\n#.*\n# .*"git checkout \|^# Changes not staged for commit:$','W')
-        call search('^# .*:$','W')
-      endif
-    else
-      call s:StageReloadSeek(arg,line('.'),line('.'))
-    endif
-    return ''
-  else
-    return 'Git! diff --no-ext-diff '.s:shellesc(arg)
-  endif
-endfunction
-
-function! s:StageToggle(lnum1,lnum2) abort
-  if a:lnum1 == 1 && a:lnum2 == 1
-    return 'Gedit /.git|call search("^index$", "wc")'
-  endif
-  try
-    let output = ''
-    for lnum in range(a:lnum1,a:lnum2)
-      let [filename, section] = s:stage_info(lnum)
-      let repo = s:repo()
-      if getline('.') =~# '^# .*:$'
-        if section ==# 'staged'
-          call repo.git_chomp_in_tree('reset','-q')
-          silent! edit!
-          1
-          if !search('^# .*:\n# .*"git add .*\n#\n\|^# Untracked files:$','W')
-            call search('^# .*:$','W')
-          endif
-          return ''
-        elseif section ==# 'unstaged'
-          call repo.git_chomp_in_tree('add','-u')
-          silent! edit!
-          1
-          if !search('^# .*:\n# .*"git add .*\n#\n\|^# Untracked files:$','W')
-            call search('^# .*:$','W')
-          endif
-          return ''
-        else
-          call repo.git_chomp_in_tree('add','.')
-          silent! edit!
-          1
-          call search('^# .*:$','W')
-          return ''
-        endif
-      endif
-      if filename ==# ''
-        continue
-      endif
-      execute lnum
-      if section ==# 'staged'
-        if filename =~ ' -> '
-          let files_to_unstage = split(filename,' -> ')
-        else
-          let files_to_unstage = [filename]
-        endif
-        let filename = files_to_unstage[-1]
-        let cmd = ['reset','-q','--'] + files_to_unstage
-      elseif getline(lnum) =~# '^#\tdeleted:'
-        let cmd = ['rm','--',filename]
-      elseif getline(lnum) =~# '^#\tmodified:'
-        let cmd = ['add','--',filename]
-      else
-        let cmd = ['add','-A','--',filename]
-      endif
-      if !exists('first_filename')
-        let first_filename = filename
-      endif
-      let output .= call(repo.git_chomp_in_tree,cmd,s:repo())."\n"
-    endfor
-    if exists('first_filename')
-      call s:StageReloadSeek(first_filename,a:lnum1,a:lnum2)
-    endif
-    echo s:sub(s:gsub(output,'\n+','\n'),'\n$','')
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-  return 'checktime'
-endfunction
-
-function! s:StagePatch(lnum1,lnum2) abort
-  let add = []
-  let reset = []
-
-  for lnum in range(a:lnum1,a:lnum2)
-    let [filename, section] = s:stage_info(lnum)
-    if getline('.') =~# '^# .*:$' && section ==# 'staged'
-      return 'Git reset --patch'
-    elseif getline('.') =~# '^# .*:$' && section ==# 'unstaged'
-      return 'Git add --patch'
-    elseif getline('.') =~# '^# .*:$' && section ==# 'untracked'
-      return 'Git add -N .'
-    elseif filename ==# ''
-      continue
-    endif
-    if !exists('first_filename')
-      let first_filename = filename
-    endif
-    execute lnum
-    if filename =~ ' -> '
-      let reset += [split(filename,' -> ')[1]]
-    elseif section ==# 'staged'
-      let reset += [filename]
-    elseif getline(lnum) !~# '^#\tdeleted:'
-      let add += [filename]
-    endif
-  endfor
-  try
-    if !empty(add)
-      execute "Git add --patch -- ".join(map(add,'s:shellesc(v:val)'))
-    endif
-    if !empty(reset)
-      execute "Git reset --patch -- ".join(map(reset,'s:shellesc(v:val)'))
-    endif
-    if exists('first_filename')
-      silent! edit!
-      1
-      redraw
-      call search('^#\t\%([[:alpha:] ]\+: *\)\=\V'.first_filename.'\%( ([^()[:digit:]]\+)\)\=\$','W')
-    endif
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-  return 'checktime'
-endfunction
-
-" Section: Gcommit
-
-call s:command("-nargs=? -complete=customlist,s:CommitComplete Gcommit :execute s:Commit(<q-args>)")
-
-function! s:Commit(args, ...) abort
-  let repo = a:0 ? a:1 : s:repo()
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let dir = getcwd()
-  let msgfile = repo.dir('COMMIT_EDITMSG')
-  let outfile = tempname()
-  let errorfile = tempname()
-  try
-    try
-      execute cd s:fnameescape(repo.tree())
-      if s:winshell()
-        let command = ''
-        let old_editor = $GIT_EDITOR
-        let $GIT_EDITOR = 'false'
-      else
-        let command = 'env GIT_EDITOR=false '
-      endif
-      let command .= repo.git_command('commit').' '.a:args
-      if &shell =~# 'csh'
-        noautocmd silent execute '!('.command.' > '.outfile.') >& '.errorfile
-      elseif a:args =~# '\%(^\| \)-\%(-interactive\|p\|-patch\)\>'
-        noautocmd execute '!'.command.' 2> '.errorfile
-      else
-        noautocmd silent execute '!'.command.' > '.outfile.' 2> '.errorfile
-      endif
-      let error = v:shell_error
-    finally
-      execute cd s:fnameescape(dir)
-    endtry
-    if !has('gui_running')
-      redraw!
-    endif
-    if !error
-      if filereadable(outfile)
-        for line in readfile(outfile)
-          echo line
-        endfor
-      endif
-      return ''
-    else
-      let errors = readfile(errorfile)
-      let error = get(errors,-2,get(errors,-1,'!'))
-      if error =~# 'false''\=\.$'
-        let args = a:args
-        let args = s:gsub(args,'%(%(^| )-- )@<!%(^| )@<=%(-[esp]|--edit|--interactive|--patch|--signoff)%($| )','')
-        let args = s:gsub(args,'%(%(^| )-- )@<!%(^| )@<=%(-c|--reedit-message|--reuse-message|-F|--file|-m|--message)%(\s+|\=)%(''[^'']*''|"%(\\.|[^"])*"|\\.|\S)*','')
-        let args = s:gsub(args,'%(^| )@<=[%#]%(:\w)*','\=expand(submatch(0))')
-        let args = s:sub(args, '\ze -- |$', ' --no-edit --no-interactive --no-signoff')
-        let args = '-F '.s:shellesc(msgfile).' '.args
-        if args !~# '\%(^\| \)--cleanup\>'
-          let args = '--cleanup=strip '.args
-        endif
-        if bufname('%') == '' && line('$') == 1 && getline(1) == '' && !&mod
-          execute 'keepalt edit '.s:fnameescape(msgfile)
-        elseif a:args =~# '\%(^\| \)-\%(-verbose\|\w*v\)\>'
-          execute 'keepalt -tabedit '.s:fnameescape(msgfile)
-        elseif s:buffer().type() ==# 'index'
-          execute 'keepalt edit '.s:fnameescape(msgfile)
-          execute (search('^#','n')+1).'wincmd+'
-          setlocal nopreviewwindow
-        else
-          execute 'keepalt split '.s:fnameescape(msgfile)
-        endif
-        let b:fugitive_commit_arguments = args
-        setlocal bufhidden=wipe filetype=gitcommit
-        return '1'
-      elseif error ==# '!'
-        return s:Status()
-      else
-        call s:throw(empty(error)?join(errors, ' '):error)
-      endif
-    endif
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  finally
-    if exists('old_editor')
-      let $GIT_EDITOR = old_editor
-    endif
-    call delete(outfile)
-    call delete(errorfile)
-    call fugitive#reload_status()
-  endtry
-endfunction
-
-function! s:CommitComplete(A,L,P) abort
-  if a:A =~ '^-' || type(a:A) == type(0) " a:A is 0 on :Gcommit -<Tab>
-    let args = ['-C', '-F', '-a', '-c', '-e', '-i', '-m', '-n', '-o', '-q', '-s', '-t', '-u', '-v', '--all', '--allow-empty', '--amend', '--author=', '--cleanup=', '--dry-run', '--edit', '--file=', '--fixup=', '--include', '--interactive', '--message=', '--no-verify', '--only', '--quiet', '--reedit-message=', '--reuse-message=', '--signoff', '--squash=', '--template=', '--untracked-files', '--verbose']
-    return filter(args,'v:val[0 : strlen(a:A)-1] ==# a:A')
-  else
-    return s:repo().superglob(a:A)
-  endif
-endfunction
-
-function! s:FinishCommit() abort
-  let args = getbufvar(+expand('<abuf>'),'fugitive_commit_arguments')
-  if !empty(args)
-    call setbufvar(+expand('<abuf>'),'fugitive_commit_arguments','')
-    return s:Commit(args, s:repo(getbufvar(+expand('<abuf>'),'git_dir')))
-  endif
-  return ''
-endfunction
-
-" Section: Gmerge, Gpull
-
-call s:command("-nargs=? -bang -complete=custom,s:RevisionComplete Gmerge " .
-      \ "execute s:Merge('merge', <bang>0, <q-args>)")
-call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gpull " .
-      \ "execute s:Merge('pull --progress', <bang>0, <q-args>)")
-
-function! s:RevisionComplete(A, L, P) abort
-  return s:repo().git_chomp('rev-parse', '--symbolic', '--branches', '--tags', '--remotes')
-        \ . "\nHEAD\nFETCH_HEAD\nORIG_HEAD"
-endfunction
-
-function! s:RemoteComplete(A, L, P) abort
-  let remote = matchstr(a:L, ' \zs\S\+\ze ')
-  if !empty(remote)
-    let matches = split(s:repo().git_chomp('ls-remote', remote), "\n")
-    call filter(matches, 'v:val =~# "\t" && v:val !~# "{"')
-    call map(matches, 's:sub(v:val, "^.*\t%(refs/%(heads/|tags/)=)=", "")')
-  else
-    let matches = split(s:repo().git_chomp('remote'), "\n")
-  endif
-  return join(matches, "\n")
-endfunction
-
-function! fugitive#cwindow() abort
-  if &buftype == 'quickfix'
-    cwindow
-  else
-    botright cwindow
-    if &buftype == 'quickfix'
-      wincmd p
-    endif
-  endif
-endfunction
-
-let s:common_efm = ''
-      \ . '%+Egit:%.%#,'
-      \ . '%+Eusage:%.%#,'
-      \ . '%+Eerror:%.%#,'
-      \ . '%+Efatal:%.%#,'
-      \ . '%-G%.%#%\e[K%.%#,'
-      \ . '%-G%.%#%\r%.%\+'
-
-function! s:Merge(cmd, bang, args) abort
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let cwd = getcwd()
-  let [mp, efm] = [&l:mp, &l:efm]
-  let had_merge_msg = filereadable(s:repo().dir('MERGE_MSG'))
-  try
-    let &l:errorformat = ''
-          \ . '%-Gerror:%.%#false''.,'
-          \ . '%-G%.%# ''git commit'' %.%#,'
-          \ . '%+Emerge:%.%#,'
-          \ . s:common_efm . ','
-          \ . '%+ECannot %.%#: You have unstaged changes.,'
-          \ . '%+ECannot %.%#: Your index contains uncommitted changes.,'
-          \ . '%+EThere is no tracking information for the current branch.,'
-          \ . '%+EYou are not currently on a branch. Please specify which,'
-          \ . 'CONFLICT (%m): %f deleted in %.%#,'
-          \ . 'CONFLICT (%m): Merge conflict in %f,'
-          \ . 'CONFLICT (%m): Rename \"%f\"->%.%#,'
-          \ . 'CONFLICT (%m): Rename %.%#->%f %.%#,'
-          \ . 'CONFLICT (%m): There is a directory with name %f in %.%#,'
-          \ . '%+ECONFLICT %.%#,'
-          \ . '%+EKONFLIKT %.%#,'
-          \ . '%+ECONFLIT %.%#,'
-          \ . "%+EXUNG \u0110\u1ed8T %.%#,"
-          \ . "%+E\u51b2\u7a81 %.%#,"
-          \ . 'U%\t%f'
-    if a:cmd =~# '^merge' && empty(a:args) &&
-          \ (had_merge_msg || isdirectory(s:repo().dir('rebase-apply')) ||
-          \  !empty(s:repo().git_chomp('diff-files', '--diff-filter=U')))
-      let &l:makeprg = g:fugitive_git_executable.' diff-files --name-status --diff-filter=U'
-    else
-      let &l:makeprg = s:sub(s:git_command() . ' ' . a:cmd .
-            \ (a:args =~# ' \%(--no-edit\|--abort\|-m\)\>' ? '' : ' --edit') .
-            \ ' ' . a:args, ' *$', '')
-    endif
-    if !empty($GIT_EDITOR) || has('win32')
-      let old_editor = $GIT_EDITOR
-      let $GIT_EDITOR = 'false'
-    else
-      let &l:makeprg = 'env GIT_EDITOR=false ' . &l:makeprg
-    endif
-    execute cd fnameescape(s:repo().tree())
-    silent noautocmd make!
-  catch /^Vim\%((\a\+)\)\=:E211/
-    let err = v:exception
-  finally
-    redraw!
-    let [&l:mp, &l:efm] = [mp, efm]
-    if exists('old_editor')
-      let $GIT_EDITOR = old_editor
-    endif
-    execute cd fnameescape(cwd)
-  endtry
-  call fugitive#reload_status()
-  if empty(filter(getqflist(),'v:val.valid'))
-    if !had_merge_msg && filereadable(s:repo().dir('MERGE_MSG'))
-      cclose
-      return 'Gcommit --no-status -n -t '.s:shellesc(s:repo().dir('MERGE_MSG'))
-    endif
-  endif
-  let qflist = getqflist()
-  let found = 0
-  for e in qflist
-    if !empty(e.bufnr)
-      let found = 1
-      let e.pattern = '^<<<<<<<'
-    endif
-  endfor
-  call fugitive#cwindow()
-  if found
-    call setqflist(qflist, 'r')
-    if !a:bang
-      return 'cfirst'
-    endif
-  endif
-  return exists('err') ? 'echoerr '.string(err) : ''
-endfunction
-
-" Section: Ggrep, Glog
-
-if !exists('g:fugitive_summary_format')
-  let g:fugitive_summary_format = '%s'
-endif
-
-call s:command("-bang -nargs=? -complete=customlist,s:EditComplete Ggrep :execute s:Grep('grep',<bang>0,<q-args>)")
-call s:command("-bang -nargs=? -complete=customlist,s:EditComplete Glgrep :execute s:Grep('lgrep',<bang>0,<q-args>)")
-call s:command("-bar -bang -nargs=* -range=0 -complete=customlist,s:EditComplete Glog :call s:Log('grep<bang>',<line1>,<count>,<f-args>)")
-call s:command("-bar -bang -nargs=* -range=0 -complete=customlist,s:EditComplete Gllog :call s:Log('lgrep<bang>',<line1>,<count>,<f-args>)")
-
-function! s:Grep(cmd,bang,arg) abort
-  let grepprg = &grepprg
-  let grepformat = &grepformat
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let dir = getcwd()
-  try
-    execute cd s:fnameescape(s:repo().tree())
-    let &grepprg = s:repo().git_command('--no-pager', 'grep', '-n', '--no-color')
-    let &grepformat = '%f:%l:%m,%m %f match%ts,%f'
-    exe a:cmd.'! '.escape(matchstr(a:arg,'\v\C.{-}%($|[''" ]\@=\|)@='),'|')
-    let list = a:cmd =~# '^l' ? getloclist(0) : getqflist()
-    for entry in list
-      if bufname(entry.bufnr) =~ ':'
-        let entry.filename = s:repo().translate(bufname(entry.bufnr))
-        unlet! entry.bufnr
-        let changed = 1
-      elseif a:arg =~# '\%(^\| \)--cached\>'
-        let entry.filename = s:repo().translate(':0:'.bufname(entry.bufnr))
-        unlet! entry.bufnr
-        let changed = 1
-      endif
-    endfor
-    if a:cmd =~# '^l' && exists('changed')
-      call setloclist(0, list, 'r')
-    elseif exists('changed')
-      call setqflist(list, 'r')
-    endif
-    if !a:bang && !empty(list)
-      return (a:cmd =~# '^l' ? 'l' : 'c').'first'.matchstr(a:arg,'\v\C[''" ]\zs\|.*')
-    else
-      return matchstr(a:arg,'\v\C[''" ]\|\zs.*')
-    endif
-  finally
-    let &grepprg = grepprg
-    let &grepformat = grepformat
-    execute cd s:fnameescape(dir)
-  endtry
-endfunction
-
-function! s:Log(cmd, line1, line2, ...) abort
-  let path = s:buffer().path('/')
-  if path =~# '^/\.git\%(/\|$\)' || index(a:000,'--') != -1
-    let path = ''
-  endif
-  let cmd = ['--no-pager', 'log', '--no-color']
-  let cmd += ['--pretty=format:fugitive://'.s:repo().dir().'//%H'.path.'::'.g:fugitive_summary_format]
-  if empty(filter(a:000[0 : index(a:000,'--')],'v:val !~# "^-"'))
-    if s:buffer().commit() =~# '\x\{40\}'
-      let cmd += [s:buffer().commit()]
-    elseif s:buffer().path() =~# '^\.git/refs/\|^\.git/.*HEAD$'
-      let cmd += [s:buffer().path()[5:-1]]
-    endif
-  end
-  let cmd += map(copy(a:000),'s:sub(v:val,"^\\%(%(:\\w)*)","\\=fnamemodify(s:buffer().path(),submatch(1))")')
-  if path =~# '/.'
-    if a:line2
-      let cmd += ['-L', a:line1 . ',' . a:line2 . ':' . path[1:-1]]
-    else
-      let cmd += ['--', path[1:-1]]
-    endif
-  endif
-  let grepformat = &grepformat
-  let grepprg = &grepprg
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let dir = getcwd()
-  try
-    execute cd s:fnameescape(s:repo().tree())
-    let &grepprg = escape(call(s:repo().git_command,cmd,s:repo()),'%#')
-    let &grepformat = '%Cdiff %.%#,%C--- %.%#,%C+++ %.%#,%Z@@ -%\d%\+\,%\d%\+ +%l\,%\d%\+ @@,%-G-%.%#,%-G+%.%#,%-G %.%#,%A%f::%m,%-G%.%#'
-    exe a:cmd
-  finally
-    let &grepformat = grepformat
-    let &grepprg = grepprg
-    execute cd s:fnameescape(dir)
-  endtry
-endfunction
-
-" Section: Gedit, Gpedit, Gsplit, Gvsplit, Gtabedit, Gread
-
-function! s:Edit(cmd,bang,...) abort
-  let buffer = s:buffer()
-  if a:cmd !~# 'read'
-    if &previewwindow && getbufvar('','fugitive_type') ==# 'index'
-      if winnr('$') == 1
-        let tabs = (&go =~# 'e' || !has('gui_running')) && &stal && (tabpagenr('$') >= &stal)
-        execute 'rightbelow' (&lines - &previewheight - &cmdheight - tabs - 1 - !!&laststatus).'new'
-      elseif winnr('#')
-        wincmd p
-      else
-        wincmd w
-      endif
-      if &diff
-        let mywinnr = winnr()
-        for winnr in range(winnr('$'),1,-1)
-          if winnr != mywinnr && getwinvar(winnr,'&diff')
-            execute winnr.'wincmd w'
-            close
-            if winnr('$') > 1
-              wincmd p
-            endif
-          endif
-        endfor
-        diffoff!
-      endif
-    endif
-  endif
-
-  if a:bang
-    let arglist = map(copy(a:000), 's:gsub(v:val, ''\\@<!%(\\\\)*\zs[%#]'', ''\=s:buffer().expand(submatch(0))'')')
-    let args = join(arglist, ' ')
-    if a:cmd =~# 'read'
-      let git = buffer.repo().git_command()
-      let last = line('$')
-      silent call s:ExecuteInTree((a:cmd ==# 'read' ? '$read' : a:cmd).'!'.git.' --no-pager '.args)
-      if a:cmd ==# 'read'
-        silent execute '1,'.last.'delete_'
-      endif
-      call fugitive#reload_status()
-      diffupdate
-      return 'redraw|echo '.string(':!'.git.' '.args)
-    else
-      let temp = resolve(tempname())
-      if has('win32')
-        let temp = fnamemodify(fnamemodify(temp, ':h'), ':p').fnamemodify(temp, ':t')
-      endif
-      let s:temp_files[s:cpath(temp)] = { 'dir': buffer.repo().dir(), 'args': arglist }
-      silent execute a:cmd.' '.temp
-      if a:cmd =~# 'pedit'
-        wincmd P
-      endif
-      let echo = s:Edit('read',1,args)
-      silent write!
-      setlocal buftype=nowrite nomodified filetype=git foldmarker=<<<<<<<,>>>>>>>
-      if getline(1) !~# '^diff '
-        setlocal readonly nomodifiable
-      endif
-      if a:cmd =~# 'pedit'
-        wincmd p
-      endif
-      return echo
-    endif
-    return ''
-  endif
-
-  if a:0 && a:1 == ''
-    return ''
-  elseif a:0
-    let file = buffer.expand(join(a:000, ' '))
-  elseif expand('%') ==# ''
-    let file = ':'
-  elseif buffer.commit() ==# '' && buffer.path('/') !~# '^/.git\>'
-    let file = buffer.path(':')
-  else
-    let file = buffer.path('/')
-  endif
-  try
-    let file = buffer.repo().translate(file)
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-  if file !~# '^fugitive:'
-    let file = s:sub(file, '/$', '')
-  endif
-  if a:cmd ==# 'read'
-    return 'silent %delete_|read '.s:fnameescape(file).'|silent 1delete_|diffupdate|'.line('.')
-  else
-    return a:cmd.' '.s:fnameescape(file)
-  endif
-endfunction
-
-function! s:EditComplete(A,L,P) abort
-  return map(s:repo().superglob(a:A), 'fnameescape(v:val)')
-endfunction
-
-function! s:EditRunComplete(A,L,P) abort
-  if a:L =~# '^\w\+!'
-    return s:GitComplete(a:A,a:L,a:P)
-  else
-    return s:repo().superglob(a:A)
-  endif
-endfunction
-
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Ge       :execute s:Edit('edit<bang>',0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gedit    :execute s:Edit('edit<bang>',0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gpedit   :execute s:Edit('pedit',<bang>0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gsplit   :execute s:Edit('split',<bang>0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gvsplit  :execute s:Edit('vsplit',<bang>0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gtabedit :execute s:Edit('tabedit',<bang>0,<f-args>)")
-call s:command("-bar -bang -nargs=* -range=-1 -complete=customlist,s:EditRunComplete Gread :execute s:Edit((<count> == -1 ? '' : <count>).'read',<bang>0,<f-args>)")
-
-" Section: Gwrite, Gwq
-
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gwrite :execute s:Write(<bang>0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gw :execute s:Write(<bang>0,<f-args>)")
-call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gwq :execute s:Wq(<bang>0,<f-args>)")
-
-function! s:Write(force,...) abort
-  if exists('b:fugitive_commit_arguments')
-    return 'write|bdelete'
-  elseif expand('%:t') == 'COMMIT_EDITMSG' && $GIT_INDEX_FILE != ''
-    return 'wq'
-  elseif s:buffer().type() == 'index'
-    return 'Gcommit'
-  elseif s:buffer().path() ==# '' && getline(4) =~# '^+++ '
-    let filename = getline(4)[6:-1]
-    setlocal buftype=
-    silent write
-    setlocal buftype=nowrite
-    if matchstr(getline(2),'index [[:xdigit:]]\+\.\.\zs[[:xdigit:]]\{7\}') ==# s:repo().rev_parse(':0:'.filename)[0:6]
-      let err = s:repo().git_chomp('apply','--cached','--reverse',s:buffer().spec())
-    else
-      let err = s:repo().git_chomp('apply','--cached',s:buffer().spec())
-    endif
-    if err !=# ''
-      let v:errmsg = split(err,"\n")[0]
-      return 'echoerr v:errmsg'
-    elseif a:force
-      return 'bdelete'
-    else
-      return 'Gedit '.fnameescape(filename)
-    endif
-  endif
-  let mytab = tabpagenr()
-  let mybufnr = bufnr('')
-  let path = a:0 ? join(a:000, ' ') : s:buffer().path()
-  if empty(path)
-    return 'echoerr '.string('fugitive: cannot determine file path')
-  endif
-  if path =~# '^:\d\>'
-    return 'write'.(a:force ? '! ' : ' ').s:fnameescape(s:repo().translate(s:buffer().expand(path)))
-  endif
-  let always_permitted = (s:buffer().path() ==# path && s:buffer().commit() =~# '^0\=$')
-  if !always_permitted && !a:force && s:repo().git_chomp_in_tree('diff','--name-status','HEAD','--',path) . s:repo().git_chomp_in_tree('ls-files','--others','--',path) !=# ''
-    let v:errmsg = 'fugitive: file has uncommitted changes (use ! to override)'
-    return 'echoerr v:errmsg'
-  endif
-  let file = s:repo().translate(path)
-  let treebufnr = 0
-  for nr in range(1,bufnr('$'))
-    if fnamemodify(bufname(nr),':p') ==# file
-      let treebufnr = nr
-    endif
-  endfor
-
-  if treebufnr > 0 && treebufnr != bufnr('')
-    let temp = tempname()
-    silent execute '%write '.temp
-    for tab in [mytab] + range(1,tabpagenr('$'))
-      for winnr in range(1,tabpagewinnr(tab,'$'))
-        if tabpagebuflist(tab)[winnr-1] == treebufnr
-          execute 'tabnext '.tab
-          if winnr != winnr()
-            execute winnr.'wincmd w'
-            let restorewinnr = 1
-          endif
-          try
-            let lnum = line('.')
-            let last = line('$')
-            silent execute '$read '.temp
-            silent execute '1,'.last.'delete_'
-            silent write!
-            silent execute lnum
-            let did = 1
-          finally
-            if exists('restorewinnr')
-              wincmd p
-            endif
-            execute 'tabnext '.mytab
-          endtry
-        endif
-      endfor
-    endfor
-    if !exists('did')
-      call writefile(readfile(temp,'b'),file,'b')
-    endif
-  else
-    execute 'write! '.s:fnameescape(s:repo().translate(path))
-  endif
-
-  if a:force
-    let error = s:repo().git_chomp_in_tree('add', '--force', '--', path)
-  else
-    let error = s:repo().git_chomp_in_tree('add', '--', path)
-  endif
-  if v:shell_error
-    let v:errmsg = 'fugitive: '.error
-    return 'echoerr v:errmsg'
-  endif
-  if s:buffer().path() ==# path && s:buffer().commit() =~# '^\d$'
-    set nomodified
-  endif
-
-  let one = s:repo().translate(':1:'.path)
-  let two = s:repo().translate(':2:'.path)
-  let three = s:repo().translate(':3:'.path)
-  for nr in range(1,bufnr('$'))
-    let name = fnamemodify(bufname(nr), ':p')
-    if bufloaded(nr) && !getbufvar(nr,'&modified') && (name ==# one || name ==# two || name ==# three)
-      execute nr.'bdelete'
-    endif
-  endfor
-
-  unlet! restorewinnr
-  let zero = s:repo().translate(':0:'.path)
-  silent execute 'doautocmd BufWritePost' s:fnameescape(zero)
-  for tab in range(1,tabpagenr('$'))
-    for winnr in range(1,tabpagewinnr(tab,'$'))
-      let bufnr = tabpagebuflist(tab)[winnr-1]
-      let bufname = fnamemodify(bufname(bufnr), ':p')
-      if bufname ==# zero && bufnr != mybufnr
-        execute 'tabnext '.tab
-        if winnr != winnr()
-          execute winnr.'wincmd w'
-          let restorewinnr = 1
-        endif
-        try
-          let lnum = line('.')
-          let last = line('$')
-          silent execute '$read '.s:fnameescape(file)
-          silent execute '1,'.last.'delete_'
-          silent execute lnum
-          set nomodified
-          diffupdate
-        finally
-          if exists('restorewinnr')
-            wincmd p
-          endif
-          execute 'tabnext '.mytab
-        endtry
-        break
-      endif
-    endfor
-  endfor
-  call fugitive#reload_status()
-  return 'checktime'
-endfunction
-
-function! s:Wq(force,...) abort
-  let bang = a:force ? '!' : ''
-  if exists('b:fugitive_commit_arguments')
-    return 'wq'.bang
-  endif
-  let result = call(s:function('s:Write'),[a:force]+a:000)
-  if result =~# '^\%(write\|wq\|echoerr\)'
-    return s:sub(result,'^write','wq')
-  else
-    return result.'|quit'.bang
-  endif
-endfunction
-
-augroup fugitive_commit
-  autocmd!
-  autocmd VimLeavePre,BufDelete COMMIT_EDITMSG execute s:sub(s:FinishCommit(), '^echoerr (.*)', 'echohl ErrorMsg|echo \1|echohl NONE')
-augroup END
-
-" Section: Gpush, Gfetch
-
-call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gpush  execute s:Dispatch('<bang>', 'push '.<q-args>)")
-call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gfetch execute s:Dispatch('<bang>', 'fetch '.<q-args>)")
-
-function! s:Dispatch(bang, args)
-  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-  let cwd = getcwd()
-  let [mp, efm, cc] = [&l:mp, &l:efm, get(b:, 'current_compiler', '')]
-  try
-    let b:current_compiler = 'git'
-    let &l:errorformat = s:common_efm
-    let &l:makeprg = substitute(s:git_command() . ' ' . a:args, '\s\+$', '', '')
-    execute cd fnameescape(s:repo().tree())
-    if exists(':Make') == 2
-      noautocmd Make
-    else
-      silent noautocmd make!
-      redraw!
-      return 'call fugitive#cwindow()'
-    endif
-    return ''
-  finally
-    let [&l:mp, &l:efm, b:current_compiler] = [mp, efm, cc]
-    if empty(cc) | unlet! b:current_compiler | endif
-    execute cd fnameescape(cwd)
-  endtry
-endfunction
-
-" Section: Gdiff
-
-call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gdiff :execute s:Diff('',<bang>0,<f-args>)")
-call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gvdiff :execute s:Diff('keepalt vert ',<bang>0,<f-args>)")
-call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gsdiff :execute s:Diff('keepalt ',<bang>0,<f-args>)")
-
-augroup fugitive_diff
-  autocmd!
-  autocmd BufWinLeave *
-        \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 2 |
-        \   call s:diffoff_all(getbufvar(+expand('<abuf>'), 'git_dir')) |
-        \ endif
-  autocmd BufWinEnter *
-        \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 1 |
-        \   call s:diffoff() |
-        \ endif
-augroup END
-
-function! s:can_diffoff(buf) abort
-  return getwinvar(bufwinnr(a:buf), '&diff') &&
-        \ !empty(getbufvar(a:buf, 'git_dir')) &&
-        \ !empty(getwinvar(bufwinnr(a:buf), 'fugitive_diff_restore'))
-endfunction
-
-function! fugitive#can_diffoff(buf) abort
-  return s:can_diffoff(a:buf)
-endfunction
-
-function! s:diff_modifier(count) abort
-  let fdc = matchstr(&diffopt, 'foldcolumn:\zs\d\+')
-  if &diffopt =~# 'horizontal' && &diffopt !~# 'vertical'
-    return 'keepalt '
-  elseif &diffopt =~# 'vertical'
-    return 'keepalt vert '
-  elseif winwidth(0) <= a:count * ((&tw ? &tw : 80) + (empty(fdc) ? 2 : fdc))
-    return 'keepalt '
-  else
-    return 'keepalt vert '
-  endif
-endfunction
-
-function! s:diff_window_count() abort
-  let c = 0
-  for nr in range(1,winnr('$'))
-    let c += getwinvar(nr,'&diff')
-  endfor
-  return c
-endfunction
-
-function! s:diff_restore() abort
-  let restore = 'setlocal nodiff noscrollbind'
-        \ . ' scrollopt=' . &l:scrollopt
-        \ . (&l:wrap ? ' wrap' : ' nowrap')
-        \ . ' foldlevel=999'
-        \ . ' foldmethod=' . &l:foldmethod
-        \ . ' foldcolumn=' . &l:foldcolumn
-        \ . ' foldlevel=' . &l:foldlevel
-        \ . (&l:foldenable ? ' foldenable' : ' nofoldenable')
-  if has('cursorbind')
-    let restore .= (&l:cursorbind ? ' ' : ' no') . 'cursorbind'
-  endif
-  return restore
-endfunction
-
-function! s:diffthis() abort
-  if !&diff
-    let w:fugitive_diff_restore = s:diff_restore()
-    diffthis
-  endif
-endfunction
-
-function! s:diffoff() abort
-  if exists('w:fugitive_diff_restore')
-    execute w:fugitive_diff_restore
-    unlet w:fugitive_diff_restore
-  else
-    diffoff
-  endif
-endfunction
-
-function! s:diffoff_all(dir) abort
-  let curwin = winnr()
-  for nr in range(1,winnr('$'))
-    if getwinvar(nr,'&diff')
-      if nr != winnr()
-        execute nr.'wincmd w'
-        let restorewinnr = 1
-      endif
-      if exists('b:git_dir') && b:git_dir ==# a:dir
-        call s:diffoff()
-      endif
-    endif
-  endfor
-  execute curwin.'wincmd w'
-endfunction
-
-function! s:buffer_compare_age(commit) dict abort
-  let scores = {':0': 1, ':1': 2, ':2': 3, ':': 4, ':3': 5}
-  let my_score    = get(scores,':'.self.commit(),0)
-  let their_score = get(scores,':'.a:commit,0)
-  if my_score || their_score
-    return my_score < their_score ? -1 : my_score != their_score
-  elseif self.commit() ==# a:commit
-    return 0
-  endif
-  let base = self.repo().git_chomp('merge-base',self.commit(),a:commit)
-  if base ==# self.commit()
-    return -1
-  elseif base ==# a:commit
-    return 1
-  endif
-  let my_time    = +self.repo().git_chomp('log','--max-count=1','--pretty=format:%at',self.commit())
-  let their_time = +self.repo().git_chomp('log','--max-count=1','--pretty=format:%at',a:commit)
-  return my_time < their_time ? -1 : my_time != their_time
-endfunction
-
-call s:add_methods('buffer',['compare_age'])
-
-function! s:Diff(vert,keepfocus,...) abort
-  let args = copy(a:000)
-  let post = ''
-  if get(args, 0) =~# '^+'
-    let post = remove(args, 0)[1:-1]
-  endif
-  let vert = empty(a:vert) ? s:diff_modifier(2) : a:vert
-  if exists(':DiffGitCached')
-    return 'DiffGitCached'
-  elseif (empty(args) || args[0] == ':') && s:buffer().commit() =~# '^[0-1]\=$' && s:repo().git_chomp_in_tree('ls-files', '--unmerged', '--', s:buffer().path()) !=# ''
-    let vert = empty(a:vert) ? s:diff_modifier(3) : a:vert
-    let nr = bufnr('')
-    execute 'leftabove '.vert.'split' s:fnameescape(fugitive#repo().translate(s:buffer().expand(':2')))
-    execute 'nnoremap <buffer> <silent> dp :diffput '.nr.'<Bar>diffupdate<CR>'
-    let nr2 = bufnr('')
-    call s:diffthis()
-    wincmd p
-    execute 'rightbelow '.vert.'split' s:fnameescape(fugitive#repo().translate(s:buffer().expand(':3')))
-    execute 'nnoremap <buffer> <silent> dp :diffput '.nr.'<Bar>diffupdate<CR>'
-    let nr3 = bufnr('')
-    call s:diffthis()
-    wincmd p
-    call s:diffthis()
-    execute 'nnoremap <buffer> <silent> d2o :diffget '.nr2.'<Bar>diffupdate<CR>'
-    execute 'nnoremap <buffer> <silent> d3o :diffget '.nr3.'<Bar>diffupdate<CR>'
-    return post
-  elseif len(args)
-    let arg = join(args, ' ')
-    if arg ==# ''
-      return post
-    elseif arg ==# '/'
-      let file = s:buffer().path('/')
-    elseif arg ==# ':'
-      let file = s:buffer().path(':0:')
-    elseif arg =~# '^:/.'
-      try
-        let file = s:repo().rev_parse(arg).s:buffer().path(':')
-      catch /^fugitive:/
-        return 'echoerr v:errmsg'
-      endtry
-    else
-      let file = s:buffer().expand(arg)
-    endif
-    if file !~# ':' && file !~# '^/' && s:repo().git_chomp('cat-file','-t',file) =~# '^\%(tag\|commit\)$'
-      let file = file.s:buffer().path(':')
-    endif
-  else
-    let file = s:buffer().path(s:buffer().commit() == '' ? ':0:' : '/')
-  endif
-  try
-    let spec = s:repo().translate(file)
-    let commit = matchstr(spec,'\C[^:/]//\zs\x\+')
-    let restore = s:diff_restore()
-    if exists('+cursorbind')
-      setlocal cursorbind
-    endif
-    let w:fugitive_diff_restore = restore
-    if s:buffer().compare_age(commit) < 0
-      execute 'rightbelow '.vert.'diffsplit '.s:fnameescape(spec)
-    else
-      execute 'leftabove '.vert.'diffsplit '.s:fnameescape(spec)
-    endif
-    let &l:readonly = &l:readonly
-    redraw
-    let w:fugitive_diff_restore = restore
-    let winnr = winnr()
-    if getwinvar('#', '&diff')
-      wincmd p
-      if !a:keepfocus
-        call feedkeys(winnr."\<C-W>w", 'n')
-      endif
-    endif
-    return post
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-" Section: Gmove, Gremove
-
-function! s:Move(force,destination) abort
-  if a:destination =~# '^/'
-    let destination = a:destination[1:-1]
-  else
-    let destination = s:shellslash(fnamemodify(s:sub(a:destination,'[%#]%(:\w)*','\=expand(submatch(0))'),':p'))
-    if destination[0:strlen(s:repo().tree())] ==# s:repo().tree('')
-      let destination = destination[strlen(s:repo().tree('')):-1]
-    endif
-  endif
-  if isdirectory(s:buffer().spec())
-    " Work around Vim parser idiosyncrasy
-    let discarded = s:buffer().setvar('&swapfile',0)
-  endif
-  let message = call(s:repo().git_chomp_in_tree,['mv']+(a:force ? ['-f'] : [])+['--', s:buffer().path(), destination], s:repo())
-  if v:shell_error
-    let v:errmsg = 'fugitive: '.message
-    return 'echoerr v:errmsg'
-  endif
-  let destination = s:repo().tree(destination)
-  if isdirectory(destination)
-    let destination = fnamemodify(s:sub(destination,'/$','').'/'.expand('%:t'),':.')
-  endif
-  call fugitive#reload_status()
-  if s:buffer().commit() == ''
-    if isdirectory(destination)
-      return 'keepalt edit '.s:fnameescape(destination)
-    else
-      return 'keepalt saveas! '.s:fnameescape(destination)
-    endif
-  else
-    return 'file '.s:fnameescape(s:repo().translate(':0:'.destination))
-  endif
-endfunction
-
-function! s:MoveComplete(A,L,P) abort
-  if a:A =~ '^/'
-    return s:repo().superglob(a:A)
-  else
-    let matches = split(glob(a:A.'*'),"\n")
-    call map(matches,'v:val !~ "/$" && isdirectory(v:val) ? v:val."/" : v:val')
-    return matches
-  endif
-endfunction
-
-function! s:Remove(after, force) abort
-  if s:buffer().commit() ==# ''
-    let cmd = ['rm']
-  elseif s:buffer().commit() ==# '0'
-    let cmd = ['rm','--cached']
-  else
-    let v:errmsg = 'fugitive: rm not supported here'
-    return 'echoerr v:errmsg'
-  endif
-  if a:force
-    let cmd += ['--force']
-  endif
-  let message = call(s:repo().git_chomp_in_tree,cmd+['--',s:buffer().path()],s:repo())
-  if v:shell_error
-    let v:errmsg = 'fugitive: '.s:sub(message,'error:.*\zs\n\(.*-f.*',' (add ! to force)')
-    return 'echoerr '.string(v:errmsg)
-  else
-    call fugitive#reload_status()
-    return a:after . (a:force ? '!' : '')
-  endif
-endfunction
-
-augroup fugitive_remove
-  autocmd!
-  autocmd User Fugitive if s:buffer().commit() =~# '^0\=$' |
-        \ exe "command! -buffer -bar -bang -nargs=1 -complete=customlist,s:MoveComplete Gmove :execute s:Move(<bang>0,<q-args>)" |
-        \ exe "command! -buffer -bar -bang Gremove :execute s:Remove('edit',<bang>0)" |
-        \ exe "command! -buffer -bar -bang Gdelete :execute s:Remove('bdelete',<bang>0)" |
-        \ endif
-augroup END
-
-" Section: Gblame
-
-augroup fugitive_blame
-  autocmd!
-  autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame
-  autocmd FileType fugitiveblame setlocal nomodeline | if exists('b:git_dir') | let &l:keywordprg = s:repo().keywordprg() | endif
-  autocmd Syntax fugitiveblame call s:BlameSyntax()
-  autocmd User Fugitive if s:buffer().type('file', 'blob') | exe "command! -buffer -bar -bang -range=0 -nargs=* Gblame :execute s:Blame(<bang>0,<line1>,<line2>,<count>,[<f-args>])" | endif
-  autocmd ColorScheme,GUIEnter * call s:RehighlightBlame()
-augroup END
-
-function! s:linechars(pattern) abort
-  let chars = strlen(s:gsub(matchstr(getline('.'), a:pattern), '.', '.'))
-  if exists('*synconcealed') && &conceallevel > 1
-    for col in range(1, chars)
-      let chars -= synconcealed(line('.'), col)[0]
-    endfor
-  endif
-  return chars
-endfunction
-
-function! s:Blame(bang,line1,line2,count,args) abort
-  if exists('b:fugitive_blamed_bufnr')
-    return 'bdelete'
-  endif
-  try
-    if s:buffer().path() == ''
-      call s:throw('file or blob required')
-    endif
-    if filter(copy(a:args),'v:val !~# "^\\%(--root\|--show-name\\|-\\=\\%([ltfnsew]\\|[MC]\\d*\\)\\+\\)$"') != []
-      call s:throw('unsupported option')
-    endif
-    call map(a:args,'s:sub(v:val,"^\\ze[^-]","-")')
-    let cmd = ['--no-pager', 'blame', '--show-number'] + a:args
-    if s:buffer().commit() =~# '\D\|..'
-      let cmd += [s:buffer().commit()]
-    else
-      let cmd += ['--contents', '-']
-    endif
-    let cmd += ['--', s:buffer().path()]
-    let basecmd = escape(call(s:repo().git_command,cmd,s:repo()),'!%#')
-    try
-      let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-      if !s:repo().bare()
-        let dir = getcwd()
-        execute cd s:fnameescape(s:repo().tree())
-      endif
-      if a:count
-        execute 'write !'.substitute(basecmd,' blame ',' blame -L '.a:line1.','.a:line2.' ','g')
-      else
-        let error = resolve(tempname())
-        let temp = error.'.fugitiveblame'
-        if &shell =~# 'csh'
-          silent! execute '%write !('.basecmd.' > '.temp.') >& '.error
-        else
-          silent! execute '%write !'.basecmd.' > '.temp.' 2> '.error
-        endif
-        if exists('l:dir')
-          execute cd s:fnameescape(dir)
-          unlet dir
-        endif
-        if v:shell_error
-          call s:throw(join(readfile(error),"\n"))
-        endif
-        for winnr in range(winnr('$'),1,-1)
-          call setwinvar(winnr, '&scrollbind', 0)
-          if exists('+cursorbind')
-            call setwinvar(winnr, '&cursorbind', 0)
-          endif
-          if getbufvar(winbufnr(winnr), 'fugitive_blamed_bufnr')
-            execute winbufnr(winnr).'bdelete'
-          endif
-        endfor
-        let bufnr = bufnr('')
-        let restore = 'call setwinvar(bufwinnr('.bufnr.'),"&scrollbind",0)'
-        if exists('+cursorbind')
-          let restore .= '|call setwinvar(bufwinnr('.bufnr.'),"&cursorbind",0)'
-        endif
-        if &l:wrap
-          let restore .= '|call setwinvar(bufwinnr('.bufnr.'),"&wrap",1)'
-        endif
-        if &l:foldenable
-          let restore .= '|call setwinvar(bufwinnr('.bufnr.'),"&foldenable",1)'
-        endif
-        setlocal scrollbind nowrap nofoldenable
-        if exists('+cursorbind')
-          setlocal cursorbind
-        endif
-        let top = line('w0') + &scrolloff
-        let current = line('.')
-        if has('win32')
-          let temp = fnamemodify(fnamemodify(temp, ':h'), ':p').fnamemodify(temp, ':t')
-        endif
-        let s:temp_files[s:cpath(temp)] = { 'dir': s:repo().dir(), 'args': cmd }
-        exe 'keepalt leftabove vsplit '.temp
-        let b:fugitive_blamed_bufnr = bufnr
-        let w:fugitive_leave = restore
-        let b:fugitive_blame_arguments = join(a:args,' ')
-        execute top
-        normal! zt
-        execute current
-        if exists('+cursorbind')
-          setlocal cursorbind
-        endif
-        setlocal nomodified nomodifiable nonumber scrollbind nowrap foldcolumn=0 nofoldenable winfixwidth filetype=fugitiveblame
-        if exists('+concealcursor')
-          setlocal concealcursor=nc conceallevel=2
-        endif
-        if exists('+relativenumber')
-          setlocal norelativenumber
-        endif
-        execute "vertical resize ".(s:linechars('.\{-\}\ze\s\+\d\+)')+1)
-        nnoremap <buffer> <silent> <F1> :help fugitive-:Gblame<CR>
-        nnoremap <buffer> <silent> g?   :help fugitive-:Gblame<CR>
-        nnoremap <buffer> <silent> q    :exe substitute(bufwinnr(b:fugitive_blamed_bufnr).' wincmd w<Bar>'.bufnr('').'bdelete','^-1','','')<CR>
-        nnoremap <buffer> <silent> gq   :exe substitute(bufwinnr(b:fugitive_blamed_bufnr).' wincmd w<Bar>'.bufnr('').'bdelete<Bar>if expand("%:p") =~# "^fugitive:[\\/][\\/]"<Bar>Gedit<Bar>endif','^-1','','')<CR>
-        nnoremap <buffer> <silent> <CR> :<C-U>exe <SID>BlameCommit("exe 'norm q'<Bar>edit")<CR>
-        nnoremap <buffer> <silent> -    :<C-U>exe <SID>BlameJump('')<CR>
-        nnoremap <buffer> <silent> P    :<C-U>exe <SID>BlameJump('^'.v:count1)<CR>
-        nnoremap <buffer> <silent> ~    :<C-U>exe <SID>BlameJump('~'.v:count1)<CR>
-        nnoremap <buffer> <silent> i    :<C-U>exe <SID>BlameCommit("exe 'norm q'<Bar>edit")<CR>
-        nnoremap <buffer> <silent> o    :<C-U>exe <SID>BlameCommit((&splitbelow ? "botright" : "topleft")." split")<CR>
-        nnoremap <buffer> <silent> O    :<C-U>exe <SID>BlameCommit("tabedit")<CR>
-        nnoremap <buffer> <silent> A    :<C-u>exe "vertical resize ".(<SID>linechars('.\{-\}\ze [0-9:/+-][0-9:/+ -]* \d\+)')+1+v:count)<CR>
-        nnoremap <buffer> <silent> C    :<C-u>exe "vertical resize ".(<SID>linechars('^\S\+')+1+v:count)<CR>
-        nnoremap <buffer> <silent> D    :<C-u>exe "vertical resize ".(<SID>linechars('.\{-\}\ze\d\ze\s\+\d\+)')+1-v:count)<CR>
-        redraw
-        syncbind
-      endif
-    finally
-      if exists('l:dir')
-        execute cd s:fnameescape(dir)
-      endif
-    endtry
-    return ''
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-function! s:BlameCommit(cmd) abort
-  let cmd = s:Edit(a:cmd, 0, matchstr(getline('.'),'\x\+'))
-  if cmd =~# '^echoerr'
-    return cmd
-  endif
-  let lnum = matchstr(getline('.'),' \zs\d\+\ze\s\+[([:digit:]]')
-  let path = matchstr(getline('.'),'^\^\=\x\+\s\+\zs.\{-\}\ze\s*\d\+ ')
-  if path ==# ''
-    let path = s:buffer(b:fugitive_blamed_bufnr).path()
-  endif
-  execute cmd
-  if search('^diff .* b/\M'.escape(path,'\').'$','W')
-    call search('^+++')
-    let head = line('.')
-    while search('^@@ \|^diff ') && getline('.') =~# '^@@ '
-      let top = +matchstr(getline('.'),' +\zs\d\+')
-      let len = +matchstr(getline('.'),' +\d\+,\zs\d\+')
-      if lnum >= top && lnum <= top + len
-        let offset = lnum - top
-        if &scrolloff
-          +
-          normal! zt
-        else
-          normal! zt
-          +
-        endif
-        while offset > 0 && line('.') < line('$')
-          +
-          if getline('.') =~# '^[ +]'
-            let offset -= 1
-          endif
-        endwhile
-        return 'normal! zv'
-      endif
-    endwhile
-    execute head
-    normal! zt
-  endif
-  return ''
-endfunction
-
-function! s:BlameJump(suffix) abort
-  let commit = matchstr(getline('.'),'^\^\=\zs\x\+')
-  if commit =~# '^0\+$'
-    let commit = ':0'
-  endif
-  let lnum = matchstr(getline('.'),' \zs\d\+\ze\s\+[([:digit:]]')
-  let path = matchstr(getline('.'),'^\^\=\x\+\s\+\zs.\{-\}\ze\s*\d\+ ')
-  if path ==# ''
-    let path = s:buffer(b:fugitive_blamed_bufnr).path()
-  endif
-  let args = b:fugitive_blame_arguments
-  let offset = line('.') - line('w0')
-  let bufnr = bufnr('%')
-  let winnr = bufwinnr(b:fugitive_blamed_bufnr)
-  if winnr > 0
-    exe winnr.'wincmd w'
-  endif
-  execute s:Edit('edit', 0, commit.a:suffix.':'.path)
-  execute lnum
-  if winnr > 0
-    exe bufnr.'bdelete'
-  endif
-  if exists(':Gblame')
-    execute 'Gblame '.args
-    execute lnum
-    let delta = line('.') - line('w0') - offset
-    if delta > 0
-      execute 'normal! '.delta."\<C-E>"
-    elseif delta < 0
-      execute 'normal! '.(-delta)."\<C-Y>"
-    endif
-    syncbind
-  endif
-  return ''
-endfunction
-
-let s:hash_colors = {}
-
-function! s:BlameSyntax() abort
-  let b:current_syntax = 'fugitiveblame'
-  let conceal = has('conceal') ? ' conceal' : ''
-  let arg = exists('b:fugitive_blame_arguments') ? b:fugitive_blame_arguments : ''
-  syn match FugitiveblameBoundary "^\^"
-  syn match FugitiveblameBlank                      "^\s\+\s\@=" nextgroup=FugitiveblameAnnotation,fugitiveblameOriginalFile,FugitiveblameOriginalLineNumber skipwhite
-  syn match FugitiveblameHash       "\%(^\^\=\)\@<=\<\x\{7,40\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite
-  syn match FugitiveblameUncommitted "\%(^\^\=\)\@<=\<0\{7,40\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite
-  syn region FugitiveblameAnnotation matchgroup=FugitiveblameDelimiter start="(" end="\%( \d\+\)\@<=)" contained keepend oneline
-  syn match FugitiveblameTime "[0-9:/+-][0-9:/+ -]*[0-9:/+-]\%( \+\d\+)\)\@=" contained containedin=FugitiveblameAnnotation
-  exec 'syn match FugitiveblameLineNumber         " *\d\+)\@=" contained containedin=FugitiveblameAnnotation'.conceal
-  exec 'syn match FugitiveblameOriginalFile       " \%(\f\+\D\@<=\|\D\@=\f\+\)\%(\%(\s\+\d\+\)\=\s\%((\|\s*\d\+)\)\)\@=" contained nextgroup=FugitiveblameOriginalLineNumber,FugitiveblameAnnotation skipwhite'.(arg =~# 'f' ? '' : conceal)
-  exec 'syn match FugitiveblameOriginalLineNumber " *\d\+\%(\s(\)\@=" contained nextgroup=FugitiveblameAnnotation skipwhite'.(arg =~# 'n' ? '' : conceal)
-  exec 'syn match FugitiveblameOriginalLineNumber " *\d\+\%(\s\+\d\+)\)\@=" contained nextgroup=FugitiveblameShort skipwhite'.(arg =~# 'n' ? '' : conceal)
-  syn match FugitiveblameShort              " \d\+)" contained contains=FugitiveblameLineNumber
-  syn match FugitiveblameNotCommittedYet "(\@<=Not Committed Yet\>" contained containedin=FugitiveblameAnnotation
-  hi def link FugitiveblameBoundary           Keyword
-  hi def link FugitiveblameHash               Identifier
-  hi def link FugitiveblameUncommitted        Ignore
-  hi def link FugitiveblameTime               PreProc
-  hi def link FugitiveblameLineNumber         Number
-  hi def link FugitiveblameOriginalFile       String
-  hi def link FugitiveblameOriginalLineNumber Float
-  hi def link FugitiveblameShort              FugitiveblameDelimiter
-  hi def link FugitiveblameDelimiter          Delimiter
-  hi def link FugitiveblameNotCommittedYet    Comment
-  let seen = {}
-  for lnum in range(1, line('$'))
-    let hash = matchstr(getline(lnum), '^\^\=\zs\x\{6\}')
-    if hash ==# '' || hash ==# '000000' || has_key(seen, hash)
-      continue
-    endif
-    let seen[hash] = 1
-    if &t_Co > 16 && get(g:, 'CSApprox_loaded') && !empty(findfile('autoload/csapprox/per_component.vim', escape(&rtp, ' ')))
-          \ && empty(get(s:hash_colors, hash))
-      let [s, r, g, b; __] = map(matchlist(hash, '\(\x\x\)\(\x\x\)\(\x\x\)'), 'str2nr(v:val,16)')
-      let color = csapprox#per_component#Approximate(r, g, b)
-      if color == 16 && &background ==# 'dark'
-        let color = 8
-      endif
-      let s:hash_colors[hash] = ' ctermfg='.color
-    else
-      let s:hash_colors[hash] = ''
-    endif
-    exe 'syn match FugitiveblameHash'.hash.'       "\%(^\^\=\)\@<='.hash.'\x\{1,34\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite'
-  endfor
-  call s:RehighlightBlame()
-endfunction
-
-function! s:RehighlightBlame() abort
-  for [hash, cterm] in items(s:hash_colors)
-    if !empty(cterm) || has('gui_running') || has('termguicolors') && &termguicolors
-      exe 'hi FugitiveblameHash'.hash.' guifg=#'.hash.get(s:hash_colors, hash, '')
-    else
-      exe 'hi link FugitiveblameHash'.hash.' Identifier'
-    endif
-  endfor
-endfunction
-
-" Section: Gbrowse
-
-call s:command("-bar -bang -range=0 -nargs=* -complete=customlist,s:EditComplete Gbrowse :execute s:Browse(<bang>0,<line1>,<count>,<f-args>)")
-
-let s:redirects = {}
-
-function! s:Browse(bang,line1,count,...) abort
-  try
-    let validremote = '\.\|\.\=/.*\|[[:alnum:]_-]\+\%(://.\{-\}\)\='
-    if a:0
-      let remote = matchstr(join(a:000, ' '),'@\zs\%('.validremote.'\)$')
-      let rev = substitute(join(a:000, ' '),'@\%('.validremote.'\)$','','')
-    else
-      let remote = ''
-      let rev = ''
-    endif
-    if rev ==# ''
-      let expanded = s:buffer().rev()
-    elseif rev ==# ':'
-      let expanded = s:buffer().path('/')
-    else
-      let expanded = s:buffer().expand(rev)
-    endif
-    let full = s:repo().translate(expanded)
-    let commit = ''
-    if full =~# '^fugitive://'
-      let commit = matchstr(full,'://.*//\zs\w\w\+')
-      let path = matchstr(full,'://.*//\w\+\zs/.*')
-      if commit =~ '..'
-        let type = s:repo().git_chomp('cat-file','-t',commit.s:sub(path,'^/',':'))
-        let branch = matchstr(expanded, '^[^:]*')
-      else
-        let type = 'blob'
-      endif
-      let path = path[1:-1]
-    elseif s:repo().bare()
-      let path = '.git/' . full[strlen(s:repo().dir())+1:-1]
-      let type = ''
-    else
-      let path = full[strlen(s:repo().tree())+1:-1]
-      if path =~# '^\.git/'
-        let type = ''
-      elseif isdirectory(full)
-        let type = 'tree'
-      else
-        let type = 'blob'
-      endif
-    endif
-    if type ==# 'tree' && !empty(path)
-      let path = s:sub(path, '/\=$', '/')
-    endif
-    if path =~# '^\.git/.*HEAD' && filereadable(s:repo().dir(path[5:-1]))
-      let body = readfile(s:repo().dir(path[5:-1]))[0]
-      if body =~# '^\x\{40\}$'
-        let commit = body
-        let type = 'commit'
-        let path = ''
-      elseif body =~# '^ref: refs/'
-        let path = '.git/' . matchstr(body,'ref: \zs.*')
-      endif
-    endif
-
-    let merge = ''
-    if path =~# '^\.git/refs/remotes/.'
-      if empty(remote)
-        let remote = matchstr(path, '^\.git/refs/remotes/\zs[^/]\+')
-        let branch = matchstr(path, '^\.git/refs/remotes/[^/]\+/\zs.\+')
-      else
-        let merge = matchstr(path, '^\.git/refs/remotes/[^/]\+/\zs.\+')
-        let path = '.git/refs/heads/'.merge
-      endif
-    elseif path =~# '^\.git/refs/heads/.'
-      let branch = path[16:-1]
-    elseif !exists('branch')
-      let branch = s:repo().head()
-    endif
-    if !empty(branch)
-      let r = s:repo().git_chomp('config','branch.'.branch.'.remote')
-      let m = s:repo().git_chomp('config','branch.'.branch.'.merge')[11:-1]
-      if r ==# '.' && !empty(m)
-        let r2 = s:repo().git_chomp('config','branch.'.m.'.remote')
-        if r2 !~# '^\.\=$'
-          let r = r2
-          let m = s:repo().git_chomp('config','branch.'.m.'.merge')[11:-1]
-        endif
-      endif
-      if empty(remote)
-        let remote = r
-      endif
-      if r ==# '.' || r ==# remote
-        let merge = m
-        if path =~# '^\.git/refs/heads/.'
-          let path = '.git/refs/heads/'.merge
-        endif
-      endif
-    endif
-
-    if empty(commit) && path !~# '^\.git/'
-      if a:line1 && !a:count && !empty(merge)
-        let commit = merge
-      else
-        let commit = s:repo().rev_parse('HEAD')
-      endif
-    endif
-
-    if empty(remote)
-      let remote = '.'
-      let remote_for_url = 'origin'
-    else
-      let remote_for_url = remote
-    endif
-    if fugitive#git_version() =~# '^[01]\.\|^2\.[0-6]\.'
-      let raw = s:repo().git_chomp('config','remote.'.remote_for_url.'.url')
-    else
-      let raw = s:repo().git_chomp('remote','get-url',remote_for_url)
-    endif
-    if raw ==# ''
-      let raw = remote
-    endif
-
-    if raw =~# '^https\=://' && s:executable('curl')
-      if !has_key(s:redirects, raw)
-        let s:redirects[raw] = matchstr(system('curl -I ' .
-              \ s:shellesc(raw . '/info/refs?service=git-upload-pack')),
-              \ 'Location: \zs\S\+\ze/info/refs?')
-      endif
-      if len(s:redirects[raw])
-        let raw = s:redirects[raw]
-      endif
-    endif
-
-    for Handler in g:fugitive_browse_handlers
-      let url = call(Handler, [{
-            \ 'repo': s:repo(),
-            \ 'remote': raw,
-            \ 'revision': 'No longer provided',
-            \ 'commit': commit,
-            \ 'path': path,
-            \ 'type': type,
-            \ 'line1': a:count > 0 ? a:line1 : 0,
-            \ 'line2': a:count > 0 ? a:count : 0}])
-      if !empty(url)
-        break
-      endif
-    endfor
-
-    if empty(url) && raw ==# '.'
-      call s:throw("Instaweb failed to start")
-    elseif empty(url)
-      call s:throw("'".remote."' is not a supported remote")
-    endif
-
-    let url = s:gsub(url, '[ <>]', '\="%".printf("%02X",char2nr(submatch(0)))')
-    if a:bang
-      if has('clipboard')
-        let @+ = url
-      endif
-      return 'echomsg '.string(url)
-    elseif exists(':Browse') == 2
-      return 'echomsg '.string(url).'|Browse '.url
-    else
-      if !exists('g:loaded_netrw')
-        runtime! autoload/netrw.vim
-      endif
-      if exists('*netrw#BrowseX')
-        return 'echomsg '.string(url).'|call netrw#BrowseX('.string(url).', 0)'
-      else
-        return 'echomsg '.string(url).'|call netrw#NetrwBrowseX('.string(url).', 0)'
-      endif
-    endif
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-function! s:github_url(opts, ...) abort
-  if a:0 || type(a:opts) != type({})
-    return ''
-  endif
-  let domain_pattern = 'github\.com'
-  let domains = exists('g:fugitive_github_domains') ? g:fugitive_github_domains : []
-  for domain in domains
-    let domain_pattern .= '\|' . escape(split(domain, '://')[-1], '.')
-  endfor
-  let repo = matchstr(get(a:opts, 'remote'), '^\%(https\=://\|git://\|git@\)\=\zs\('.domain_pattern.'\)[/:].\{-\}\ze\%(\.git\)\=$')
-  if repo ==# ''
-    return ''
-  endif
-  call s:warn('Install rhubarb.vim for GitHub support')
-  return 'https://github.com/tpope/vim-rhubarb'
-endfunction
-
-function! s:instaweb_url(opts) abort
-  if a:opts.remote !=# '.'
-    return ''
-  endif
-  let output = a:opts.repo.git_chomp('instaweb','-b','unknown')
-  if output =~# 'http://'
-    let root = matchstr(output,'http://.*').'/?p='.fnamemodify(a:opts.repo.dir(),':t')
-  else
-    return ''
-  endif
-  if a:opts.path =~# '^\.git/refs/.'
-    return root . ';a=shortlog;h=' . matchstr(a:opts.path,'^\.git/\zs.*')
-  elseif a:opts.path =~# '^\.git\>'
-    return root
-  endif
-  let url = root
-  if a:opts.commit =~# '^\x\{40\}$'
-    if a:opts.type ==# 'commit'
-      let url .= ';a=commit'
-    endif
-    let url .= ';h=' . a:opts.repo.rev_parse(a:opts.commit . (a:opts.path == '' ? '' : ':' . a:opts.path))
-  else
-    if a:opts.type ==# 'blob' && empty(a:opts.commit)
-      let url .= ';h='.a:opts.repo.git_chomp('hash-object', '-w', a:opts.path)
-    else
-      try
-        let url .= ';h=' . a:opts.repo.rev_parse((a:opts.commit == '' ? 'HEAD' : ':' . a:opts.commit) . ':' . a:opts.path)
-      catch /^fugitive:/
-        call s:throw('fugitive: cannot browse uncommitted file')
-      endtry
-    endif
-    let root .= ';hb=' . matchstr(a:opts.repo.head_ref(),'[^ ]\+$')
-  endif
-  if a:opts.path !=# ''
-    let url .= ';f=' . a:opts.path
-  endif
-  if get(a:opts, 'line1')
-    let url .= '#l' . a:opts.line1
-  endif
-  return url
-endfunction
-
-if !exists('g:fugitive_browse_handlers')
-  let g:fugitive_browse_handlers = []
-endif
-
-call extend(g:fugitive_browse_handlers,
-      \ [s:function('s:github_url'), s:function('s:instaweb_url')])
-
-" Section: File access
-
-function! s:ReplaceCmd(cmd,...) abort
-  let fn = expand('%:p')
-  let tmp = tempname()
-  let prefix = ''
-  try
-    if a:0 && a:1 != ''
-      if s:winshell()
-        let old_index = $GIT_INDEX_FILE
-        let $GIT_INDEX_FILE = a:1
-      else
-        let prefix = 'env GIT_INDEX_FILE='.s:shellesc(a:1).' '
-      endif
-    endif
-    let redir = ' > '.tmp
-    if &shellpipe =~ '2>&1'
-      let redir .= ' 2>&1'
-    endif
-    if s:winshell()
-      let cmd_escape_char = &shellxquote == '(' ?  '^' : '^^^'
-      call system('cmd /c "'.prefix.s:gsub(a:cmd,'[<>]', cmd_escape_char.'&').redir.'"')
-    elseif &shell =~# 'fish'
-      call system(' begin;'.prefix.a:cmd.redir.';end ')
-    else
-      call system(' ('.prefix.a:cmd.redir.') ')
-    endif
-  finally
-    if exists('old_index')
-      let $GIT_INDEX_FILE = old_index
-    endif
-  endtry
-  silent exe 'keepalt file '.tmp
-  try
-    silent edit!
-  finally
-    try
-      silent exe 'keepalt file '.s:fnameescape(fn)
-    catch /^Vim\%((\a\+)\)\=:E302/
-    endtry
-    call delete(tmp)
-    if fnamemodify(bufname('$'), ':p') ==# tmp
-      silent execute 'bwipeout '.bufnr('$')
-    endif
-    silent exe 'doau BufReadPost '.s:fnameescape(fn)
-  endtry
-endfunction
-
-function! s:BufReadIndex() abort
-  if !exists('b:fugitive_display_format')
-    let b:fugitive_display_format = filereadable(expand('%').'.lock')
-  endif
-  let b:fugitive_display_format = b:fugitive_display_format % 2
-  let b:fugitive_type = 'index'
-  try
-    let b:git_dir = s:repo().dir()
-    setlocal noro ma nomodeline
-    if fnamemodify($GIT_INDEX_FILE !=# '' ? $GIT_INDEX_FILE : b:git_dir . '/index', ':p') ==# expand('%:p')
-      let index = ''
-    else
-      let index = expand('%:p')
-    endif
-    if b:fugitive_display_format
-      call s:ReplaceCmd(s:repo().git_command('ls-files','--stage'),index)
-      set ft=git nospell
-    else
-      let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
-      let dir = getcwd()
-      if fugitive#git_version() =~# '^0\|^1\.[1-7]\.'
-        let cmd = s:repo().git_command('status')
-      else
-        let cmd = s:repo().git_command(
-              \ '-c', 'status.displayCommentPrefix=true',
-              \ '-c', 'color.status=false',
-              \ '-c', 'status.short=false',
-              \ 'status')
-      endif
-      try
-        execute cd s:fnameescape(s:repo().tree())
-        call s:ReplaceCmd(cmd, index)
-      finally
-        execute cd s:fnameescape(dir)
-      endtry
-      set ft=gitcommit
-      set foldtext=fugitive#foldtext()
-    endif
-    setlocal ro noma nomod noswapfile
-    if &bufhidden ==# ''
-      setlocal bufhidden=delete
-    endif
-    call s:JumpInit()
-    nunmap   <buffer>          P
-    nunmap   <buffer>          ~
-    nnoremap <buffer> <silent> <C-N> :<C-U>execute <SID>StageNext(v:count1)<CR>
-    nnoremap <buffer> <silent> <C-P> :<C-U>execute <SID>StagePrevious(v:count1)<CR>
-    nnoremap <buffer> <silent> - :<C-U>silent execute <SID>StageToggle(line('.'),line('.')+v:count1-1)<CR>
-    xnoremap <buffer> <silent> - :<C-U>silent execute <SID>StageToggle(line("'<"),line("'>"))<CR>
-    nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += 1<Bar>exe <SID>BufReadIndex()<CR>
-    nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= 1<Bar>exe <SID>BufReadIndex()<CR>
-    nnoremap <buffer> <silent> C :<C-U>Gcommit<CR>
-    nnoremap <buffer> <silent> cA :<C-U>Gcommit --amend --reuse-message=HEAD<CR>
-    nnoremap <buffer> <silent> ca :<C-U>Gcommit --amend<CR>
-    nnoremap <buffer> <silent> cc :<C-U>Gcommit<CR>
-    nnoremap <buffer> <silent> cva :<C-U>Gcommit --amend --verbose<CR>
-    nnoremap <buffer> <silent> cvc :<C-U>Gcommit --verbose<CR>
-    nnoremap <buffer> <silent> D :<C-U>execute <SID>StageDiff('Gdiff')<CR>
-    nnoremap <buffer> <silent> dd :<C-U>execute <SID>StageDiff('Gdiff')<CR>
-    nnoremap <buffer> <silent> dh :<C-U>execute <SID>StageDiff('Gsdiff')<CR>
-    nnoremap <buffer> <silent> ds :<C-U>execute <SID>StageDiff('Gsdiff')<CR>
-    nnoremap <buffer> <silent> dp :<C-U>execute <SID>StageDiffEdit()<CR>
-    nnoremap <buffer> <silent> dv :<C-U>execute <SID>StageDiff('Gvdiff')<CR>
-    nnoremap <buffer> <silent> p :<C-U>execute <SID>StagePatch(line('.'),line('.')+v:count1-1)<CR>
-    xnoremap <buffer> <silent> p :<C-U>execute <SID>StagePatch(line("'<"),line("'>"))<CR>
-    nnoremap <buffer> <silent> P :<C-U>execute <SID>StagePatch(line('.'),line('.')+v:count1-1)<CR>
-    xnoremap <buffer> <silent> P :<C-U>execute <SID>StagePatch(line("'<"),line("'>"))<CR>
-    nnoremap <buffer> <silent> q :<C-U>if bufnr('$') == 1<Bar>quit<Bar>else<Bar>bdelete<Bar>endif<CR>
-    nnoremap <buffer> <silent> r :<C-U>edit<CR>
-    nnoremap <buffer> <silent> R :<C-U>edit<CR>
-    nnoremap <buffer> <silent> U :<C-U>execute <SID>StageUndo()<CR>
-    nnoremap <buffer> <silent> g?   :help fugitive-:Gstatus<CR>
-    nnoremap <buffer> <silent> <F1> :help fugitive-:Gstatus<CR>
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-function! s:FileRead() abort
-  try
-    let repo = s:repo(fugitive#extract_git_dir(expand('<amatch>')))
-    let path = s:sub(s:sub(matchstr(expand('<amatch>'),'fugitive://.\{-\}//\zs.*'),'/',':'),'^\d:',':&')
-    let hash = repo.rev_parse(path)
-    if path =~ '^:'
-      let type = 'blob'
-    else
-      let type = repo.git_chomp('cat-file','-t',hash)
-    endif
-    " TODO: use count, if possible
-    return "read !".escape(repo.git_command('cat-file',type,hash),'%#\')
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-function! s:BufReadIndexFile() abort
-  try
-    let b:fugitive_type = 'blob'
-    let b:git_dir = s:repo().dir()
-    try
-      call s:ReplaceCmd(s:repo().git_command('cat-file','blob',s:buffer().sha1()))
-    finally
-      if &bufhidden ==# ''
-        setlocal bufhidden=delete
-      endif
-      setlocal noswapfile
-    endtry
-    return ''
-  catch /^fugitive: rev-parse/
-    silent exe 'doau BufNewFile '.s:fnameescape(expand('%:p'))
-    return ''
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-function! s:BufWriteIndexFile() abort
-  let tmp = tempname()
-  try
-    let path = matchstr(expand('<amatch>'),'//\d/\zs.*')
-    let stage = matchstr(expand('<amatch>'),'//\zs\d')
-    silent execute 'write !'.s:repo().git_command('hash-object','-w','--stdin').' > '.tmp
-    let sha1 = readfile(tmp)[0]
-    let old_mode = matchstr(s:repo().git_chomp('ls-files','--stage',path),'^\d\+')
-    if old_mode == ''
-      let old_mode = executable(s:repo().tree(path)) ? '100755' : '100644'
-    endif
-    let info = old_mode.' '.sha1.' '.stage."\t".path
-    call writefile([info],tmp)
-    if s:winshell()
-      let error = system('type '.s:gsub(tmp,'/','\\').'|'.s:repo().git_command('update-index','--index-info'))
-    else
-      let error = system(s:repo().git_command('update-index','--index-info').' < '.tmp)
-    endif
-    if v:shell_error == 0
-      setlocal nomodified
-      if exists('#BufWritePost')
-        execute 'doautocmd BufWritePost '.s:fnameescape(expand('%:p'))
-      endif
-      call fugitive#reload_status()
-      return ''
-    else
-      return 'echoerr '.string('fugitive: '.error)
-    endif
-  finally
-    call delete(tmp)
-  endtry
-endfunction
-
-function! s:BufReadObject() abort
-  try
-    setlocal noro ma
-    let b:git_dir = s:repo().dir()
-    let hash = s:buffer().sha1()
-    if !exists("b:fugitive_type")
-      let b:fugitive_type = s:repo().git_chomp('cat-file','-t',hash)
-    endif
-    if b:fugitive_type !~# '^\%(tag\|commit\|tree\|blob\)$'
-      return "echoerr ".string("fugitive: unrecognized git type '".b:fugitive_type."'")
-    endif
-    let firstline = getline('.')
-    if !exists('b:fugitive_display_format') && b:fugitive_type != 'blob'
-      let b:fugitive_display_format = +getbufvar('#','fugitive_display_format')
-    endif
-
-    if b:fugitive_type !=# 'blob'
-      setlocal nomodeline
-    endif
-
-    let pos = getpos('.')
-    silent keepjumps %delete_
-    setlocal endofline
-
-    try
-      if b:fugitive_type ==# 'tree'
-        let b:fugitive_display_format = b:fugitive_display_format % 2
-        if b:fugitive_display_format
-          call s:ReplaceCmd(s:repo().git_command('ls-tree',hash))
-        else
-          call s:ReplaceCmd(s:repo().git_command('show','--no-color',hash))
-        endif
-      elseif b:fugitive_type ==# 'tag'
-        let b:fugitive_display_format = b:fugitive_display_format % 2
-        if b:fugitive_display_format
-          call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
-        else
-          call s:ReplaceCmd(s:repo().git_command('cat-file','-p',hash))
-        endif
-      elseif b:fugitive_type ==# 'commit'
-        let b:fugitive_display_format = b:fugitive_display_format % 2
-        if b:fugitive_display_format
-          call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
-        else
-          call s:ReplaceCmd(s:repo().git_command('show','--no-color','--pretty=format:tree%x20%T%nparent%x20%P%nauthor%x20%an%x20<%ae>%x20%ad%ncommitter%x20%cn%x20<%ce>%x20%cd%nencoding%x20%e%n%n%s%n%n%b',hash))
-          keepjumps call search('^parent ')
-          if getline('.') ==# 'parent '
-            silent keepjumps delete_
-          else
-            silent keepjumps s/\%(^parent\)\@<! /\rparent /ge
-          endif
-          keepjumps let lnum = search('^encoding \%(<unknown>\)\=$','W',line('.')+3)
-          if lnum
-            silent keepjumps delete_
-          end
-          keepjumps 1
-        endif
-      elseif b:fugitive_type ==# 'blob'
-        call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
-        setlocal nomodeline
-      endif
-    finally
-      keepjumps call setpos('.',pos)
-      setlocal ro noma nomod noswapfile
-      if &bufhidden ==# ''
-        setlocal bufhidden=delete
-      endif
-      if b:fugitive_type !=# 'blob'
-        setlocal filetype=git foldmethod=syntax
-        nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += v:count1<Bar>exe <SID>BufReadObject()<CR>
-        nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= v:count1<Bar>exe <SID>BufReadObject()<CR>
-      else
-        call s:JumpInit()
-      endif
-    endtry
-
-    return ''
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-endfunction
-
-augroup fugitive_files
-  autocmd!
-  autocmd BufReadCmd  index{,.lock}
-        \ if fugitive#is_git_dir(expand('<amatch>:p:h')) |
-        \   exe s:BufReadIndex() |
-        \ elseif filereadable(expand('<amatch>')) |
-        \   read <amatch> |
-        \   1delete |
-        \ endif
-  autocmd FileReadCmd fugitive://**//[0-3]/**          exe s:FileRead()
-  autocmd BufReadCmd  fugitive://**//[0-3]/**          exe s:BufReadIndexFile()
-  autocmd BufWriteCmd fugitive://**//[0-3]/**          exe s:BufWriteIndexFile()
-  autocmd BufReadCmd  fugitive://**//[0-9a-f][0-9a-f]* exe s:BufReadObject()
-  autocmd FileReadCmd fugitive://**//[0-9a-f][0-9a-f]* exe s:FileRead()
-  autocmd FileType git
-        \ if exists('b:git_dir') |
-        \  call s:JumpInit() |
-        \ endif
-  autocmd FileType git,gitcommit,gitrebase
-        \ if exists('b:git_dir') |
-        \   call s:GFInit() |
-        \ endif
-augroup END
-
-" Section: Temp files
-
-if !exists('s:temp_files')
-  let s:temp_files = {}
-endif
-
-augroup fugitive_temp
-  autocmd!
-  autocmd BufNewFile,BufReadPost *
-        \ if has_key(s:temp_files,s:cpath(expand('<afile>:p'))) |
-        \   let b:git_dir = s:temp_files[s:cpath(expand('<afile>:p'))].dir |
-        \   let b:git_type = 'temp' |
-        \   let b:git_args = s:temp_files[s:cpath(expand('<afile>:p'))].args |
-        \   call fugitive#detect(expand('<afile>:p')) |
-        \   setlocal bufhidden=delete nobuflisted |
-        \   nnoremap <buffer> <silent> q    :<C-U>bdelete<CR>|
-        \ endif
-augroup END
-
-" Section: Go to file
-
-nnoremap <SID>: :<C-U><C-R>=v:count ? v:count : ''<CR>
-function! s:GFInit(...) abort
-  cnoremap <buffer> <expr> <Plug><cfile> fugitive#cfile()
-  if !exists('g:fugitive_no_maps') && empty(mapcheck('gf', 'n'))
-    nmap <buffer> <silent> gf          <SID>:find <Plug><cfile><CR>
-    nmap <buffer> <silent> <C-W>f     <SID>:sfind <Plug><cfile><CR>
-    nmap <buffer> <silent> <C-W><C-F> <SID>:sfind <Plug><cfile><CR>
-    nmap <buffer> <silent> <C-W>gf  <SID>:tabfind <Plug><cfile><CR>
-  endif
-endfunction
-
-function! s:JumpInit(...) abort
-  nnoremap <buffer> <silent> <CR>    :<C-U>exe <SID>GF("edit")<CR>
-  if !&modifiable
-    nnoremap <buffer> <silent> o     :<C-U>exe <SID>GF("split")<CR>
-    nnoremap <buffer> <silent> S     :<C-U>exe <SID>GF("vsplit")<CR>
-    nnoremap <buffer> <silent> O     :<C-U>exe <SID>GF("tabedit")<CR>
-    nnoremap <buffer> <silent> -     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().up(v:count1))<Bar> if fugitive#buffer().type('tree')<Bar>call search('^'.escape(expand('#:t'),'.*[]~\').'/\=$','wc')<Bar>endif<CR>
-    nnoremap <buffer> <silent> P     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().commit().'^'.v:count1.<SID>buffer().path(':'))<CR>
-    nnoremap <buffer> <silent> ~     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().commit().'~'.v:count1.<SID>buffer().path(':'))<CR>
-    nnoremap <buffer> <silent> C     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().containing_commit())<CR>
-    nnoremap <buffer> <silent> cc    :<C-U>exe <SID>Edit('edit',0,<SID>buffer().containing_commit())<CR>
-    nnoremap <buffer> <silent> co    :<C-U>exe <SID>Edit('split',0,<SID>buffer().containing_commit())<CR>
-    nnoremap <buffer> <silent> cS    :<C-U>exe <SID>Edit('vsplit',0,<SID>buffer().containing_commit())<CR>
-    nnoremap <buffer> <silent> cO    :<C-U>exe <SID>Edit('tabedit',0,<SID>buffer().containing_commit())<CR>
-    nnoremap <buffer> <silent> cP    :<C-U>exe <SID>Edit('pedit',0,<SID>buffer().containing_commit())<CR>
-    nnoremap <buffer>          .     : <C-R>=fnameescape(<SID>recall())<CR><Home>
-  endif
-endfunction
-
-function! s:cfile() abort
-  try
-    let buffer = s:buffer()
-    let myhash = buffer.sha1()
-    if myhash ==# '' && getline(1) =~# '^\%(commit\|tag\) \w'
-      let myhash = matchstr(getline(1),'^\w\+ \zs\S\+')
-    endif
-
-    if buffer.type('tree')
-      let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
-      if showtree && line('.') > 2
-        return [buffer.commit().':'.s:buffer().path().(buffer.path() =~# '^$\|/$' ? '' : '/').s:sub(getline('.'),'/$','')]
-      elseif getline('.') =~# '^\d\{6\} \l\{3,8\} \x\{40\}\t'
-        return [buffer.commit().':'.s:buffer().path().(buffer.path() =~# '^$\|/$' ? '' : '/').s:sub(matchstr(getline('.'),'\t\zs.*'),'/$','')]
-      endif
-
-    elseif buffer.type('blob')
-      let ref = expand("<cfile>")
-      try
-        let sha1 = buffer.repo().rev_parse(ref)
-      catch /^fugitive:/
-      endtry
-      if exists('sha1')
-        return [ref]
-      endif
-
-    else
-
-      let dcmds = []
-
-      " Index
-      if getline('.') =~# '^\d\{6\} \x\{40\} \d\t'
-        let ref = matchstr(getline('.'),'\x\{40\}')
-        let file = ':'.s:sub(matchstr(getline('.'),'\d\t.*'),'\t',':')
-        return [file]
-
-      elseif getline('.') =~# '^#\trenamed:.* -> '
-        let file = '/'.matchstr(getline('.'),' -> \zs.*')
-        return [file]
-      elseif getline('.') =~# '^#\t\(\k\| \)\+\p\?: *.'
-        let file = '/'.matchstr(getline('.'),': *\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$')
-        return [file]
-      elseif getline('.') =~# '^#\t.'
-        let file = '/'.matchstr(getline('.'),'#\t\zs.*')
-        return [file]
-      elseif getline('.') =~# ': needs merge$'
-        let file = '/'.matchstr(getline('.'),'.*\ze: needs merge$')
-        return [file, 'Gdiff!']
-
-      elseif getline('.') ==# '# Not currently on any branch.'
-        return ['HEAD']
-      elseif getline('.') =~# '^# On branch '
-        let file = 'refs/heads/'.getline('.')[12:]
-        return [file]
-      elseif getline('.') =~# "^# Your branch .*'"
-        let file = matchstr(getline('.'),"'\\zs\\S\\+\\ze'")
-        return [file]
-      endif
-
-      let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
-
-      if getline('.') =~# '^ref: '
-        let ref = strpart(getline('.'),5)
-
-      elseif getline('.') =~# '^commit \x\{40\}\>'
-        let ref = matchstr(getline('.'),'\x\{40\}')
-        return [ref]
-
-      elseif getline('.') =~# '^parent \x\{40\}\>'
-        let ref = matchstr(getline('.'),'\x\{40\}')
-        let line = line('.')
-        let parent = 0
-        while getline(line) =~# '^parent '
-          let parent += 1
-          let line -= 1
-        endwhile
-        return [ref]
-
-      elseif getline('.') =~ '^tree \x\{40\}$'
-        let ref = matchstr(getline('.'),'\x\{40\}')
-        if s:repo().rev_parse(myhash.':') == ref
-          let ref = myhash.':'
-        endif
-        return [ref]
-
-      elseif getline('.') =~# '^object \x\{40\}$' && getline(line('.')+1) =~ '^type \%(commit\|tree\|blob\)$'
-        let ref = matchstr(getline('.'),'\x\{40\}')
-        let type = matchstr(getline(line('.')+1),'type \zs.*')
-
-      elseif getline('.') =~# '^\l\{3,8\} '.myhash.'$'
-        let ref = buffer.rev()
-
-      elseif getline('.') =~# '^\l\{3,8\} \x\{40\}\>'
-        let ref = matchstr(getline('.'),'\x\{40\}')
-        echoerr "warning: unknown context ".matchstr(getline('.'),'^\l*')
-
-      elseif getline('.') =~# '^[+-]\{3\} [abciow12]\=/'
-        let ref = getline('.')[4:]
-
-      elseif getline('.') =~# '^[+-]' && search('^@@ -\d\+,\d\+ +\d\+,','bnW')
-        let type = getline('.')[0]
-        let lnum = line('.') - 1
-        let offset = 0
-        while getline(lnum) !~# '^@@ -\d\+,\d\+ +\d\+,'
-          if getline(lnum) =~# '^[ '.type.']'
-            let offset += 1
-          endif
-          let lnum -= 1
-        endwhile
-        let offset += matchstr(getline(lnum), type.'\zs\d\+')
-        let ref = getline(search('^'.type.'\{3\} [abciow12]/','bnW'))[4:-1]
-        let dcmds = [offset, 'normal!zv']
-
-      elseif getline('.') =~# '^rename from '
-        let ref = 'a/'.getline('.')[12:]
-      elseif getline('.') =~# '^rename to '
-        let ref = 'b/'.getline('.')[10:]
-
-      elseif getline('.') =~# '^@@ -\d\+,\d\+ +\d\+,'
-        let diff = getline(search('^diff --git \%([abciow12]/.*\|/dev/null\) \%([abciow12]/.*\|/dev/null\)', 'bcnW'))
-        let offset = matchstr(getline('.'), '+\zs\d\+')
-
-        let dref = matchstr(diff, '\Cdiff --git \zs\%([abciow12]/.*\|/dev/null\)\ze \%([abciow12]/.*\|/dev/null\)')
-        let ref = matchstr(diff, '\Cdiff --git \%([abciow12]/.*\|/dev/null\) \zs\%([abciow12]/.*\|/dev/null\)')
-        let dcmd = 'Gdiff! +'.offset
-
-      elseif getline('.') =~# '^diff --git \%([abciow12]/.*\|/dev/null\) \%([abciow12]/.*\|/dev/null\)'
-        let dref = matchstr(getline('.'),'\Cdiff --git \zs\%([abciow12]/.*\|/dev/null\)\ze \%([abciow12]/.*\|/dev/null\)')
-        let ref = matchstr(getline('.'),'\Cdiff --git \%([abciow12]/.*\|/dev/null\) \zs\%([abciow12]/.*\|/dev/null\)')
-        let dcmd = 'Gdiff!'
-
-      elseif getline('.') =~# '^index ' && getline(line('.')-1) =~# '^diff --git \%([abciow12]/.*\|/dev/null\) \%([abciow12]/.*\|/dev/null\)'
-        let line = getline(line('.')-1)
-        let dref = matchstr(line,'\Cdiff --git \zs\%([abciow12]/.*\|/dev/null\)\ze \%([abciow12]/.*\|/dev/null\)')
-        let ref = matchstr(line,'\Cdiff --git \%([abciow12]/.*\|/dev/null\) \zs\%([abciow12]/.*\|/dev/null\)')
-        let dcmd = 'Gdiff!'
-
-      elseif line('$') == 1 && getline('.') =~ '^\x\{40\}$'
-        let ref = getline('.')
-
-      elseif expand('<cword>') =~# '^\x\{7,40\}\>'
-        return [expand('<cword>')]
-
-      else
-        let ref = ''
-      endif
-
-      let prefixes = {
-            \ '1': '',
-            \ '2': '',
-            \ 'b': ':0:',
-            \ 'i': ':0:',
-            \ 'o': '',
-            \ 'w': ''}
-
-      if len(myhash)
-        let prefixes.a = myhash.'^:'
-        let prefixes.b = myhash.':'
-      endif
-      let ref = substitute(ref, '^\(\w\)/', '\=get(prefixes, submatch(1), "HEAD:")', '')
-      if exists('dref')
-        let dref = substitute(dref, '^\(\w\)/', '\=get(prefixes, submatch(1), "HEAD:")', '')
-      endif
-
-      if ref ==# '/dev/null'
-        " Empty blob
-        let ref = 'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391'
-      endif
-
-      if exists('dref')
-        return [ref, dcmd . ' ' . s:fnameescape(dref)] + dcmds
-      elseif ref != ""
-        return [ref] + dcmds
-      endif
-
-    endif
-    return []
-  endtry
-endfunction
-
-function! s:GF(mode) abort
-  try
-    let results = s:cfile()
-  catch /^fugitive:/
-    return 'echoerr v:errmsg'
-  endtry
-  if len(results)
-    return s:Edit(a:mode, 0, results[0]).join(map(results[1:-1], '"|".v:val'), '')
-  else
-    return ''
-  endif
-endfunction
-
-function! fugitive#cfile() abort
-  let pre = ''
-  let results = s:cfile()
-  if empty(results)
-    let cfile = expand('<cfile>')
-    if &includeexpr =~# '\<v:fname\>'
-      sandbox let cfile = eval(substitute(&includeexpr, '\C\<v:fname\>', '\=string(cfile)', 'g'))
-    endif
-    return cfile
-  elseif len(results) > 1
-    let pre = '+' . join(map(results[1:-1], 'escape(v:val, " ")'), '\|') . ' '
-  endif
-  return pre . s:fnameescape(fugitive#repo().translate(results[0]))
-endfunction
-
-" Section: Statusline
-
-function! s:repo_head_ref() dict abort
-  if !filereadable(self.dir('HEAD'))
-    return ''
-  endif
-  return readfile(self.dir('HEAD'))[0]
-endfunction
-
-call s:add_methods('repo',['head_ref'])
-
-function! fugitive#statusline(...) abort
-  if !exists('b:git_dir')
-    return ''
-  endif
-  let status = ''
-  if s:buffer().commit() != ''
-    let status .= ':' . s:buffer().commit()[0:7]
-  endif
-  let status .= '('.fugitive#head(7).')'
-  if &statusline =~# '%[MRHWY]' && &statusline !~# '%[mrhwy]'
-    return ',GIT'.status
-  else
-    return '[Git'.status.']'
-  endif
-endfunction
-
-function! fugitive#head(...) abort
-  if !exists('b:git_dir')
-    return ''
-  endif
-
-  return s:repo().head(a:0 ? a:1 : 0)
-endfunction
-
-augroup fugitive_statusline
-  autocmd!
-  autocmd User Flags call Hoist('buffer', function('fugitive#statusline'))
-augroup END
-
-" Section: Folding
-
-function! fugitive#foldtext() abort
-  if &foldmethod !=# 'syntax'
-    return foldtext()
-  elseif getline(v:foldstart) =~# '^diff '
-    let [add, remove] = [-1, -1]
-    let filename = ''
-    for lnum in range(v:foldstart, v:foldend)
-      if filename ==# '' && getline(lnum) =~# '^[+-]\{3\} [abciow12]/'
-        let filename = getline(lnum)[6:-1]
-      endif
-      if getline(lnum) =~# '^+'
-        let add += 1
-      elseif getline(lnum) =~# '^-'
-        let remove += 1
-      elseif getline(lnum) =~# '^Binary '
-        let binary = 1
-      endif
-    endfor
-    if filename ==# ''
-      let filename = matchstr(getline(v:foldstart), '^diff .\{-\} [abciow12]/\zs.*\ze [abciow12]/')
-    endif
-    if filename ==# ''
-      let filename = getline(v:foldstart)[5:-1]
-    endif
-    if exists('binary')
-      return 'Binary: '.filename
-    else
-      return (add<10&&remove<100?' ':'') . add . '+ ' . (remove<10&&add<100?' ':'') . remove . '- ' . filename
-    endif
-  elseif getline(v:foldstart) =~# '^# .*:$'
-    let lines = getline(v:foldstart, v:foldend)
-    call filter(lines, 'v:val =~# "^#\t"')
-    cal map(lines,'s:sub(v:val, "^#\t%(modified: +|renamed: +)=", "")')
-    cal map(lines,'s:sub(v:val, "^([[:alpha:] ]+): +(.*)", "\\2 (\\1)")')
-    return getline(v:foldstart).' '.join(lines, ', ')
-  endif
-  return foldtext()
-endfunction
-
-augroup fugitive_foldtext
-  autocmd!
-  autocmd User Fugitive
-        \ if &filetype =~# '^git\%(commit\)\=$' && &foldtext ==# 'foldtext()' |
-        \    set foldtext=fugitive#foldtext() |
-        \ endif
-augroup END
+call s:Map('c', '<C-R><C-G>', 'fnameescape(fugitive#Object(@%))', '<expr>')
+call s:Map('n', 'y<C-G>', ':<C-U>call setreg(v:register, fugitive#Object(@%))<CR>', '<silent>')
diff --git a/vim/bundle/vim-fugitive/syntax/fugitive.vim b/vim/bundle/vim-fugitive/syntax/fugitive.vim
new file mode 100644
index 0000000..e84eba4
--- /dev/null
+++ b/vim/bundle/vim-fugitive/syntax/fugitive.vim
@@ -0,0 +1,57 @@
+if exists("b:current_syntax")
+  finish
+endif
+
+syn sync fromstart
+syn spell notoplevel
+
+syn include @fugitiveDiff syntax/diff.vim
+
+syn match fugitiveHeader /^[A-Z][a-z][^:]*:/ nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
+syn match fugitiveBareHeader /^Bare:/
+syn match fugitiveHelpHeader /^Help:/ nextgroup=fugitiveHelpTag skipwhite
+syn match fugitiveHelpTag    /\S\+/ contained
+
+syn region fugitiveSection start=/^\%(.*(\d\+)$\)\@=/ contains=fugitiveHeading end=/^$/
+syn cluster fugitiveSection contains=fugitiveSection
+syn match fugitiveHeading /^[A-Z][a-z][^:]*\ze (\d\+)$/ contains=fugitivePreposition contained nextgroup=fugitiveCount skipwhite
+syn match fugitiveCount /(\d\+)/hs=s+1,he=e-1 contained
+syn match fugitivePreposition /\<\%([io]nto\|from\|to\|Rebasing\%( detached\)\=\)\>/ transparent contained nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
+
+syn match fugitiveInstruction /^\l\l\+\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
+syn match fugitiveDone /^done\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
+syn match fugitiveStop /^stop\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
+syn match fugitiveModifier /^[MADRCU?]\{1,2} / contained containedin=@fugitiveSection
+syn match fugitiveSymbolicRef /\.\@!\%(\.\.\@!\|[^[:space:][:cntrl:]\:.]\)\+\.\@<!/ contained
+syn match fugitiveHash /^\x\{4,\}\S\@!/ contained containedin=@fugitiveSection
+syn match fugitiveHash /\S\@<!\x\{4,\}\S\@!/ contained
+
+syn region fugitiveHunk start=/^\%(@@\+ -\)\@=/ end=/^\%([A-Za-z?@]\|$\)\@=/ contains=@fugitiveDiff containedin=@fugitiveSection fold
+
+for s:section in ['Untracked', 'Unstaged', 'Staged']
+  exe 'syn region fugitive' . s:section . 'Section start=/^\%(' . s:section . ' .*(\d\+)$\)\@=/ contains=fugitive' . s:section . 'Heading end=/^$/'
+  exe 'syn match fugitive' . s:section . 'Modifier /^[MADRCU?] / contained containedin=fugitive' . s:section . 'Section'
+  exe 'syn cluster fugitiveSection add=fugitive' . s:section . 'Section'
+  exe 'syn match fugitive' . s:section . 'Heading /^[A-Z][a-z][^:]*\ze (\d\+)$/ contains=fugitivePreposition contained nextgroup=fugitiveCount skipwhite'
+endfor
+unlet s:section
+
+hi def link fugitiveBareHeader fugitiveHeader
+hi def link fugitiveHelpHeader fugitiveHeader
+hi def link fugitiveHeader Label
+hi def link fugitiveHelpTag Tag
+hi def link fugitiveHeading PreProc
+hi def link fugitiveUntrackedHeading PreCondit
+hi def link fugitiveUnstagedHeading Macro
+hi def link fugitiveStagedHeading Include
+hi def link fugitiveModifier Type
+hi def link fugitiveUntrackedModifier StorageClass
+hi def link fugitiveUnstagedModifier Structure
+hi def link fugitiveStagedModifier Typedef
+hi def link fugitiveInstruction Type
+hi def link fugitiveStop Function
+hi def link fugitiveHash Identifier
+hi def link fugitiveSymbolicRef Function
+hi def link fugitiveCount Number
+
+let b:current_syntax = "fugitive"
diff --git a/vim/bundle/vim-fugitive/syntax/fugitiveblame.vim b/vim/bundle/vim-fugitive/syntax/fugitiveblame.vim
new file mode 100644
index 0000000..c06d19e
--- /dev/null
+++ b/vim/bundle/vim-fugitive/syntax/fugitiveblame.vim
@@ -0,0 +1,7 @@
+if exists("b:current_syntax")
+  finish
+endif
+
+call fugitive#BlameSyntax()
+
+let b:current_syntax = "fugitiveblame"
diff --git a/vimrc b/vimrc
index d00fa0c..7ebaec3 100644
--- a/vimrc
+++ b/vimrc
@@ -32,7 +32,7 @@ if has("autocmd")
   augroup vimrcEx
   au!
 
-  " For all text files set 'textwidth' to 78 characters.
+  " Custom text width for plaintext files
   autocmd FileType text setlocal textwidth=90
 
   " When vimrc is edited, reload it
@@ -46,6 +46,13 @@ if has("autocmd")
     \   exe "normal g`\"" |
     \ endif
   augroup END
+
+  " Persist folds across file loads
+  " augroup remember_folds
+  "     autocmd!
+  "     autocmd BufWinLeave ?* mkview | filetype detect
+  "     autocmd BufWinEnter ?* silent loadview | filetype detect
+  " augroup END
 endif " has("autocmd")
 
 " Open a NERDtree when loading vim with no files.
@@ -192,6 +199,12 @@ nnoremap <leader>f :let @* = expand("%")<CR>
 " Copy `yarn runtest --watch <current filename>` to system clipboard
 nnoremap <leader>tf :let @* = "yarn run runtest --watch " . expand("%")<CR>
 
+" By default, * and # respect 'ignorecase'. This mapping forces these commands
+" to search case sensitively, which is usually what you want when searching
+" code with * or #.
+nnoremap <silent> * /\C\<<C-R>=expand('<cword>')<CR>\><CR>
+nnoremap <silent> # ?\C\<<C-R>=expand('<cword>')<CR>\><CR>
+
 " Custom options
 set mouse=a                       " Enable mouse in all modes
 set backspace=indent,eol,start    " Allow backspacing over everything in insert mode
@@ -209,9 +222,9 @@ set magic                         " Use regular expression magic mode (see help)
 set noshowmatch                   " Turn off matching bracket highlighting
 set scrolloff=5                   " Always show at least 5 lines past the cursor
 set wildmenu                      " Use advanced ex mode completion
-set undodir="~/.vim/runtime/undo" " Where to store persistent undo info
+set undodir=~/.vim/runtime/undo   " Where to store persistent undo info
 set undofile                      " Turn on persistent undo
-set backupskip="/tmp/*"           " Don't create backup files for these.
+set backupskip=/tmp/*             " Don't create backup files for these.
 set expandtab                     " Always use spaces; no tabs
 set shiftwidth=2                  " Number of spaces in one level of indentation
 set tabstop=8                     " Number of spaces to display where tabs are found
-- 
2.51.2