From 797bb7310b03ce22857dfb039af2c1f3d301532b Mon Sep 17 00:00:00 2001
From: c0dev0id <sh+git@codevoid.de>
Date: Sat, 19 Aug 2023 13:25:19 +0200
Subject: [PATCH] vim-plugins

---
 .../bundle/vim-fugitive/CONTRIBUTING.markdown |   24 +
 .vim/bundle/vim-fugitive/README.markdown      |  137 +
 .../bundle/vim-fugitive/autoload/fugitive.vim | 8227 +++++++++++++++++
 .vim/bundle/vim-fugitive/doc/fugitive.txt     |  730 ++
 .vim/bundle/vim-fugitive/doc/tags             |  153 +
 .../bundle/vim-fugitive/ftdetect/fugitive.vim |    1 +
 .../vim-fugitive/ftplugin/fugitiveblame.vim   |    6 +
 .vim/bundle/vim-fugitive/plugin/fugitive.vim  |  754 ++
 .vim/bundle/vim-fugitive/syntax/fugitive.vim  |   57 +
 .../vim-fugitive/syntax/fugitiveblame.vim     |    7 +
 .vim/bundle/vim-nerdtree-fugitive             |    1 +
 .vim/bundle/vim-nerdtree/.vintrc.yaml         |    5 +
 .vim/bundle/vim-nerdtree/CHANGELOG.md         |  307 +
 .vim/bundle/vim-nerdtree/LICENCE              |   13 +
 .vim/bundle/vim-nerdtree/README.markdown      |  227 +
 .vim/bundle/vim-nerdtree/_config.yml          |    1 +
 .../bundle/vim-nerdtree/autoload/nerdtree.vim |  249 +
 .../autoload/nerdtree/ui_glue.vim             |  732 ++
 .vim/bundle/vim-nerdtree/doc/NERDTree.txt     | 1534 +++
 .vim/bundle/vim-nerdtree/doc/tags             |  143 +
 .../vim-nerdtree/lib/nerdtree/bookmark.vim    |  365 +
 .../vim-nerdtree/lib/nerdtree/creator.vim     |  402 +
 .../vim-nerdtree/lib/nerdtree/event.vim       |   13 +
 .../vim-nerdtree/lib/nerdtree/flag_set.vim    |   58 +
 .../vim-nerdtree/lib/nerdtree/key_map.vim     |  164 +
 .../lib/nerdtree/menu_controller.vim          |  211 +
 .../vim-nerdtree/lib/nerdtree/menu_item.vim   |  118 +
 .../vim-nerdtree/lib/nerdtree/nerdtree.vim    |  209 +
 .../vim-nerdtree/lib/nerdtree/notifier.vim    |   35 +
 .../vim-nerdtree/lib/nerdtree/opener.vim      |  326 +
 .../bundle/vim-nerdtree/lib/nerdtree/path.vim |  852 ++
 .../lib/nerdtree/tree_dir_node.vim            |  706 ++
 .../lib/nerdtree/tree_file_node.vim           |  349 +
 .vim/bundle/vim-nerdtree/lib/nerdtree/ui.vim  |  532 ++
 .../nerdtree_plugin/exec_menuitem.vim         |   40 +
 .../vim-nerdtree/nerdtree_plugin/fs_menu.vim  |  484 +
 .../vim-nerdtree/nerdtree_plugin/vcs.vim      |   47 +
 .vim/bundle/vim-nerdtree/plugin/NERD_tree.vim |  234 +
 .vim/bundle/vim-nerdtree/screenshot.png       |  Bin 0 -> 87896 bytes
 .vim/bundle/vim-nerdtree/syntax/nerdtree.vim  |   97 +
 40 files changed, 18550 insertions(+)
 create mode 100644 .vim/bundle/vim-fugitive/CONTRIBUTING.markdown
 create mode 100644 .vim/bundle/vim-fugitive/README.markdown
 create mode 100644 .vim/bundle/vim-fugitive/autoload/fugitive.vim
 create mode 100644 .vim/bundle/vim-fugitive/doc/fugitive.txt
 create mode 100644 .vim/bundle/vim-fugitive/doc/tags
 create mode 100644 .vim/bundle/vim-fugitive/ftdetect/fugitive.vim
 create mode 100644 .vim/bundle/vim-fugitive/ftplugin/fugitiveblame.vim
 create mode 100644 .vim/bundle/vim-fugitive/plugin/fugitive.vim
 create mode 100644 .vim/bundle/vim-fugitive/syntax/fugitive.vim
 create mode 100644 .vim/bundle/vim-fugitive/syntax/fugitiveblame.vim
 create mode 160000 .vim/bundle/vim-nerdtree-fugitive
 create mode 100644 .vim/bundle/vim-nerdtree/.vintrc.yaml
 create mode 100644 .vim/bundle/vim-nerdtree/CHANGELOG.md
 create mode 100644 .vim/bundle/vim-nerdtree/LICENCE
 create mode 100644 .vim/bundle/vim-nerdtree/README.markdown
 create mode 100644 .vim/bundle/vim-nerdtree/_config.yml
 create mode 100644 .vim/bundle/vim-nerdtree/autoload/nerdtree.vim
 create mode 100644 .vim/bundle/vim-nerdtree/autoload/nerdtree/ui_glue.vim
 create mode 100644 .vim/bundle/vim-nerdtree/doc/NERDTree.txt
 create mode 100644 .vim/bundle/vim-nerdtree/doc/tags
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/bookmark.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/creator.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/event.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/flag_set.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/key_map.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/menu_controller.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/menu_item.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/nerdtree.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/notifier.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/opener.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/path.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/tree_dir_node.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/tree_file_node.vim
 create mode 100644 .vim/bundle/vim-nerdtree/lib/nerdtree/ui.vim
 create mode 100644 .vim/bundle/vim-nerdtree/nerdtree_plugin/exec_menuitem.vim
 create mode 100644 .vim/bundle/vim-nerdtree/nerdtree_plugin/fs_menu.vim
 create mode 100644 .vim/bundle/vim-nerdtree/nerdtree_plugin/vcs.vim
 create mode 100644 .vim/bundle/vim-nerdtree/plugin/NERD_tree.vim
 create mode 100644 .vim/bundle/vim-nerdtree/screenshot.png
 create mode 100644 .vim/bundle/vim-nerdtree/syntax/nerdtree.vim

diff --git a/.vim/bundle/vim-fugitive/CONTRIBUTING.markdown b/.vim/bundle/vim-fugitive/CONTRIBUTING.markdown
new file mode 100644
index 0000000..843bbe6
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/CONTRIBUTING.markdown
@@ -0,0 +1,24 @@
+Before reporting a bug, you should try stripping down your Vim configuration
+and removing other plugins.  The sad truth about VimScript is that it is
+fraught with incompatibilities waiting to happen.  I'm happy to work around
+them where I can, but it's up to you to isolate the conflict.
+
+Fugitive is particularly prone to regressions due to Git version issues,
+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](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
+perverse knowledge of VimScript so vast that many would consider it a symptom
+of mental illness.  On the flip side, some ideas I'll reject no matter how
+good the implementation is.  "Send a patch" is an edge case answer in my book.
diff --git a/.vim/bundle/vim-fugitive/README.markdown b/.vim/bundle/vim-fugitive/README.markdown
new file mode 100644
index 0000000..3dc4e6c
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/README.markdown
@@ -0,0 +1,137 @@
+# fugitive.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` (or `:Gvdiffsplit`) 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 `%{FugitiveStatusline()}` to `'statusline'` to get an indicator
+with the current branch in your statusline.
+
+For more information, see `:help fugitive`.
+
+## Screencasts
+
+* [A complement to command line git](http://vimcasts.org/e/31)
+* [Working with the git index](http://vimcasts.org/e/32)
+* [Resolving merge conflicts with vimdiff](http://vimcasts.org/e/33)
+* [Browsing the git object database](http://vimcasts.org/e/34)
+* [Exploring the history of a git repository](http://vimcasts.org/e/35)
+
+## Installation
+
+Install using your favorite package manager, or use Vim's built-in package
+support:
+
+    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
+
+> What happened to the dispatch.vim backed asynchronous `:Gpush` and
+> `:Gfetch`?
+
+This behavior was divisive, confusing, and complicated inputting passwords, so
+it was removed.  Use `:Git! push` to use Fugitive's own asynchronous
+execution, or retroactively make `:Git push` asynchronous by pressing
+`CTRL-D`.
+
+> Why am I getting `core.worktree is required when using an external Git dir`?
+
+Git generally sets `core.worktree` for you automatically when necessary, but
+if you're doing something weird, or using a third-party tool that does
+something weird, you may need to set it manually:
+
+    git config core.worktree "$PWD"
+
+This may be necessary even when simple `git` commands seem to work fine
+without it.
+
+> So I have a symlink and...
+
+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
+
+Like fugitive.vim? Follow the repository on
+[GitHub](https://github.com/tpope/vim-fugitive) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=2975).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/.vim/bundle/vim-fugitive/autoload/fugitive.vim b/.vim/bundle/vim-fugitive/autoload/fugitive.vim
new file mode 100644
index 0000000..6e5095f
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/autoload/fugitive.vim
@@ -0,0 +1,8227 @@
+" Location:     autoload/fugitive.vim
+" Maintainer:   Tim Pope <http://tpo.pe/>
+
+" The functions contained within this file are for internal use only.  For the
+" official API, see the commented functions in plugin/fugitive.vim.
+
+if exists('g:autoloaded_fugitive')
+  finish
+endif
+let g:autoloaded_fugitive = 1
+
+" 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:JoinChomp(list) abort
+  if empty(a:list[-1])
+    return join(a:list[0:-2], "\n")
+  else
+    return join(a:list, "\n")
+  endif
+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:WinShellEsc(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
+
+function! s:fnameescape(file) abort
+  if type(a:file) == type([])
+    return join(map(copy(a:file), 's:fnameescape(v:val)'))
+  else
+    return fnameescape(a:file)
+  endif
+endfunction
+
+function! fugitive#UrlDecode(str) abort
+  return substitute(a:str, '%\(\x\x\)', '\=iconv(nr2char("0x".submatch(1)), "utf-8", "latin1")', 'g')
+endfunction
+
+function! s:UrlEncode(str) abort
+  return substitute(a:str, '[%#?&;+=\<> [:cntrl:]]', '\=printf("%%%02X", char2nr(submatch(0)))', 'g')
+endfunction
+
+function! s:PathUrlEncode(str) abort
+  return substitute(a:str, '[%#?[:cntrl:]]', '\=printf("%%%02X", char2nr(submatch(0)))', 'g')
+endfunction
+
+function! s:PathJoin(prefix, str) abort
+  if a:prefix =~# '://'
+    return a:prefix . s:PathUrlEncode(a:str)
+  else
+    return a:prefix . a:str
+  endif
+endfunction
+
+function! s:throw(string) abort
+  throw 'fugitive: '.a:string
+endfunction
+
+function! s:VersionCheck() abort
+  if v:version < 704
+    return 'return ' . string('echoerr "fugitive: Vim 7.4 or newer required"')
+  elseif empty(fugitive#GitVersion())
+    let exe = get(s:GitCmd(), 0, '')
+    if len(exe) && !executable(exe)
+      return 'return ' . string('echoerr "fugitive: cannot find ' . string(exe) . ' in PATH"')
+    endif
+    return 'return ' . string('echoerr "fugitive: cannot execute Git"')
+  elseif !fugitive#GitVersion(1, 8, 5)
+    return 'return ' . string('echoerr "fugitive: Git 1.8.5 or newer required"')
+  else
+    return ''
+  endif
+endfunction
+
+let s:worktree_error = "core.worktree is required when using an external Git dir"
+function! s:DirCheck(...) abort
+  let vcheck = s:VersionCheck()
+  if !empty(vcheck)
+    return vcheck
+  endif
+  let dir = call('FugitiveGitDir', a:000)
+  if !empty(dir) && FugitiveWorkTree(dir, 1) is# 0
+    return 'return ' . string('echoerr "fugitive: ' . s:worktree_error . '"')
+  elseif !empty(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 default = a:1
+    if default ==# 'SpanOrigin'
+      if s:OriginBufnr() > 0 && (mods =~# '\<vertical\>' ? &winfixheight : &winfixwidth)
+        let default = 'Edge'
+      else
+        let default = ''
+      endif
+    endif
+    if default ==# 'Edge'
+      if mods =~# '\<vertical\>' ? &splitright : &splitbelow
+        let mods = 'botright ' . mods
+      else
+        let mods = 'topleft ' . mods
+      endif
+    else
+      let mods = default . ' ' . mods
+    endif
+  endif
+  return substitute(mods, '\s\+', ' ', 'g')
+endfunction
+
+if exists('+shellslash')
+
+  let s:dir_commit_file = '\c^fugitive://\%(/[^/]\@=\)\=\([^?#]\{-1,\}\)//\%(\(\x\{40,\}\|[0-3]\)\(/[^?#]*\)\=\)\=$'
+
+  function! s:Slash(path) abort
+    return tr(a:path, '\', '/')
+  endfunction
+
+  function! s:VimSlash(path) abort
+    return tr(a:path, '\/', &shellslash ? '//' : '\\')
+  endfunction
+
+else
+
+  let s:dir_commit_file = '\c^fugitive://\([^?#]\{-\}\)//\%(\(\x\{40,\}\|[0-3]\)\(/[^?#]*\)\=\)\=$'
+
+  function! s:Slash(path) abort
+    return a:path
+  endfunction
+
+  function! s:VimSlash(path) abort
+    return a:path
+  endfunction
+
+endif
+
+function! s:AbsoluteVimPath(...) abort
+  if a:0 && type(a:1) == type('')
+    let path = a:1
+  else
+    let path = bufname(a:0 && a:1 > 0 ? a:1 : '')
+    if getbufvar(a:0 && a:1 > 0 ? a:1 : '', '&buftype') !~# '^\%(nowrite\|acwrite\)\=$'
+      return path
+    endif
+  endif
+  if s:Slash(path) =~# '^/\|^\a\+:'
+    return path
+  else
+    return getcwd() . matchstr(getcwd(), '[\\/]') . path
+  endif
+endfunction
+
+function! s:Resolve(path) abort
+  let path = resolve(a:path)
+  if has('win32')
+    let path = s:VimSlash(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 = s:VimSlash(tolower(a:path))
+  else
+    let path = s:VimSlash(a:path)
+  endif
+  return a:0 ? path ==# s:cpath(a:1) : path
+endfunction
+
+let s:quote_chars = {
+      \ "\007": 'a', "\010": 'b', "\011": 't', "\012": 'n', "\013": 'v', "\014": 'f', "\015": 'r',
+      \ '"': '"', '\': '\'}
+
+let s:unquote_chars = {
+      \ 'a': "\007", 'b': "\010", 't': "\011", 'n': "\012", 'v': "\013", 'f': "\014", 'r': "\015",
+      \ '"': '"', '\': '\'}
+
+function! s:Quote(string) abort
+  let string = substitute(a:string, "[\001-\037\"\\\177]", '\="\\" . get(s:quote_chars, submatch(0), printf("%03o", char2nr(submatch(0))))', 'g')
+  if string !=# a:string
+    return '"' . string . '"'
+  else
+    return string
+  endif
+endfunction
+
+function! fugitive#Unquote(string) abort
+  let string = substitute(a:string, "\t*$", '', '')
+  if string =~# '^".*"$'
+    return substitute(string[1:-2], '\\\(\o\o\o\|.\)', '\=get(s:unquote_chars, submatch(1), iconv(nr2char("0" . submatch(1)), "utf-8", "latin1"))', 'g')
+  else
+    return string
+  endif
+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(...) abort
+  return join(map(copy(a:000), "'doautocmd <nomodeline>' . v:val"), '|')
+endfunction
+
+function! s:Map(mode, lhs, rhs, ...) abort
+  let maps = []
+  let flags = a:0 && type(a:1) == type('') ? a:1 : ''
+  let defer = flags =~# '<unique>'
+  let flags = substitute(flags, '<unique>', '', '') . (a:rhs =~# '<Plug>' ? '' : '<script>') . '<nowait>'
+  for mode in split(a:mode, '\zs')
+    if a:0 <= 1
+      call add(maps, mode.'map <buffer>' . substitute(flags, '<unique>', '', '') . ' <Plug>fugitive:' . a:lhs . ' ' . a:rhs)
+    endif
+    let skip = 0
+    let head = a:lhs
+    let tail = ''
+    let keys = get(g:, mode.'remap', {})
+    if type(keys) == type([])
+      continue
+    endif
+    while !empty(head)
+      if has_key(keys, head)
+        let head = keys[head]
+        let skip = empty(head)
+        break
+      endif
+      let tail = matchstr(head, '<[^<>]*>$\|.$') . tail
+      let head = substitute(head, '<[^<>]*>$\|.$', '', '')
+    endwhile
+    if !skip && (!defer || empty(mapcheck(head.tail, mode)))
+      call add(maps, mode.'map <buffer>' . flags . ' ' . head.tail . ' ' . a:rhs)
+      if a:0 > 1 && a:2
+        let b:undo_ftplugin = get(b:, 'undo_ftplugin', 'exe') .
+              \ '|sil! exe "' . mode . 'unmap <buffer> ' . head.tail . '"'
+      endif
+    endif
+  endfor
+  exe join(maps, '|')
+  return ''
+endfunction
+
+function! fugitive#Autowrite() abort
+  if &autowrite || &autowriteall
+    try
+      if &confirm
+        let reconfirm = 1
+        setglobal noconfirm
+      endif
+      silent! wall
+    finally
+      if exists('reconfirm')
+        setglobal confirm
+      endif
+    endtry
+  endif
+  return ''
+endfunction
+
+function! fugitive#Wait(job_or_jobs, ...) abort
+  let original = type(a:job_or_jobs) == type([]) ? copy(a:job_or_jobs) : [a:job_or_jobs]
+  let jobs = map(copy(original), 'type(v:val) ==# type({}) ? get(v:val, "job", "") : v:val')
+  call filter(jobs, 'type(v:val) !=# type("")')
+  let timeout_ms = a:0 ? a:1 : -1
+  if exists('*jobwait')
+    call map(copy(jobs), 'chanclose(v:val, "stdin")')
+    call jobwait(jobs, timeout_ms)
+    let jobs = map(copy(original), 'type(v:val) ==# type({}) ? get(v:val, "job", "") : v:val')
+    call filter(jobs, 'type(v:val) !=# type("")')
+    if len(jobs)
+      sleep 1m
+    endif
+  else
+    let sleep = has('patch-8.2.2366') ? 'sleep! 1m' : 'sleep 1m'
+    for job in jobs
+      if ch_status(job) ==# 'open'
+        call ch_close_in(job)
+      endif
+    endfor
+    let i = 0
+    for job in jobs
+      while ch_status(job) !~# '^closed$\|^fail$' || job_status(job) ==# 'run'
+        if i == timeout_ms
+          break
+        endif
+        let i += 1
+        exe sleep
+      endwhile
+    endfor
+  endif
+  return a:job_or_jobs
+endfunction
+
+function! s:JobVimExit(dict, callback, temp, job, status) abort
+  let a:dict.exit_status = a:status
+  let a:dict.stderr = readfile(a:temp . '.err', 'b')
+  call delete(a:temp . '.err')
+  let a:dict.stdout = readfile(a:temp . '.out', 'b')
+  call delete(a:temp . '.out')
+  call delete(a:temp . '.in')
+  call remove(a:dict, 'job')
+  call call(a:callback[0], [a:dict] + a:callback[1:-1])
+endfunction
+
+function! s:JobNvimExit(dict, callback, job, data, type) dict abort
+  let a:dict.stdout = self.stdout
+  let a:dict.stderr = self.stderr
+  let a:dict.exit_status = a:data
+  call remove(a:dict, 'job')
+  call call(a:callback[0], [a:dict] + a:callback[1:-1])
+endfunction
+
+function! s:JobExecute(argv, jopts, stdin, callback, ...) abort
+  let dict = a:0 ? a:1 : {}
+  let cb = len(a:callback) ? a:callback : [function('len')]
+  if exists('*jobstart')
+    call extend(a:jopts, {
+          \ 'stdout_buffered': v:true,
+          \ 'stderr_buffered': v:true,
+          \ 'on_exit': function('s:JobNvimExit', [dict, cb])})
+    try
+      let dict.job = jobstart(a:argv, a:jopts)
+      if !empty(a:stdin)
+        call chansend(dict.job, a:stdin)
+        call chanclose(dict.job, 'stdin')
+      endif
+    catch /^Vim\%((\a\+)\)\=:E475:/
+      let [dict.exit_status, dict.stdout, dict.stderr] = [122, [''], ['']]
+    endtry
+  elseif exists('*ch_close_in')
+    let temp = tempname()
+    call extend(a:jopts, {
+          \ 'out_io': 'file',
+          \ 'out_name': temp . '.out',
+          \ 'err_io': 'file',
+          \ 'err_name': temp . '.err',
+          \ 'exit_cb': function('s:JobVimExit', [dict, cb, temp])})
+    if a:stdin ==# ['']
+      let a:jopts.in_io = 'null'
+    elseif !empty(a:stdin)
+      let a:jopts.in_io = 'file'
+      let a:jopts.in_name = temp . '.in'
+      call writefile(a:stdin, a:jopts.in_name, 'b')
+    endif
+    let dict.job = job_start(a:argv, a:jopts)
+    if job_status(dict.job) ==# 'fail'
+      let [dict.exit_status, dict.stdout, dict.stderr] = [122, [''], ['']]
+      unlet dict.job
+    endif
+  elseif &shell !~# 'sh' || &shell =~# 'fish\|\%(powershell\|pwsh\)\%(\.exe\)\=$'
+    throw 'fugitive: Vim 8 or higher required to use ' . &shell
+  else
+    let cmd = s:shellesc(a:argv)
+    let outfile = tempname()
+    try
+      if len(a:stdin)
+        call writefile(a:stdin, outfile . '.in', 'b')
+        let cmd = ' (' . cmd . ' >' . outfile . ' <' . outfile . '.in) '
+      else
+        let cmd = ' (' . cmd . ' >' . outfile . ') '
+      endif
+      let dict.stderr = split(system(cmd), "\n", 1)
+      let dict.exit_status = v:shell_error
+      let dict.stdout = readfile(outfile, 'b')
+      call call(cb[0], [dict] + cb[1:-1])
+    finally
+      call delete(outfile)
+      call delete(outfile . '.in')
+    endtry
+  endif
+  if empty(a:callback)
+    call fugitive#Wait(dict)
+  endif
+  return dict
+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
+endfunction
+
+" Section: Git
+
+let s:run_jobs = (exists('*ch_close_in') || exists('*jobstart')) && exists('*bufwinid')
+
+function! s:GitCmd() abort
+  if !exists('g:fugitive_git_executable')
+    return ['git']
+  elseif type(g:fugitive_git_executable) == type([])
+    return g:fugitive_git_executable
+  else
+    let dquote = '"\%([^"]\|""\|\\"\)*"\|'
+    let string = g:fugitive_git_executable
+    let list = []
+    if string =~# '^\w\+='
+      call add(list, '/usr/bin/env')
+    endif
+    while string =~# '\S'
+      let arg = matchstr(string, '^\s*\%(' . dquote . '''[^'']*''\|\\.\|[^' . "\t" . ' |]\)\+')
+      let string = strpart(string, len(arg))
+      let arg = substitute(arg, '^\s\+', '', '')
+      let arg = substitute(arg,
+            \ '\(' . dquote . '''\%(''''\|[^'']\)*''\|\\[' . s:fnameescape . ']\|^\\[>+-]\|' . s:commit_expand . '\)\|' . s:expand,
+            \ '\=submatch(0)[0] ==# "\\" ? submatch(0)[1] : submatch(0)[1:-2]', 'g')
+      call add(list, arg)
+    endwhile
+    return list
+  endif
+endfunction
+
+function! s:GitShellCmd() abort
+  if !exists('g:fugitive_git_executable')
+    return 'git'
+  elseif type(g:fugitive_git_executable) == type([])
+    return s:shellesc(g:fugitive_git_executable)
+  else
+    return g:fugitive_git_executable
+  endif
+endfunction
+
+function! s:UserCommandCwd(dir) abort
+  let tree = s:Tree(a:dir)
+  return len(tree) ? s:VimSlash(tree) : getcwd()
+endfunction
+
+function! s:UserCommandList(...) abort
+  if !fugitive#GitVersion(1, 8, 5)
+    throw 'fugitive: Git 1.8.5 or higher required'
+  endif
+  if !exists('g:fugitive_git_command')
+    let git = s:GitCmd()
+  elseif type(g:fugitive_git_command) == type([])
+    let git = g:fugitive_git_command
+  else
+    let git = split(g:fugitive_git_command, '\s\+')
+  endif
+  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.git_dir
+  elseif a:0
+    let dir = s:GitDir(a:1)
+  else
+    let dir = ''
+  endif
+  if len(dir)
+    let tree = s:Tree(dir)
+    if empty(tree)
+      call add(git, '--git-dir=' . FugitiveGitPath(dir))
+    else
+      if !s:cpath(tree . '/.git', dir) || len($GIT_DIR)
+        call add(git, '--git-dir=' . FugitiveGitPath(dir))
+      endif
+      if !s:cpath(tree, getcwd())
+        call extend(git, ['-C', FugitiveGitPath(tree)])
+      endif
+    endif
+  endif
+  return git + flags
+endfunction
+
+let s:git_versions = {}
+function! fugitive#GitVersion(...) abort
+  let git = s:GitShellCmd()
+  if !has_key(s:git_versions, git)
+    let s:git_versions[git] = matchstr(get(s:JobExecute(s:GitCmd() + ['--version'], {}, [], [], {}).stdout, 0, ''), '\d[^[:space:]]\+')
+  endif
+  if !a:0
+    return s:git_versions[git]
+  endif
+  let components = split(s:git_versions[git], '\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
+
+function! s:Dir(...) abort
+  return a:0 ? FugitiveGitDir(a:1) : FugitiveGitDir()
+endfunction
+
+function! s:GitDir(...) abort
+  return a:0 ? FugitiveGitDir(a:1) : FugitiveGitDir()
+endfunction
+
+function! s:InitializeBuffer(repo) abort
+  let b:git_dir = s:GitDir(a:repo)
+endfunction
+
+function! s:SameRepo(one, two) abort
+  let one = s:GitDir(a:one)
+  return !empty(one) && one ==# s:GitDir(a:two)
+endfunction
+
+if exists('+shellslash')
+  function! s:DirUrlPrefix(dir) abort
+    let gd = s:GitDir(a:dir)
+    return 'fugitive://' . (gd =~# '^[^/]' ? '/' : '') . s:PathUrlEncode(gd) . '//'
+  endfunction
+else
+  function! s:DirUrlPrefix(dir) abort
+    return 'fugitive://' . s:PathUrlEncode(s:GitDir(a:dir)) . '//'
+  endfunction
+endif
+
+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, explicit) abort
+  if !a:explicit
+    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)
+        if a:literal
+          let a:cmd[i] = fugitive#Path(bufname(a:cmd[i]), './', a:dir)
+        else
+          let a:cmd[i] = fugitive#Path(bufname(a:cmd[i]), ':(top,literal)', a:dir)
+        endif
+      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)
+      if a:literal
+        let a:cmd[i] = fugitive#Path(bufname(a:cmd[i]), './', a:dir)
+      else
+        let a:cmd[i] = fugitive#Path(bufname(a:cmd[i]), ':(top,literal)', a:dir)
+      endif
+    elseif !a:explicit
+      let a:cmd[i] = fugitive#Path(a:cmd[i], './', a:dir)
+    endif
+  endfor
+  return a:cmd
+endfunction
+
+let s:git_index_file_env = {}
+function! s:GitIndexFileEnv() abort
+  if $GIT_INDEX_FILE =~# '^/\|^\a:' && !has_key(s:git_index_file_env, $GIT_INDEX_FILE)
+    let s:git_index_file_env[$GIT_INDEX_FILE] = s:Slash(FugitiveVimPath($GIT_INDEX_FILE))
+  endif
+  return get(s:git_index_file_env, $GIT_INDEX_FILE, '')
+endfunction
+
+function! s:PrepareEnv(env, dir) abort
+  if len($GIT_INDEX_FILE) && len(s:Tree(a:dir)) && !has_key(a:env, 'GIT_INDEX_FILE')
+    let index_dir = substitute(s:GitIndexFileEnv(), '[^/]\+$', '', '')
+    let our_dir = fugitive#Find('.git/', a:dir)
+    if !s:cpath(index_dir, our_dir) && !s:cpath(resolve(index_dir), our_dir)
+      let a:env['GIT_INDEX_FILE'] = FugitiveGitPath(fugitive#Find('.git/index', a:dir))
+    endif
+  endif
+  if len($GIT_WORK_TREE)
+    let a:env['GIT_WORK_TREE'] = '.'
+  endif
+endfunction
+
+let s:prepare_env = {
+      \ 'sequence.editor': 'GIT_SEQUENCE_EDITOR',
+      \ 'core.editor': 'GIT_EDITOR',
+      \ 'core.askpass': 'GIT_ASKPASS',
+      \ }
+function! fugitive#PrepareDirEnvGitFlagsArgs(...) abort
+  if !fugitive#GitVersion(1, 8, 5)
+    throw 'fugitive: Git 1.8.5 or higher required'
+  endif
+  let git = s:GitCmd()
+  if a:0 == 1 && type(a:1) == type({}) && (has_key(a:1, 'fugitive_dir') || has_key(a:1, 'git_dir')) && has_key(a:1, 'flags') && has_key(a:1, 'args')
+    let cmd = a:1.flags + a:1.args
+    let dir = s:Dir(a:1)
+    if has_key(a:1, 'git')
+      let git = a:1.git
+    endif
+    let env = get(a:1, 'env', {})
+  else
+    let list_args = []
+    let cmd = []
+    for l:.arg in a:000
+      if type(arg) ==# type([])
+        call extend(list_args, arg)
+      else
+        call add(cmd, arg)
+      endif
+    endfor
+    call extend(cmd, list_args)
+    let env = {}
+  endif
+  let autoenv = {}
+  let explicit_pathspec_option = 0
+  let literal_pathspecs = 1
+  let i = 0
+  let arg_count = 0
+  while i < len(cmd)
+    if type(cmd[i]) == type({})
+      if has_key(cmd[i], 'fugitive_dir') || has_key(cmd[i], 'git_dir')
+        let dir = s:Dir(cmd[i])
+      endif
+      if has_key(cmd[i], 'git')
+        let git = cmd[i].git
+      endif
+      if has_key(cmd[i], 'env')
+        call extend(env, cmd[i].env)
+      endif
+      call remove(cmd, i)
+    elseif cmd[i] =~# '^$\|[\/.]' && cmd[i] !~# '^-'
+      let dir = s:Dir(remove(cmd, i))
+    elseif cmd[i] =~# '^--git-dir='
+      let dir = s: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))
+        let var = s:prepare_env[tolower(key)]
+        let val = matchstr(cmd[i+1], '=\zs.*')
+        let autoenv[var] = val
+      endif
+      let i += 2
+    elseif cmd[i] =~# '^--.*pathspecs$'
+      let literal_pathspecs = (cmd[i] ==# '--literal-pathspecs')
+      let explicit_pathspec_option = 1
+      let i += 1
+    elseif cmd[i] !~# '^-'
+      let arg_count = len(cmd) - i
+      break
+    else
+      let i += 1
+    endif
+  endwhile
+  if !exists('dir')
+    let dir = s:Dir()
+  endif
+  call extend(autoenv, env)
+  call s:PrepareEnv(autoenv, dir)
+  if len($GPG_TTY) && !has_key(autoenv, 'GPG_TTY')
+    let autoenv.GPG_TTY = ''
+  endif
+  call s:PreparePathArgs(cmd, dir, literal_pathspecs, explicit_pathspec_option)
+  return [dir, env, extend(autoenv, env), git, cmd[0 : -arg_count-1], arg_count ? cmd[-arg_count : -1] : []]
+endfunction
+
+function! s:BuildEnvPrefix(env) abort
+  let pre = ''
+  let env = items(a:env)
+  if empty(env)
+    return ''
+  elseif &shell =~# '\%(powershell\|pwsh\)\%(\.exe\)\=$'
+    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 '/usr/bin/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('nvim') && api_info().version.api_level - api_info().version.api_prerelease >= 7 ||
+        \ has('patch-8.0.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 [['/usr/bin/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:PrepareJob(opts) abort
+  let dict = {'argv': a:opts.argv}
+  if has_key(a:opts, 'env')
+    let dict.env = a:opts.env
+  endif
+  let [argv, jopts] = s:JobOpts(a:opts.argv, get(a:opts, 'env', {}))
+  if has_key(a:opts, 'cwd')
+    if has('patch-8.0.0902')
+      let jopts.cwd = a:opts.cwd
+      let dict.cwd = a:opts.cwd
+    else
+      throw 'fugitive: cwd unsupported'
+    endif
+  endif
+  return [argv, jopts, dict]
+endfunction
+
+function! fugitive#PrepareJob(...) abort
+  if a:0 == 1 && type(a:1) == type({}) && has_key(a:1, 'argv') && !has_key(a:1, 'args')
+    return s:PrepareJob(a:1)
+  endif
+  let [repo, user_env, exec_env, git, flags, args] = call('fugitive#PrepareDirEnvGitFlagsArgs', a:000)
+  let dir = s:GitDir(repo)
+  let dict = {'git': git, 'git_dir': dir, 'flags': flags, 'args': args}
+  if len(user_env)
+    let dict.env = user_env
+  endif
+  let cmd = flags + args
+  let tree = s:Tree(repo)
+  if empty(tree) || index(cmd, '--') == len(cmd) - 1
+    let dict.cwd = getcwd()
+    call extend(cmd, ['--git-dir=' . FugitiveGitPath(dir)], 'keep')
+  else
+    let dict.cwd = s:VimSlash(tree)
+    call extend(cmd, ['-C', FugitiveGitPath(tree)], 'keep')
+    if !s:cpath(tree . '/.git', dir) || len($GIT_DIR)
+      call extend(cmd, ['--git-dir=' . FugitiveGitPath(dir)], 'keep')
+    endif
+  endif
+  call extend(cmd, git, 'keep')
+  return s:JobOpts(cmd, exec_env) + [dict]
+endfunction
+
+function! fugitive#Execute(...) abort
+  let cb = copy(a:000)
+  let cmd = []
+  let stdin = []
+  while len(cb) && type(cb[0]) !=# type(function('tr'))
+    if type(cb[0]) ==# type({}) && has_key(cb[0], 'stdin')
+      if type(cb[0].stdin) == type([])
+        call extend(stdin, cb[0].stdin)
+      elseif type(cb[0].stdin) == type('')
+        call extend(stdin, readfile(cb[0].stdin, 'b'))
+      endif
+      if len(keys(cb[0])) == 1
+        call remove(cb, 0)
+        continue
+      endif
+    endif
+    call add(cmd, remove(cb, 0))
+  endwhile
+  let [argv, jopts, dict] = call('fugitive#PrepareJob', cmd)
+  return s:JobExecute(argv, jopts, stdin, cb, dict)
+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))
+  else
+    call extend(cmd, ['-C', FugitiveGitPath(tree)], 'keep')
+    if !s:cpath(tree . '/.git', a:dir) || len($GIT_DIR)
+      call extend(cmd, ['--git-dir=' . FugitiveGitPath(a:dir)], 'keep')
+    endif
+  endif
+  return pre . join(map(a:git + cmd, 's:shellesc(v:val)'))
+endfunction
+
+function! s:JobNvimCallback(lines, job, data, type) abort
+  let a:lines[-1] .= remove(a:data, 0)
+  call extend(a:lines, a:data)
+endfunction
+
+function! s:SystemList(cmd) abort
+  let exit = []
+  if exists('*jobstart')
+    let lines = ['']
+    let jopts = {
+          \ 'on_stdout': function('s:JobNvimCallback', [lines]),
+          \ 'on_stderr': function('s:JobNvimCallback', [lines]),
+          \ 'on_exit': { j, code, _ -> add(exit, code) }}
+    let job = jobstart(a:cmd, jopts)
+    call chanclose(job, 'stdin')
+    call jobwait([job])
+    if empty(lines[-1])
+      call remove(lines, -1)
+    endif
+    return [lines, exit[0]]
+  elseif exists('*ch_close_in')
+    let lines = []
+    let jopts = {
+          \ 'out_cb': { j, str -> add(lines, str) },
+          \ 'err_cb': { j, str -> add(lines, str) },
+          \ 'exit_cb': { j, code -> add(exit, code) }}
+    let job = job_start(a:cmd, jopts)
+    call ch_close_in(job)
+    let sleep = has('patch-8.2.2366') ? 'sleep! 1m' : 'sleep 1m'
+    while ch_status(job) !~# '^closed$\|^fail$' || job_status(job) ==# 'run'
+      exe sleep
+    endwhile
+    return [lines, exit[0]]
+  else
+    let [output, exec_error] = s:SystemError(s:shellesc(a:cmd))
+    let lines = split(output, "\n", 1)
+    if empty(lines[-1])
+      call remove(lines, -1)
+    endif
+    return [lines, v:shell_error]
+  endif
+endfunction
+
+function! fugitive#ShellCommand(...) abort
+  let [repo, _, env, git, flags, args] = call('fugitive#PrepareDirEnvGitFlagsArgs', a:000)
+  return s:BuildShell(s:GitDir(repo), env, git, flags + args)
+endfunction
+
+function! s:SystemError(cmd, ...) abort
+  let cmd = type(a:cmd) == type([]) ? s:shellesc(a:cmd) : a:cmd
+  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', [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 `' . cmd . '` with ' . join(opts, ' '))
+  finally
+    if exists('shellredir')
+      let &shellredir = shellredir
+    endif
+    if exists('guioptions')
+      let &guioptions = guioptions
+    endif
+  endtry
+endfunction
+
+function! s:ChompStderr(...) abort
+  let r = call('fugitive#Execute', a:000)
+  return !r.exit_status ? '' : len(r.stderr) > 1 ? s:JoinChomp(r.stderr) : 'unknown Git error' . string(r)
+endfunction
+
+function! s:ChompDefault(default, ...) abort
+  let r = call('fugitive#Execute', a:000)
+  return r.exit_status ? a:default : s:JoinChomp(r.stdout)
+endfunction
+
+function! s:LinesError(...) abort
+  let r = call('fugitive#Execute', a:000)
+  if empty(r.stdout[-1])
+    call remove(r.stdout, -1)
+  endif
+  return [r.exit_status ? [] : r.stdout, r.exit_status]
+endfunction
+
+function! s:NullError(cmd) abort
+  let r = fugitive#Execute(a:cmd)
+  let list = r.exit_status ? [] : split(tr(join(r.stdout, "\1"), "\1\n", "\n\1"), "\1", 1)[0:-2]
+  return [list, s:JoinChomp(r.stderr), r.exit_status]
+endfunction
+
+function! s:TreeChomp(...) abort
+  let r = call('fugitive#Execute', a:000)
+  if !r.exit_status
+    return s:JoinChomp(r.stdout)
+  endif
+  throw 'fugitive: error running `' . call('fugitive#ShellCommand', a:000) . '`: ' . s:JoinChomp(r.stderr)
+endfunction
+
+function! s:StdoutToFile(out, cmd, ...) abort
+  let [argv, jopts, _] = fugitive#PrepareJob(a:cmd)
+  let exit = []
+  if exists('*jobstart')
+    call extend(jopts, {
+          \ 'stdout_buffered': v:true,
+          \ 'stderr_buffered': v:true,
+          \ 'on_exit': { j, code, _ -> add(exit, code) }})
+    let job = jobstart(argv, jopts)
+    if a:0
+      call chansend(job, a:1)
+    endif
+    call chanclose(job, 'stdin')
+    call jobwait([job])
+    if len(a:out)
+      call writefile(jopts.stdout, a:out, 'b')
+    endif
+    return [join(jopts.stderr, "\n"), exit[0]]
+  elseif exists('*ch_close_in')
+    try
+      let err = tempname()
+      call extend(jopts, {
+            \ 'out_io': len(a:out) ? 'file' : 'null',
+            \ 'out_name': a:out,
+            \ 'err_io': 'file',
+            \ 'err_name': err,
+            \ 'exit_cb': { j, code -> add(exit, code) }})
+      let job = job_start(argv, jopts)
+      if a:0
+        call ch_sendraw(job, a:1)
+      endif
+      call ch_close_in(job)
+      while ch_status(job) !~# '^closed$\|^fail$' || job_status(job) ==# 'run'
+        exe has('patch-8.2.2366') ? 'sleep! 1m' : 'sleep 1m'
+      endwhile
+      return [join(readfile(err, 'b'), "\n"), exit[0]]
+    finally
+      call delete(err)
+    endtry
+  elseif s:winshell() || &shell !~# 'sh' || &shell =~# 'fish\|\%(powershell\|pwsh\)\%(\.exe\)\=$'
+    throw 'fugitive: Vim 8 or higher required to use ' . &shell
+  else
+    let cmd = fugitive#ShellCommand(a:cmd)
+    return s:SystemError(' (' . cmd . ' >' . a:out . ') ')
+  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 = FugitiveActualDir(dir) . '/HEAD'
+  let ftime = getftime(file)
+  if ftime == -1
+    return ''
+  elseif ftime != get(s:head_cache, file, [-1])[0]
+    let s:head_cache[file] = [ftime, readfile(file)[0]]
+  endif
+  let head = s:head_cache[file][1]
+  let len = a:0 ? a:1 : 0
+  if head =~# '^ref: '
+    if len < 0
+      return strpart(head, 5)
+    else
+      return substitute(head, '\C^ref: \%(refs/\%(heads/\|remotes/\|tags/\)\=\)\=', '', '')
+    endif
+  elseif head =~# '^\x\{40,\}$'
+    return len < 0 ? head : strpart(head, 0, len)
+  else
+    return ''
+  endif
+endfunction
+
+function! fugitive#RevParse(rev, ...) abort
+  let hash = s:ChompDefault('', [a:0 ? a:1 : s:Dir(), 'rev-parse', '--verify', a:rev, '--'])
+  if hash =~# '^\x\{40,\}$'
+    return hash
+  endif
+  throw 'fugitive: failed to parse revision ' . a:rev
+endfunction
+
+" Section: Git config
+
+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
+
+function! s:ConfigCallback(r, into) abort
+  let dict = a:into[1]
+  if has_key(dict, 'job')
+    call remove(dict, 'job')
+  endif
+  let lines = a:r.exit_status ? [] : split(tr(join(a:r.stdout, "\1"), "\1\n", "\n\1"), "\1", 1)[0:-2]
+  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 callbacks = remove(dict, 'callbacks')
+  lockvar! dict
+  let a:into[0] = s:ConfigTimestamps(dict.git_dir, dict)
+  for callback in callbacks
+    call call(callback[0], [dict] + callback[1:-1])
+  endfor
+endfunction
+
+let s:config_prototype = {}
+
+let s:config = {}
+function! fugitive#ExpireConfig(...) abort
+  if !a:0 || a:1 is# 0
+    let s:config = {}
+  else
+    let key = a:1 is# '' ? '_' : s:GitDir(a:0 ? a:1 : -1)
+    if len(key) && has_key(s:config, key)
+      call remove(s:config, key)
+    endif
+  endif
+endfunction
+
+function! fugitive#Config(...) abort
+  let name = ''
+  let default = get(a:, 3, '')
+  if a:0 && type(a:1) == type(function('tr'))
+    let dir = s:Dir()
+    let callback = a:000
+  elseif a:0 > 1 && type(a:2) == type(function('tr'))
+    if type(a:1) == type({}) && has_key(a:1, 'GetAll')
+      if has_key(a:1, 'callbacks')
+        call add(a:1.callbacks, a:000[1:-1])
+      else
+        call call(a:2, [a:1] + a:000[2:-1])
+      endif
+      return a:1
+    else
+      let dir = s:Dir(a:1)
+      let callback = a:000[1:-1]
+    endif
+  elseif a:0 >= 2 && type(a:2) == type({}) && has_key(a:2, 'GetAll')
+    return get(fugitive#ConfigGetAll(a:1, a:2), 0, default)
+  elseif a:0 >= 2
+    let dir = s:Dir(a:2)
+    let name = a:1
+  elseif a:0 == 1 && type(a:1) == type({}) && has_key(a:1, 'GetAll')
+    return a:1
+  elseif a:0 == 1 && type(a:1) == type('') && a:1 =~# '^[[:alnum:]-]\+\.'
+    let dir = s:Dir()
+    let name = a:1
+  elseif a:0 == 1
+    let dir = s:Dir(a:1)
+  else
+    let dir = s:Dir()
+  endif
+  let name = substitute(name, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+  let git_dir = s:GitDir(dir)
+  let dir_key = len(git_dir) ? git_dir : '_'
+  let [ts, dict] = get(s:config, dir_key, ['new', {}])
+  if !has_key(dict, 'job') && ts !=# s:ConfigTimestamps(git_dir, dict)
+    let dict = copy(s:config_prototype)
+    let dict.git_dir = git_dir
+    let into = ['running', dict]
+    let dict.callbacks = []
+    let exec = fugitive#Execute([dir, 'config', '--list', '-z', '--'], function('s:ConfigCallback'), into)
+    if has_key(exec, 'job')
+      let dict.job = exec.job
+    endif
+    let s:config[dir_key] = into
+  endif
+  if !exists('l:callback')
+    call fugitive#Wait(dict)
+  elseif has_key(dict, 'callbacks')
+    call add(dict.callbacks, callback)
+  else
+    call call(callback[0], [dict] + callback[1:-1])
+  endif
+  return len(name) ? get(fugitive#ConfigGetAll(name, dict), 0, default) : dict
+endfunction
+
+function! fugitive#ConfigGetAll(name, ...) abort
+  if a:0 && (type(a:name) !=# type('') || a:name !~# '^[[:alnum:]-]\+\.' && type(a:1) ==# type('') && a:1 =~# '^[[:alnum:]-]\+\.')
+    let config = fugitive#Config(a:name)
+    let name = a:1
+  else
+    let config = fugitive#Config(a:0 ? a:1 : s:Dir())
+    let name = a:name
+  endif
+  let name = substitute(name, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+  call fugitive#Wait(config)
+  return name =~# '\.' ? copy(get(config, name, [])) : []
+endfunction
+
+function! fugitive#ConfigGetRegexp(pattern, ...) abort
+  if type(a:pattern) !=# type('')
+    let config = fugitive#Config(a:name)
+    let pattern = a:0 ? a:1 : '.*'
+  else
+    let config = fugitive#Config(a:0 ? a:1 : s:Dir())
+    let pattern = a:pattern
+  endif
+  call fugitive#Wait(config)
+  let filtered = map(filter(copy(config), 'v:key =~# "\\." && v:key =~# pattern'), 'copy(v:val)')
+  if pattern !~# '\\\@<!\%(\\\\\)*\\z[se]'
+    return filtered
+  endif
+  let transformed = {}
+  for [k, v] in items(filtered)
+    let k = matchstr(k, pattern)
+    if len(k)
+      let transformed[k] = v
+    endif
+  endfor
+  return transformed
+endfunction
+
+function! s:config_GetAll(name) dict abort
+  let name = substitute(a:name, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+  call fugitive#Wait(self)
+  return name =~# '\.' ? copy(get(self, name, [])) : []
+endfunction
+
+function! s:config_Get(name, ...) dict abort
+  return get(self.GetAll(a:name), 0, a:0 ? a:1 : '')
+endfunction
+
+function! s:config_GetRegexp(pattern) dict abort
+  return fugitive#ConfigGetRegexp(self, a:pattern)
+endfunction
+
+call s:add_methods('config', ['GetAll', 'Get', 'GetRegexp'])
+
+function! s:RemoteDefault(dir) abort
+  let head = FugitiveHead(0, a:dir)
+  let remote = len(head) ? FugitiveConfigGet('branch.' . head . '.remote', a:dir) : ''
+  let i = 10
+  while remote ==# '.' && i > 0
+    let head = matchstr(FugitiveConfigGet('branch.' . head . '.merge', a:dir), 'refs/heads/\zs.*')
+    let remote = len(head) ? FugitiveConfigGet('branch.' . head . '.remote', a:dir) : ''
+    let i -= 1
+  endwhile
+  return remote =~# '^\.\=$' ? 'origin' : remote
+endfunction
+
+function! s:SshParseHost(value) abort
+  let patterns = []
+  let negates = []
+  for host in split(a:value, '\s\+')
+    let pattern = substitute(host, '[\\^$.*~?]', '\=submatch(0) == "*" ? ".*" : submatch(0) == "?" ? "." : "\\" . submatch(0)', 'g')
+    if pattern[0] ==# '!'
+      call add(negates, '\&\%(^' . pattern[1 : -1] . '$\)\@!')
+    else
+      call add(patterns, pattern)
+    endif
+  endfor
+  return '^\%(' . join(patterns, '\|') . '\)$' . join(negates, '')
+endfunction
+
+function! s:SshParseConfig(into, root, file, ...) abort
+  if !filereadable(a:file)
+    return a:into
+  endif
+  let host = a:0 ? a:1 : '^\%(.*\)$'
+  for line in readfile(a:file)
+    let key = tolower(matchstr(line, '^\s*\zs\w\+\ze\s'))
+    let value = matchstr(line, '^\s*\w\+\s\+\zs.*\S')
+    if key ==# 'match'
+      let host = value ==# 'all' ? '^\%(.*\)$' : ''
+    elseif key ==# 'host'
+      let host = s:SshParseHost(value)
+    elseif key ==# 'include'
+      call s:SshParseInclude(a:into, a:root, host, value)
+    elseif len(key) && len(host)
+      call extend(a:into, {key : []}, 'keep')
+      call add(a:into[key], [host, value])
+    endif
+  endfor
+  return a:into
+endfunction
+
+function! s:SshParseInclude(into, root, host, value) abort
+  for glob in split(a:value)
+    if glob !~# '^/'
+      let glob = a:root . glob
+    endif
+    for file in split(glob(glob), "\n")
+      call s:SshParseConfig(a:into, a:root, file, a:host)
+    endfor
+  endfor
+endfunction
+
+unlet! s:ssh_config
+function! fugitive#SshConfig(host, ...) abort
+  if !exists('s:ssh_config')
+    let s:ssh_config = {}
+    for file in [expand("~/.ssh/config"), "/etc/ssh/ssh_config"]
+      call s:SshParseConfig(s:ssh_config, substitute(file, '\w*$', '', ''), file)
+    endfor
+  endif
+  let host_config = {}
+  for key in a:0 ? a:1 : keys(s:ssh_config)
+    for [host_pattern, value] in get(s:ssh_config, key, [])
+      if a:host =~# host_pattern
+        let host_config[key] = value
+        break
+      endif
+    endfor
+  endfor
+  return host_config
+endfunction
+
+function! fugitive#SshHostAlias(authority) abort
+  let [_, user, host, port; __] = matchlist(a:authority, '^\%(\([^/@]\+\)@\)\=\(.\{-\}\)\%(:\(\d\+\)\)\=$')
+  let c = fugitive#SshConfig(host, ['user', 'hostname', 'port'])
+  if empty(user)
+    let user = get(c, 'user', '')
+  endif
+  if empty(port)
+    let port = get(c, 'port', '')
+  endif
+  return (len(user) ? user . '@' : '') . get(c, 'hostname', host) . (port =~# '^\%(22\)\=$' ? '' : ':' . port)
+endfunction
+
+function! s:CurlResponse(result) abort
+  let a:result.headers = {}
+  for line in a:result.exit_status ? [] : remove(a:result, 'stdout')
+    let header = matchlist(line, '^\([[:alnum:]-]\+\):\s\(.\{-\}\)'. "\r\\=$")
+    if len(header)
+      let k = tolower(header[1])
+      if has_key(a:result.headers, k)
+        let a:result.headers[k] .= ', ' . header[2]
+      else
+        let a:result.headers[k] = header[2]
+      endif
+    elseif empty(line)
+      break
+    endif
+  endfor
+endfunction
+
+let s:remote_headers = {}
+
+function! fugitive#RemoteHttpHeaders(remote) abort
+  let remote = type(a:remote) ==# type({}) ? get(a:remote, 'remote', '') : a:remote
+  if type(remote) !=# type('') || remote !~# '^https\=://.' || !s:executable('curl')
+    return {}
+  endif
+  let remote = substitute(remote, '#.*', '', '')
+  if !has_key(s:remote_headers, remote)
+    let url = remote . '/info/refs?service=git-upload-pack'
+    let exec = s:JobExecute(
+          \ ['curl', '--disable', '--silent', '--max-time', '5', '-X', 'GET', '-I',
+          \ url], {}, [], [function('s:CurlResponse')], {})
+    call fugitive#Wait(exec)
+    let s:remote_headers[remote] = exec.headers
+  endif
+  return s:remote_headers[remote]
+endfunction
+
+function! s:UrlParse(url) abort
+  let scp_authority = matchstr(a:url, '^[^:/]\+\ze:\%(//\)\@!')
+  if len(scp_authority) && !(has('win32') && scp_authority =~# '^\a:[\/]')
+    let url = {'scheme': 'ssh', 'authority': s:UrlEncode(scp_authority), 'hash': '',
+          \ 'path': s:UrlEncode(strpart(a:url, len(scp_authority) + 1))}
+  elseif empty(a:url)
+    let url = {'scheme': '', 'authority': '', 'path': '', 'hash': ''}
+  else
+    let match = matchlist(a:url, '^\([[:alnum:].+-]\+\)://\([^/]*\)\(/[^#]*\)\=\(#.*\)\=$')
+    if empty(match)
+      let url = {'scheme': 'file', 'authority': '', 'hash': '',
+            \ 'path': s:UrlEncode(a:url)}
+    else
+      let url = {'scheme': match[1], 'authority': match[2], 'hash': match[4]}
+      let url.path = empty(match[3]) ? '/' : match[3]
+    endif
+  endif
+  return url
+endfunction
+
+function! s:UrlPopulate(string, into) abort
+  let url = a:into
+  let url.protocol = substitute(url.scheme, '.\zs$', ':', '')
+  let url.user = fugitive#UrlDecode(matchstr(url.authority, '.\{-\}\ze@', '', ''))
+  let url.host = substitute(url.authority, '.\{-\}@', '', '')
+  let url.hostname = substitute(url.host, ':\d\+$', '', '')
+  let url.port = matchstr(url.host, ':\zs\d\+$', '', '')
+  let url.origin = substitute(url.scheme, '.\zs$', '://', '') . url.host
+  let url.search = matchstr(url.path, '?.*')
+  let url.pathname = '/' . matchstr(url.path, '^/\=\zs[^?]*')
+  if (url.scheme ==# 'ssh' || url.scheme ==# 'git') && url.path[0:1] ==# '/~'
+    let url.path = strpart(url.path, 1)
+  endif
+  if url.path =~# '^/'
+    let url.href = url.scheme . '://' . url.authority . url.path . url.hash
+  elseif url.path =~# '^\~'
+    let url.href = url.scheme . '://' . url.authority . '/' . url.path . url.hash
+  elseif url.scheme ==# 'ssh' && url.authority !~# ':'
+    let url.href = url.authority . ':' . url.path . url.hash
+  else
+    let url.href = a:string
+  endif
+  let url.path = fugitive#UrlDecode(matchstr(url.path, '^[^?]*'))
+  let url.url = matchstr(url.href, '^[^#]*')
+endfunction
+
+function! s:RemoteResolve(url, flags) abort
+  let remote = s:UrlParse(a:url)
+  if remote.scheme =~# '^https\=$' && index(a:flags, ':nohttp') < 0
+    let headers = fugitive#RemoteHttpHeaders(a:url)
+    let loc = matchstr(get(headers, 'location', ''), '^https\=://.\{-\}\ze/info/refs?')
+    if len(loc)
+      let remote = s:UrlParse(loc)
+    else
+      let remote.headers = headers
+    endif
+  elseif remote.scheme ==# 'ssh'
+    let remote.authority = fugitive#SshHostAlias(remote.authority)
+  endif
+  return remote
+endfunction
+
+function! s:ConfigLengthSort(i1, i2) abort
+  return len(a:i2[0]) - len(a:i1[0])
+endfunction
+
+function! s:RemoteCallback(config, into, flags, cb) abort
+  if a:into.remote_name =~# '^\.\=$'
+    let a:into.remote_name = s:RemoteDefault(a:config)
+  endif
+  let url = a:into.remote_name
+
+  if url ==# '.git'
+    let url = s:GitDir(a:config)
+  elseif url !~# ':\|^/\|^\a:[\/]\|^\.\.\=/'
+    let url = FugitiveConfigGet('remote.' . url . '.url', a:config)
+  endif
+  let instead_of = []
+  for [k, vs] in items(fugitive#ConfigGetRegexp('^url\.\zs.\{-\}\ze\.insteadof$', a:config))
+    for v in vs
+      call add(instead_of, [v, k])
+    endfor
+  endfor
+  call sort(instead_of, 's:ConfigLengthSort')
+  for [orig, replacement] in instead_of
+    if strpart(url, 0, len(orig)) ==# orig
+      let url = replacement . strpart(url, len(orig))
+      break
+    endif
+  endfor
+  if index(a:flags, ':noresolve') < 0
+    call extend(a:into, s:RemoteResolve(url, a:flags))
+  else
+    call extend(a:into, s:UrlParse(url))
+  endif
+  call s:UrlPopulate(url, a:into)
+  if len(a:cb)
+    call call(a:cb[0], [a:into] + a:cb[1:-1])
+  endif
+endfunction
+
+function! s:Remote(dir, remote, flags, cb) abort
+  let into = {'remote_name': a:remote, 'git_dir': s:GitDir(a:dir)}
+  let config = fugitive#Config(a:dir, function('s:RemoteCallback'), into, a:flags, a:cb)
+  if len(a:cb)
+    return config
+  else
+    call fugitive#Wait(config)
+    return into
+  endif
+endfunction
+
+function! s:RemoteParseArgs(args) abort
+  " Extract ':noresolve' style flags and an optional callback
+  let args = []
+  let flags = []
+  let cb = copy(a:args)
+  while len(cb)
+    if type(cb[0]) ==# type(function('tr'))
+      break
+    elseif len(args) > 1 || type(cb[0]) ==# type('') && cb[0] =~# '^:'
+      call add(flags, remove(cb, 0))
+    else
+      call add(args, remove(cb, 0))
+    endif
+  endwhile
+
+  " From the remaining 0-2 arguments, extract the remote and Git config
+  let remote = ''
+  if empty(args)
+    let dir_or_config = s:Dir()
+  elseif len(args) == 1 && type(args[0]) ==# type('') && args[0] !~# '^/\|^\a:[\\/]'
+    let dir_or_config = s:Dir()
+    let remote = args[0]
+  elseif len(args) == 1
+    let dir_or_config = args[0]
+    if type(args[0]) ==# type({}) && has_key(args[0], 'remote_name')
+      let remote = args[0].remote_name
+    endif
+  elseif type(args[1]) !=# type('') || args[1] =~# '^/\|^\a:[\\/]'
+    let dir_or_config = args[1]
+    let remote = args[0]
+  else
+    let dir_or_config = args[0]
+    let remote = args[1]
+  endif
+  return [dir_or_config, remote, flags, cb]
+endfunction
+
+function! fugitive#Remote(...) abort
+  let [dir_or_config, remote, flags, cb] = s:RemoteParseArgs(a:000)
+  return s:Remote(dir_or_config, remote, flags, cb)
+endfunction
+
+function! s:RemoteUrlCallback(remote, callback) abort
+  return call(a:callback[0], [a:remote.url] + a:callback[1:-1])
+endfunction
+
+function! fugitive#RemoteUrl(...) abort
+  let [dir_or_config, remote_url, flags, cb] = s:RemoteParseArgs(a:000)
+  if len(cb)
+    let cb = [function('s:RemoteUrlCallback'), cb]
+  endif
+  let remote = s:Remote(dir_or_config, remote_url, flags, cb)
+  return get(remote, 'url', remote_url)
+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:QuickfixOpen(nr, mods) abort
+  let mods = substitute(s:Mods(a:mods), '\<tab\>', '', '')
+  return mods . (a:nr < 0 ? 'c' : 'l').'open' . (mods =~# '\<vertical\>' ? ' 20' : '')
+endfunction
+
+function! s:QuickfixStream(nr, event, title, cmd, first, mods, callback, ...) abort
+  call s:BlurStatus()
+  let opts = {'title': a:title, 'context': {'items': []}}
+  call s:QuickfixCreate(a:nr, opts)
+  let event = (a:nr < 0 ? 'c' : 'l') . 'fugitive-' . a:event
+  exe s:DoAutocmd('QuickFixCmdPre ' . event)
+  let winnr = winnr()
+  exe s:QuickfixOpen(a:nr, a:mods)
+  if winnr != winnr()
+    wincmd p
+  endif
+
+  let buffer = []
+  let lines = s:SystemList(a:cmd)[0]
+  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 a: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')
+
+  exe s:DoAutocmd('QuickFixCmdPost ' . event)
+  if a:first && len(s:QuickfixGet(a:nr))
+    return (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
+
+let s:repo_prototype = {}
+
+function! fugitive#repo(...) abort
+  let dir = a:0 ? s:GitDir(a:1) : (len(s:GitDir()) ? s:GitDir() : FugitiveExtractGitDir(expand('%:p')))
+  if dir !=# ''
+    return extend({'git_dir': dir, 'fugitive_dir': dir}, s:repo_prototype, 'keep')
+  endif
+  throw 'fugitive: not a Git repository'
+endfunction
+
+function! s:repo_dir(...) dict abort
+  if !a:0
+    return self.git_dir
+  endif
+  throw 'fugitive: fugitive#repo().dir("...") has been replaced by FugitiveFind(".git/...")'
+endfunction
+
+function! s:repo_tree(...) dict abort
+  let tree = s:Tree(self.git_dir)
+  if empty(tree)
+    throw 'fugitive: no work tree'
+  elseif !a:0
+    return tree
+  endif
+  throw 'fugitive: fugitive#repo().tree("...") has been replaced by FugitiveFind(":(top)...")'
+endfunction
+
+function! s:repo_bare() dict abort
+  throw 'fugitive: fugitive#repo().bare() has been replaced by !empty(FugitiveWorkTree())'
+endfunction
+
+function! s:repo_find(object) dict abort
+  throw 'fugitive: fugitive#repo().find(...) has been replaced by FugitiveFind(...)'
+endfunction
+
+function! s:repo_translate(rev) dict abort
+  throw 'fugitive: fugitive#repo().translate(...) has been replaced by FugitiveFind(...)'
+endfunction
+
+function! s:repo_head(...) dict abort
+  throw 'fugitive: fugitive#repo().head(...) has been replaced by FugitiveHead(...)'
+endfunction
+
+call s:add_methods('repo',['dir','tree','bare','find','translate','head'])
+
+function! s:repo_git_command(...) dict abort
+  throw 'fugitive: fugitive#repo().git_command(...) has been replaced by FugitiveShellCommand(...)'
+endfunction
+
+function! s:repo_git_chomp(...) dict abort
+  silent return substitute(system(fugitive#ShellCommand(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
+  throw 'fugitive: fugitive#repo().rev_parse(...) has been replaced by FugitiveExecute("rev-parse", "--verify", ...).stdout'
+endfunction
+
+call s:add_methods('repo',['git_command','git_chomp','git_chomp_in_tree','rev_parse'])
+
+function! s:repo_config(name) dict abort
+  return FugitiveConfigGet(a:name, self.git_dir)
+endfunction
+
+call s:add_methods('repo',['config'])
+
+" Section: File API
+
+function! s:DirCommitFile(path) abort
+  let vals = matchlist(s:Slash(a:path), s:dir_commit_file)
+  if empty(vals)
+    return ['', '', '']
+  endif
+  return [s:Dir(fugitive#UrlDecode(vals[1])), vals[2], empty(vals[2]) ? '/.git/index' : fugitive#UrlDecode(vals[3])]
+endfunction
+
+function! s:DirRev(url) abort
+  let [dir, commit, file] = s:DirCommitFile(a:url)
+  return [dir, commit . file ==# '/.git/index' ? ':' : (!empty(dir) && commit =~# '^.$' ? ':' : '') . commit . substitute(file, '^/', ':', '')]
+endfunction
+
+function! fugitive#Parse(url) abort
+  return reverse(s:DirRev(a:url))
+endfunction
+
+let s:merge_heads = ['MERGE_HEAD', 'REBASE_HEAD', 'CHERRY_PICK_HEAD', 'REVERT_HEAD']
+function! s:MergeHead(dir) abort
+  let dir = fugitive#Find('.git/', a: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 ? s:Dir(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:SameRepo(dir, pdir)
+    if commit =~# '^\x\{40,\}$'
+      return commit
+    elseif commit ==# '2'
+      return '@'
+    elseif commit ==# '0'
+      return ''
+    endif
+    let merge_head = s:MergeHead(dir)
+    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 s:VimSlash((len(tree) ? tree : s:GitDir(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 s:VimSlash(empty(url) ? a:url : url)
+endfunction
+
+function! fugitive#Path(url, ...) abort
+  if empty(a:url)
+    return ''
+  endif
+  let repo = call('s:Dir', a:000[1:-1])
+  let dir_s = fugitive#Find('.git/', repo)
+  let tree = fugitive#Find(':/', repo)
+  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(url)
+  if !empty(argdir) && !s:SameRepo(argdir, repo)
+    let file = ''
+  elseif len(dir_s) && s:cpath(strpart(url, 0, len(dir_s)), dir_s)
+    let file = '/.git' . strpart(url, len(dir_s)-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 s:VimSlash(name =~# '^$\|^/\|^\a\+:' ? name : getcwd() . '/' . name)
+  elseif a:object =~# '^[~$]'
+    let prefix = matchstr(a:object, '^[~$]\i*')
+    let owner = expand(prefix)
+    return s:VimSlash(FugitiveVimPath((len(owner) ? owner : prefix) . strpart(a:object, len(prefix))))
+  endif
+  let rev = s:Slash(a:object)
+  if rev =~# '^\a\+://' && rev !~# '^fugitive:'
+    return rev
+  elseif rev =~# '^$\|^/\|^\%(\a\a\+:\).*\%(//\|::\)' . (has('win32') ? '\|^\a:/' : '')
+    return s:VimSlash(a:object)
+  elseif rev =~# '^\.\.\=\%(/\|$\)'
+    return s:VimSlash(simplify(getcwd() . '/' . a:object))
+  endif
+  let dir = call('s:GitDir', a:000)
+  if empty(dir)
+    let file = matchstr(a:object, '^\%(:\d:\|[^:]*:\)\zs\%(\.\.\=$\|\.\.\=/.*\|/.*\|\w:/.*\)')
+    let dir = FugitiveExtractGitDir(file)
+    if empty(dir)
+      return ''
+    endif
+  endif
+  let tree = s:Tree(dir)
+  let urlprefix = s:DirUrlPrefix(dir)
+  let base = len(tree) ? tree : urlprefix . '0'
+  if rev ==# '.git'
+    let f = len(tree) && len(getftype(tree . '/.git')) ? tree . '/.git' : dir
+  elseif rev =~# '^\.git/'
+    let f = strpart(rev, 5)
+    let fdir = simplify(FugitiveActualDir(dir) . '/')
+    let cdir = simplify(FugitiveCommonDir(dir) . '/')
+    if f =~# '^\.\./\.\.\%(/\|$\)'
+      let f = simplify(len(tree) ? tree . f[2:-1] : fdir . f)
+    elseif f =~# '^\.\.\%(/\|$\)'
+      let f = s:PathJoin(base, f[2:-1])
+    elseif cdir !=# fdir && (
+          \ f =~# '^\%(config\|hooks\|info\|logs/refs\|objects\|refs\|worktrees\)\%(/\|$\)' ||
+          \ f !~# '^\%(index$\|index\.lock$\|\w*MSG$\|\w*HEAD$\|logs/\w*HEAD$\|logs$\|rebase-\w\+\)\%(/\|$\)' &&
+          \ getftime(fdir . f) < 0 && getftime(cdir . f) >= 0)
+      let f = simplify(cdir . f)
+    else
+      let f = simplify(fdir . f)
+    endif
+  elseif rev ==# ':/'
+    let f = tree
+  elseif rev =~# '^\.\%(/\|$\)'
+    let f = s:PathJoin(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 = s:PathJoin(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 = s:PathJoin(urlprefix, +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 = s:PathJoin(urlprefix, rev[1] . '/' . rev[3:-1])
+  elseif rev ==# ':'
+    let f = urlprefix
+  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 = s:PathJoin(base, '/' . f)
+    endif
+  elseif rev =~# '^:/\@!'
+    let f = s:PathJoin(urlprefix, '0/' . rev[1:-1])
+  else
+    if !exists('f')
+      let commit = matchstr(rev, '^\%([^:.-]\|\.\.[^/:]\)[^:]*\|^:.*')
+      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')
+        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 = s:PathJoin(urlprefix, commit . file)
+      else
+        let f = s:PathJoin(base, '/' . substitute(rev, '^:/:\=\|^[^:]\+:', '', ''))
+      endif
+    endif
+  endif
+  return s:VimSlash(f)
+endfunction
+
+function! s:Generate(object, ...) abort
+  let dir = a:0 ? a:1 : s:Dir()
+  let f = fugitive#Find(a:object, dir)
+  if !empty(f)
+    return f
+  elseif a:object ==# ':/'
+    return len(dir) ? s:VimSlash(s:DirUrlPrefix(dir) . '0') : '.'
+  endif
+  let file = matchstr(a:object, '^\%(:\d:\|[^:]*:\)\=\zs.*')
+  return empty(file) ? '' : fnamemodify(s:VimSlash(file), ':p')
+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 ? s:Dir(a:2) : s:Dir()
+  let [fdir, rev] = s:DirRev(a:0 ? a:1 : @%)
+  if !s:SameRepo(dir, fdir)
+    let rev = ''
+  endif
+  let tree = s:Tree(dir)
+  let full = a:0 ? a:1 : s:BufName('%')
+  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 = '\%(<\%(cword\|cWORD\|cexpr\|cfile\|sfile\|slnum\|afile\|abuf\|amatch' . (has('clientserver') ? '\|client' : '') . '\)>\|%\|#<\=\d\+\|##\=\)'
+let s:flag = '\%(:[p8~.htre]\|:g\=s\(.\).\{-\}\1.\{-\}\1\)'
+let s:expand = '\%(\(' . s:var . '\)\(' . s:flag . '*\)\(:S\)\=\)'
+let s:commit_expand = '!\\\@!#\=\d*\|!%'
+
+function! s:BufName(var) abort
+  if a:var ==# '%'
+    return bufname(get(s:TempState(), 'origin_bufnr', ''))
+  elseif a:var =~# '^#\d*$'
+    let nr = get(s:TempState(+a:var[1:-1]), 'origin_bufnr', '')
+    return bufname(nr ? nr : +a:var[1:-1])
+  else
+    return expand(a:var)
+  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 substitute(a:other[1:-2], "''", "'", "g")
+  elseif a:other =~# '^"'
+    return substitute(a:other[1:-2], '""', '"', "g")
+  elseif a:other =~# '^[!`]'
+    let buffer = s:BufName(a:other =~# '[0-9#]' ? '#' . matchstr(a:other, '\d\+') : '%')
+    let owner = s:Owner(buffer)
+    return len(owner) ? owner : '@'
+  elseif a:other =~# '^\~[~.]$'
+    return s:Slash(getcwd())
+  elseif len(a:other)
+    return expand(a:other)
+  elseif a:var ==# '<cfile>'
+    let bufnames = [expand('<cfile>')]
+    if get(maparg('<Plug><cfile>', 'c', 0, 1), 'expr')
+      try
+        let bufnames = [eval(maparg('<Plug><cfile>', 'c'))]
+        if bufnames[0] ==# "\<C-R>\<C-F>"
+          let bufnames = [expand('<cfile>')]
+        endif
+      catch
+      endtry
+    endif
+  elseif a:var =~# '^<'
+    let bufnames = [s:BufName(a:var)]
+  elseif a:var ==# '##'
+    let bufnames = map(argv(), 'fugitive#Real(v:val)')
+  else
+    let bufnames = [fugitive#Real(s:BufName(a:var))]
+  endif
+  let files = []
+  for bufname in bufnames
+    let flags = a:flags
+    let file = s:DotRelative(bufname, cwd)
+    while len(flags)
+      let flag = matchstr(flags, s:flag)
+      let flags = strpart(flags, len(flag))
+      if flag ==# ':.'
+        let file = s:DotRelative(fugitive#Real(file), cwd)
+      else
+        let file = fnamemodify(file, flag)
+      endif
+    endwhile
+    let file = s:Slash(file)
+    if file =~# '^fugitive://'
+      let [dir, commit, file_candidate] = s:DirCommitFile(file)
+      let tree = s:Tree(dir)
+      if len(tree) && len(file_candidate)
+        let file = (commit =~# '^.$' ? ':' : '') . commit . ':' .
+              \ s:DotRelative(tree . file_candidate)
+      elseif empty(file_candidate) && commit !~# '^.$'
+        let file = commit
+      endif
+    endif
+    call add(files, len(a:esc) ? shellescape(file) : file)
+  endfor
+  return join(files, "\1")
+endfunction
+
+if has('win32')
+  let s:fnameescape = " \t\n*?`%#'\"|!<"
+else
+  let s:fnameescape = " \t\n*?[{`$\\%#'\"|!<"
+endif
+
+function! s:Expand(rev, ...) abort
+  if a:rev =~# '^>' && s:Slash(@%) =~# '^fugitive://' && empty(s:DirCommitFile(@%)[1])
+    return s:Slash(@%)
+  elseif a:rev =~# '^>\=:[0-3]$'
+    let file = len(expand('%')) ? a:rev[-2:-1] . ':%' : '%'
+  elseif a:rev =~# '^>\%(:\=/\)\=$'
+    let file = '%'
+  elseif a:rev =~# '^>[> ]\@!' && @% !~# '^fugitive:' && s:Slash(@%) =~# '://\|^$'
+    let file = '%'
+  elseif a:rev ==# '>:'
+    let file = empty(s:DirCommitFile(@%)[0]) ? ':0:%' : '%'
+  elseif a:rev =~# '^>[> ]\@!'
+    let rev = (a:rev =~# '^>[~^]' ? '!' : '') . a:rev[1:-1]
+    let prefix = matchstr(rev, '^\%(\\.\|{[^{}]*}\|[^:]\)*')
+    if prefix !=# rev
+      let file = rev
+    else
+      let file = len(expand('%')) ? rev . ':%' : '%'
+    endif
+  elseif s:Slash(a:rev) =~# '^\a\a\+://'
+    let file = substitute(a:rev, '\\\@<!\%(#\a\|%\x\x\)', '\\&', 'g')
+  else
+    let file = a:rev
+  endif
+  return substitute(file,
+        \ '\(\\[' . s:fnameescape . ']\|^\\[>+-]\|' . s:commit_expand . '\|^\~[~.]\)\|' . s:expand,
+        \ '\=tr(s:ExpandVar(submatch(1),submatch(2),submatch(3),"", a:0 ? a:1 : getcwd()), "\1", " ")', 'g')
+endfunction
+
+function! fugitive#Expand(object) abort
+  return substitute(a:object,
+        \ '\(\\[' . s:fnameescape . ']\|^\\[>+-]\|' . s:commit_expand . '\|^\~[~.]\)\|' . s:expand,
+        \ '\=tr(s:ExpandVar(submatch(1),submatch(2),submatch(3),submatch(5)), "\1", " ")', 'g')
+endfunction
+
+function! s:SplitExpandChain(string, ...) abort
+  let list = []
+  let string = a:string
+  let dquote = '"\%([^"]\|""\|\\"\)*"\|'
+  let cwd = a:0 ? a:1 : getcwd()
+  while string =~# '\S'
+    if string =~# '^\s*|'
+      return [list, substitute(string, '^\s*', '', '')]
+    endif
+    let arg = matchstr(string, '^\s*\%(' . dquote . '''[^'']*''\|\\.\|[^' . "\t" . ' |]\)\+')
+    let string = strpart(string, len(arg))
+    let arg = substitute(arg, '^\s\+', '', '')
+    if !exists('seen_separator')
+      let arg = substitute(arg, '^\%([^:.][^:]*:\|^:\%((literal)\)\=\|^:[0-3]:\)\=\zs\.\.\=\%(/.*\)\=$',
+            \ '\=s:DotRelative(s:Slash(simplify(getcwd() . "/" . submatch(0))), cwd)', '')
+    endif
+    let arg = substitute(arg,
+          \ '\(' . dquote . '''\%(''''\|[^'']\)*''\|\\[' . s:fnameescape . ']\|^\\[>+-]\|' . s:commit_expand . '\|^\~[~]\|^\~\w*\|\$\w\+\)\|' . s:expand,
+          \ '\=s:ExpandVar(submatch(1),submatch(2),submatch(3),submatch(5), cwd)', 'g')
+    call extend(list, split(arg, "\1", 1))
+    if arg ==# '--'
+      let seen_separator = 1
+    endif
+  endwhile
+  return [list, '']
+endfunction
+
+let s:trees = {}
+let s:indexes = {}
+function! s:TreeInfo(dir, commit) abort
+  let key = s:GitDir(a:dir)
+  if a:commit =~# '^:\=[0-3]$'
+    let index = get(s:indexes, key, [])
+    let newftime = getftime(fugitive#Find('.git/index', a:dir))
+    if get(index, 0, -2) < newftime
+      let [lines, exec_error] = s:LinesError([a:dir, 'ls-files', '--stage', '--'])
+      let s:indexes[key] = [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[key][1][stage][filename] = [newftime, mode, 'blob', sha, -2]
+        while filename =~# '/'
+          let filename = substitute(filename, '/[^/]*$', '', '')
+          let s:indexes[key][1][stage][filename] = [newftime, '040000', 'tree', '', 0]
+        endwhile
+      endfor
+    endif
+    return [get(s:indexes[key][1], a:commit[-1:-1], {}), newftime]
+  elseif a:commit =~# '^\x\{40,\}$'
+    if !has_key(s:trees, key)
+      let s:trees[key] = {}
+    endif
+    if !has_key(s:trees[key], a:commit)
+      let ftime = s:ChompDefault('', [a:dir, 'log', '-1', '--pretty=format:%ct', a:commit, '--'])
+      if empty(ftime)
+        let s:trees[key][a:commit] = [{}, -1]
+        return s:trees[key][a:commit]
+      endif
+      let s:trees[key][a:commit] = [{}, +ftime]
+      let [lines, exec_error] = s:LinesError([a:dir, 'ls-tree', '-rtl', '--full-name', a:commit, '--'])
+      if exec_error
+        return s:trees[key][a:commit]
+      endif
+      for line in lines
+        let [info, filename] = split(line, "\t")
+        let [mode, type, sha, size] = split(info, '\s\+')
+        let s:trees[key][a:commit][0][filename] = [+ftime, mode, type, sha, +size, filename]
+      endfor
+    endif
+    return s:trees[key][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 ''
+  elseif empty(commit)
+    return s:VimSlash(s:DirUrlPrefix(simplify(s:GitDir(dir))))
+  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 s:VimSlash(path)
+      endif
+    endif
+  endif
+  return s:VimSlash(s:PathJoin(s:DirUrlPrefix(simplify(s:GitDir(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:StdoutToFile('', [a:dir, 'update-index', '--index-info'], info)
+  return !exec_error ? '' : len(error) ? error : '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
+
+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
+  let key = s:GitDir(dir)
+  if !has_key(s:blobdirs, key)
+    let s:blobdirs[key] = tempname()
+  endif
+  let tempfile = s:blobdirs[key] . '/' . commit . file
+  let tempparent = fnamemodify(tempfile, ':h')
+  if !isdirectory(tempparent)
+    call mkdir(tempparent, 'p')
+  elseif isdirectory(tempfile)
+    if commit =~# '^\d$' && has('patch-7.4.1107')
+      call delete(tempfile, 'rf')
+    else
+      return ''
+    endif
+  endif
+  if commit =~# '^\d$' || !filereadable(tempfile)
+    let rev = s:DirRev(a:url)[1]
+    let blob_or_filters = fugitive#GitVersion(2, 11) ? '--filters' : 'blob'
+    let exec_error = s:StdoutToFile(tempfile, [dir, 'cat-file', blob_or_filters, 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 = s:ChompDefault('', [dir, '--literal-pathspecs', 'hash-object', '-w', FugitiveGitPath(temp)])
+    let mode = entry[1] !=# '000000' ? entry[1] : '100644'
+    if 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 [repo, commit, glob] = s:DirCommitFile(a:url)
+  let dirglob = s:GitDir(repo)
+  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 = s:DirUrlPrefix(dir) . substitute(commit, '^:', '', '') . '/'
+    call sort(files)
+    call map(files, 's:VimSlash(s:PathJoin(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: Completion
+
+function! s:FilterEscape(items, ...) abort
+  let items = copy(a:items)
+  call map(items, 'fnameescape(v:val)')
+  if !a:0 || type(a:1) != type('')
+    let match = ''
+  else
+    let match = substitute(a:1, '^[+>]\|\\\@<![' . substitute(s:fnameescape, '\\', '', '') . ']', '\\&', 'g')
+  endif
+  let cmp = s:FileIgnoreCase(1) ? '==?' : '==#'
+  return filter(items, 'strpart(v:val, 0, strlen(match)) ' . cmp . ' match')
+endfunction
+
+function! s:GlobComplete(lead, pattern, ...) abort
+  if a:lead ==# '/'
+    return []
+  else
+    let results = glob(substitute(a:lead . a:pattern, '[\{}]', '\\&', 'g'), a:0 ? a:1 : 0, 1)
+  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/' && len(dir)
+    let pattern = s:gsub(base[5:-1], '/', '*&').'*'
+    let fdir = fugitive#Find('.git/', dir)
+    let matches = s:GlobComplete(fdir, pattern)
+    let cdir = fugitive#Find('.git/refs', dir)[0 : -5]
+    if len(cdir) && s:cpath(fdir) !=# 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
+  let base = s:Expand(a:base)
+
+  if a:base =~# '^!\d*$' && base !~# '^!'
+    return [base]
+  elseif base =~# '^\.\=/\|^:(' || base !~# ':'
+    let results = []
+    if base =~# '^refs/'
+      let cdir = fugitive#Find('.git/refs', dir)[0 : -5]
+      let results += map(s:GlobComplete(cdir, base . '*'), 's:Slash(v:val)')
+      call map(results, 's:fnameescape(v:val)')
+    elseif 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, fnameescape(base))
+    endif
+    let results += a:0 == 1 || a:0 >= 3 ? fugitive#CompletePath(base, 0, '', dir, a:0 >= 4 ? a:4 : tree) : fugitive#CompletePath(base)
+    return results
+
+  elseif base =~# '^:'
+    let entries = s:LinesError(['ls-files','--stage'], dir)[0]
+    if base =~# ':\./'
+      call map(entries, 'substitute(v:val, "\\M\t\\zs" . subdir, "./", "")')
+    endif
+    call map(entries,'s:sub(v:val,".*(\\d)\\t(.*)",":\\1:\\2")')
+    if base !~# '^:[0-3]\%(:\|$\)'
+      call filter(entries,'v:val[1] == "0"')
+      call map(entries,'v:val[2:-1]')
+    endif
+
+  else
+    let parent = matchstr(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, fnameescape(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
+
+augroup fugitive_dummy_events
+  autocmd!
+  autocmd User Fugitive* "
+  autocmd BufWritePre,FileWritePre,FileWritePost * "
+  autocmd BufNewFile * "
+  autocmd QuickfixCmdPre,QuickfixCmdPost * "
+augroup END
+
+function! s:ReplaceCmd(cmd) abort
+  let temp = tempname()
+  let [err, exec_error] = s:StdoutToFile(temp, a:cmd)
+  if exec_error
+    throw 'fugitive: ' . (len(err) ? substitute(err, "\n$", '', '') : 'unknown error running ' . string(a:cmd))
+  endif
+  setlocal noswapfile
+  silent exe 'lockmarks keepalt noautocmd 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(s:AbsoluteVimPath(bufnr('$')), temp)
+    silent! noautocmd execute bufnr('$') . 'bwipeout'
+  endif
+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
+
+function! s:QueryLog(refspec, limit) abort
+  let [log, exec_error] = s:LinesError(['log', '-n', '' . a:limit, '--pretty=format:%h%x09%s'] + a:refspec + ['--'])
+  call map(log, 'split(v:val, "\t", 1)')
+  call map(log, '{"type": "Log", "commit": v:val[0], "subject": join(v:val[1 : -1], "\t")}')
+  let result = {'error': exec_error ? 1 : 0, 'overflow': 0, 'entries': log}
+  if len(log) == a:limit
+    call remove(log, -1)
+    let result.overflow = 1
+  endif
+  return result
+endfunction
+
+function! s:QueryLogRange(old, new) abort
+  if empty(a:old) || empty(a:new)
+    return {'error': 2, 'overflow': 0, 'entries': []}
+  endif
+  return s:QueryLog([a:old . '..' . a:new], 256)
+endfunction
+
+function! s:AddLogSection(label, log) abort
+  if empty(a:log.entries)
+    return
+  endif
+  let label = a:label . ' (' . len(a:log.entries) . (a:log.overflow ? '+' : '') . ')'
+  call append(line('$'), ['', label] + s:Format(a:log.entries))
+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'))
+  unlet! b:fugitive_reltime b:fugitive_type
+  try
+    doautocmd BufReadPre
+    let config = fugitive#Config()
+
+    let cmd = [s:Dir()]
+    setlocal noreadonly modifiable nomodeline buftype=nowrite
+    if amatch !~# '^fugitive:' && s:cpath($GIT_INDEX_FILE !=# '' ? resolve(s:GitIndexFileEnv()) : fugitive#Find('.git/index')) !=# s:cpath(amatch)
+      let cmd += [{'env': {'GIT_INDEX_FILE': FugitiveGitPath(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 empty(s:Tree())
+      let branch = FugitiveHead(0)
+      let head = FugitiveHead(11)
+    elseif 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], 'relative': [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 relative = [file, output[i]]
+          else
+            let relative = [file]
+          endif
+          let filename = join(reverse(copy(relative)), ' -> ')
+          let sub = matchstr(line, '^[12u] .. \zs....')
+          if line[2] !=# '.'
+            call add(staged, {'type': 'File', 'status': line[2], 'filename': filename, 'relative': relative, 'submodule': sub})
+          endif
+          if line[3] !=# '.'
+            let sub = matchstr(line, '^[12u] .. \zs....')
+            call add(unstaged, {'type': 'File', 'status': get({'C':'M','M':'?','U':'?'}, matchstr(sub, 'S\.*\zs[CMU]'), line[3]), 'filename': file, 'relative': [file], 'submodule': 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
+    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\%($\| \[\)')
+      if head =~# '\.\.\.'
+        let head = split(head, '\.\.\.')[0]
+        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 i += 1
+        if line[2] !=# ' '
+          continue
+        endif
+        if line[0:1] =~# '[RC]'
+          let relative = [file, output[i]]
+          let i += 1
+        else
+          let relative = [file]
+        endif
+        let filename = join(reverse(copy(relative)), ' -> ')
+        if line[0] !~# '[ ?!#]'
+          call add(staged, {'type': 'File', 'status': line[0], 'filename': filename, 'relative': relative, 'submodule': ''})
+        endif
+        if line[0:1] ==# '??'
+          call add(untracked, {'type': 'File', 'status': line[1], 'filename': filename, 'relative': relative})
+        elseif line[1] !~# '[ !#]'
+          call add(unstaged, {'type': 'File', 'status': line[1], 'filename': file, 'relative': [file], 'submodule': ''})
+        endif
+      endwhile
+    endif
+
+    let diff = {'Staged': {'stdout': ['']}, 'Unstaged': {'stdout': ['']}}
+    if len(staged)
+      let diff['Staged'] =
+          \ fugitive#Execute(['-c', 'diff.suppressBlankEmpty=false', '-c', 'core.quotePath=false', 'diff', '--color=never', '--no-ext-diff', '--no-prefix', '--cached'], function('len'))
+    endif
+    if len(unstaged)
+      let diff['Unstaged'] =
+          \ fugitive#Execute(['-c', 'diff.suppressBlankEmpty=false', '-c', 'core.quotePath=false', 'diff', '--color=never', '--no-ext-diff', '--no-prefix'], function('len'))
+    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 fetch_remote = config.Get('branch.' . branch . '.remote', 'origin')
+    let push_remote = config.Get('branch.' . branch . '.pushRemote',
+          \ config.Get('remote.pushDefault', fetch_remote))
+    if fetch_remote !=# '.' && empty(config.Get('remote.' . fetch_remote . '.fetch'))
+      let fetch_remote = ''
+    endif
+    if push_remote !=# '.' && empty(config.Get('remote.' . push_remote . '.push', config.Get('remote.' . push_remote . '.fetch')))
+      let push_remote = ''
+    endif
+
+    let pull_type = 'Pull'
+    if empty(fetch_remote) || empty(branch)
+      let pull_ref = ''
+    elseif fetch_remote ==# '.'
+      let pull_ref = config.Get('branch.' . branch . '.merge', 'refs/heads/' . branch)
+    else
+      let pull_ref = substitute(config.Get('branch.' . branch . '.merge', 'refs/heads/' . branch), '^refs/heads/', 'refs/remotes/' . fetch_remote . '/', '')
+    endif
+    if len(pull_ref)
+      let rebase = FugitiveConfigGet('branch.' . branch . '.rebase', config)
+      if empty(rebase)
+        let rebase = FugitiveConfigGet('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_default = FugitiveConfigGet('push.default', config)
+    if empty(push_default)
+      let push_default = fugitive#GitVersion(2) ? 'simple' : 'matching'
+    endif
+    if push_default ==# 'upstream'
+      let push_ref = pull_ref
+    elseif empty(push_remote) || empty(branch)
+      let push_ref = ''
+    elseif push_remote ==# '.'
+      let push_ref = 'refs/heads/' . branch
+    else
+      let push_ref = 'refs/remotes/' . push_remote . '/' . branch
+    endif
+
+    let push_short = substitute(push_ref, '^refs/\w\+/', '', '')
+    let pull_short = substitute(pull_ref, '^refs/\w\+/', '', '')
+
+    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 sequencing = []
+    if filereadable(fugitive#Find('.git/sequencer/todo'))
+      for line in reverse(readfile(fugitive#Find('.git/sequencer/todo')))
+        let match = matchlist(line, '^\(\l\+\)\s\+\(\x\{4,\}\)\s\+\(.*\)')
+        if len(match) && match[1] !~# 'exec\|merge\|label'
+          call add(sequencing, {'type': 'Rebase', 'status': get(s:rebase_abbrevs, match[1], match[1]), 'commit': match[2], 'subject': match[3]})
+        endif
+      endfor
+    elseif filereadable(fugitive#Find('.git/MERGE_MSG'))
+      if filereadable(fugitive#Find('.git/CHERRY_PICK_HEAD'))
+        let pick_head = fugitive#Execute(['rev-parse', '--short', 'CHERRY_PICK_HEAD', '--']).stdout[0]
+        call add(sequencing, {'type': 'Rebase', 'status': 'pick', 'commit': pick_head, 'subject': get(readfile(fugitive#Find('.git/MERGE_MSG')), 0, '')})
+      elseif filereadable(fugitive#Find('.git/REVERT_HEAD'))
+        let pick_head = fugitive#Execute(['rev-parse', '--short', 'REVERT_HEAD', '--']).stdout[0]
+        call add(sequencing, {'type': 'Rebase', 'status': 'revert', 'commit': pick_head, 'subject': get(readfile(fugitive#Find('.git/MERGE_MSG')), 0, '')})
+      endif
+    endif
+
+    let b:fugitive_diff = diff
+    if get(a:, 1, v:cmdbang)
+      unlet! b:fugitive_expanded
+    endif
+    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_short)
+    if push_ref !=# pull_ref
+      call s:AddHeader('Push', push_short)
+    endif
+    if empty(s:Tree())
+      if get(fugitive#ConfigGetAll('core.bare', config), 0, '') !~# '^\%(false\|no|off\|0\|\)$'
+        call s:AddHeader('Bare', 'yes')
+      else
+        call s:AddHeader('Error', s:worktree_error)
+      endif
+    endif
+    if get(fugitive#ConfigGetAll('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(get(get(sequencing, 0, {}), 'status', '') ==# 'revert' ? 'Reverting' : 'Cherry Picking', sequencing)
+    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
+
+    let unique_push_ref = push_ref ==# pull_ref ? '' : push_ref
+    let unpushed_push = s:QueryLogRange(unique_push_ref, head)
+    if get(props, 'branch.ab') =~# '^+0 '
+      let unpushed_pull = {'error': 0, 'overflow': 0, 'entries': []}
+    else
+      let unpushed_pull = s:QueryLogRange(pull_ref, head)
+    endif
+    " If the push ref is defined but nowhere to be found at the remote,
+    " pretend it's the same as the pull ref
+    if unpushed_push.error == 1
+      let unpushed_push = unpushed_pull
+    endif
+    call s:AddLogSection('Unpushed to ' . push_short, unpushed_push)
+    call s:AddLogSection('Unpushed to ' . pull_short, unpushed_pull)
+    if unpushed_push.error && unpushed_pull.error && empty(rebasing) &&
+          \ !empty(push_remote . fetch_remote)
+      call s:AddLogSection('Unpushed to *', s:QueryLog([head, '--not', '--remotes'], 256))
+    endif
+    call s:AddLogSection('Unpulled from ' . push_short, s:QueryLogRange(head, unique_push_ref))
+    if len(pull_ref) && get(props, 'branch.ab') !~# ' -0$'
+      call s:AddLogSection('Unpulled from ' . pull_short, s:QueryLogRange(head, pull_ref))
+    endif
+
+    setlocal nomodified readonly noswapfile
+    doautocmd BufReadPost
+    setlocal nomodifiable
+    if &bufhidden ==# ''
+      setlocal bufhidden=delete
+    endif
+    if !exists('b:dispatch')
+      let b:dispatch = ':Git fetch --all'
+    endif
+    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', ":<C-U>Git 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 'fugitive: C has been removed in favor of cc'<CR>", '<silent><unique>')
+    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', ":echoerr 'fugitive: D has been removed in favor of dd'<CR>", '<silent><unique>')
+    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>')
+    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><unique>')
+    call s:Map('x', 'g<Bar>', ":<C-U>echoerr 'Changed to X'<CR>", '<silent><unique>')
+    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 s:DoAutocmd('User FugitiveIndex')
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  finally
+    let b:fugitive_type = 'index'
+  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 = [dir, 'log', '--pretty=format:%B', '-1', rev, '--']
+  elseif rev ==# ':'
+    let cmd = [dir, 'status', '--short']
+  else
+    let cmd = [dir, 'cat-file', '-p', rev, '--']
+  endif
+  let temp = tempname()
+  let [err, exec_error] = s:StdoutToFile(temp, cmd)
+  if exec_error
+    call delete(temp)
+    return 'noautocmd ' . line . 'read ' . s:fnameescape(amatch)
+  else
+    return 'silent keepalt ' . line . 'read ' . s:fnameescape(temp) . '|call delete(' . string(temp) . ')'
+  endif
+endfunction
+
+function! fugitive#FileWriteCmd(...) abort
+  let temp = 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 "noautocmd keepalt '[,']write ".temp
+    let hash = s:TreeChomp([dir, '--literal-pathspecs', 'hash-object', '-w', '--', FugitiveGitPath(temp)])
+    let old_mode = matchstr(s:ChompDefault('', ['ls-files', '--stage', '.' . file], dir), '^\d\+')
+    if empty(old_mode)
+      let old_mode = executable(s:Tree(dir) . file) ? '100755' : '100644'
+    endif
+    let error = s:UpdateIndex(dir, [old_mode, hash, commit, file[1:-1]])
+    if empty(error)
+      setlocal nomodified
+      if exists('#' . autype . 'WritePost')
+        execute s:DoAutocmd(autype . 'WritePost ' . s:fnameescape(amatch))
+      endif
+      exe s:DoAutocmdChanged(dir)
+      return ''
+    else
+      return 'echoerr '.string('fugitive: '.error)
+    endif
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  finally
+    call delete(temp)
+  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
+    call s:InitializeBuffer(dir)
+    if rev ==# ':'
+      return fugitive#BufReadStatus(v:cmdbang)
+    elseif rev =~# '^:\d$'
+      let b:fugitive_type = 'stage'
+    else
+      let r = fugitive#Execute([dir, 'cat-file', '-t', rev])
+      let b:fugitive_type = get(r.stdout, 0, '')
+      if r.exit_status && rev =~# '^:0'
+        let r = fugitive#Execute([dir, 'write-tree', '--prefix=' . rev[3:-1]])
+        let sha = get(r.stdout, 0, '')
+        let b:fugitive_type = 'tree'
+      endif
+      if r.exit_status
+        let error = substitute(join(r.stderr, "\n"), "\n*$", '', '')
+        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 'doautocmd BufNewFile'
+        else
+          setlocal readonly nomodifiable
+          return '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
+
+    let events = ['User FugitiveObject', 'User Fugitive' . substitute(b:fugitive_type, '^\l', '\u&', '')]
+
+    try
+      if b:fugitive_type !=# 'blob'
+        setlocal foldmarker=<<<<<<<<,>>>>>>>>
+      endif
+      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', '-c', 'log.showRoot=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'
+        let blob_or_filters = rev =~# ':' && fugitive#GitVersion(2, 11) ? '--filters' : 'blob'
+        call s:ReplaceCmd([dir, 'cat-file', blob_or_filters, rev])
+      endif
+    finally
+      keepjumps call setpos('.',pos)
+      setlocal nomodified noswapfile
+      let modifiable = rev =~# '^:.:' && b:fugitive_type !=# 'tree'
+      if modifiable
+        let events = ['User FugitiveStageBlob']
+      endif
+      let &l:readonly = !modifiable || !filewritable(fugitive#Find('.git/index', dir))
+      if empty(&bufhidden)
+        setlocal bufhidden=delete
+      endif
+      let &l:modifiable = modifiable
+      call fugitive#MapJumps()
+      if b:fugitive_type !=# 'blob'
+        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>')
+        setlocal filetype=git
+      endif
+    endtry
+
+    setlocal modifiable
+
+    return s:DoAutocmd('BufReadPost') .
+          \ (modifiable ? '' : '|setl nomodifiable') . '|' .
+          \ call('s:DoAutocmd', events)
+  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(s:AbsoluteVimPath(a:0 ? a:1 : -1)), {})
+endfunction
+
+function! fugitive#Result(...) abort
+  if !a:0 && exists('g:fugitive_event')
+    return get(g:, 'fugitive_result', {})
+  elseif !a:0 || type(a:1) == type('') && a:1 =~# '^-\=$'
+    return get(g:, '_fugitive_last_job', {})
+  elseif type(a:1) == type(0)
+    return s:TempState(a:1)
+  elseif type(a:1) == type('')
+    return s:TempState(a:1)
+  elseif type(a:1) == type({}) && has_key(a:1, 'file')
+    return s:TempState(a:1.file)
+  else
+    return {}
+  endif
+endfunction
+
+function! s:TempDotMap() abort
+  let cfile = s:cfile()
+  if empty(cfile)
+    if getline('.') =~# '^[*+] \+\f' && col('.') < 2
+      return matchstr(getline('.'), '^. \+\zs\f\+')
+    else
+      return expand('<cfile>')
+    endif
+  endif
+  let name = fugitive#Find(cfile[0])
+  let [dir, commit, file] = s:DirCommitFile(name)
+  if len(commit) && empty(file)
+    return commit
+  elseif s:cpath(s:Tree(), getcwd())
+    return fugitive#Path(name, "./")
+  else
+    return fugitive#Real(name)
+  endif
+endfunction
+
+function! s:TempReadPre(file) abort
+  let key = s:cpath(s:AbsoluteVimPath(a:file))
+  if has_key(s:temp_files, key)
+    let dict = s:temp_files[key]
+    setlocal nomodeline
+    if empty(&bufhidden)
+      setlocal bufhidden=delete
+    endif
+    setlocal buftype=nowrite
+    setlocal nomodifiable
+    call s:InitializeBuffer(dict)
+    if len(dict.git_dir)
+      call extend(b:, {'fugitive_type': 'temp'}, 'keep')
+    endif
+  endif
+  return ''
+endfunction
+
+function! s:TempReadPost(file) abort
+  let key = s:cpath(s:AbsoluteVimPath(a:file))
+  if has_key(s:temp_files, key)
+    let dict = s:temp_files[key]
+    if !has_key(dict, 'job')
+      setlocal nobuflisted
+    endif
+    if get(dict, 'filetype', '') ==# 'git'
+      call fugitive#MapJumps()
+      call s:Map('n', '.', ":<C-U> <C-R>=<SID>fnameescape(<SID>TempDotMap())<CR><Home>")
+      call s:Map('x', '.', ":<C-U> <C-R>=<SID>fnameescape(<SID>TempDotMap())<CR><Home>")
+    endif
+    if has_key(dict, 'filetype')
+      if dict.filetype ==# 'man' && has('nvim')
+        let b:man_sect = matchstr(getline(1), '^\w\+(\zs\d\+\ze)')
+      endif
+      if !get(g:, 'did_load_ftplugin') && dict.filetype ==# 'fugitiveblame'
+        call s:BlameMaps(0)
+      endif
+      let &l:filetype = dict.filetype
+    endif
+    setlocal foldmarker=<<<<<<<<,>>>>>>>>
+    if !&modifiable
+      call s:Map('n', 'gq', ":<C-U>bdelete<CR>", '<silent> <unique>')
+    endif
+  endif
+  return s:DoAutocmd('User FugitivePager')
+endfunction
+
+function! s:TempDelete(file) abort
+  let key = s:cpath(s:AbsoluteVimPath(a:file))
+  if has_key(s:temp_files, key) && !has_key(s:temp_files[key], 'job') && key !=# s:cpath(get(get(g:, '_fugitive_last_job', {}), 'file', ''))
+    call delete(a:file)
+    call remove(s:temp_files, key)
+  endif
+  return ''
+endfunction
+
+function! s:OriginBufnr(...) abort
+  let state = s:TempState(a:0 ? a:1 : bufnr(''))
+  return get(state, 'origin_bufnr', -1)
+endfunction
+
+augroup fugitive_temp
+  autocmd!
+  autocmd BufReadPre  * exe s:TempReadPre( +expand('<abuf>'))
+  autocmd BufReadPost * exe s:TempReadPost(+expand('<abuf>'))
+  autocmd BufWipeout  * exe s:TempDelete(  +expand('<abuf>'))
+augroup END
+
+" Section: :Git
+
+function! s:AskPassArgs(dir) abort
+  if (len($DISPLAY) || len($TERM_PROGRAM) || has('gui_running')) &&
+        \ empty($GIT_ASKPASS) && empty($SSH_ASKPASS) && empty(fugitive#ConfigGetAll('core.askpass', a:dir))
+    if s:executable(s:VimExecPath() . '/git-gui--askpass')
+      return ['-c', 'core.askPass=' . s:ExecPath()[0] . '/git-gui--askpass']
+    elseif s:executable('ssh-askpass')
+      return ['-c', 'core.askPass=ssh-askpass']
+    endif
+  endif
+  return []
+endfunction
+
+function! s:RunSave(state) abort
+  let s:temp_files[s:cpath(a:state.file)] = a:state
+endfunction
+
+function! s:RunFinished(state, ...) abort
+  if has_key(get(g:, '_fugitive_last_job', {}), 'file') && bufnr(g:_fugitive_last_job.file) < 0
+    exe s:TempDelete(remove(g:, '_fugitive_last_job').file)
+  endif
+  let g:_fugitive_last_job = a:state
+  let first = join(readfile(a:state.file, '', 2), "\n")
+  if get(a:state, 'filetype', '') ==# 'git' && first =~# '\<\([[:upper:][:digit:]_-]\+(\d\+)\).*\1'
+    let a:state.filetype = 'man'
+  endif
+  if !has_key(a:state, 'capture_bufnr')
+    return
+  endif
+  call fugitive#DidChange(a:state)
+endfunction
+
+function! s:RunEdit(state, tmp, job) abort
+  if get(a:state, 'request', '') !=# 'edit'
+    return 0
+  endif
+  call remove(a:state, 'request')
+  let sentinel = a:state.file . '.edit'
+  let file = FugitiveVimPath(readfile(sentinel, '', 1)[0])
+  try
+    if !&equalalways && a:state.mods !~# '\<tab\>' && 3 > (a:state.mods =~# '\<vert' ? winwidth(0) : winheight(0))
+      let noequalalways = 1
+      setglobal equalalways
+    endif
+    let mods = s:Mods(a:state.mods, 'SpanOrigin')
+    exe substitute(mods, '\<tab\>', '-tab', 'g') 'keepalt split' s:fnameescape(file)
+  finally
+    if exists('l:noequalalways')
+      setglobal noequalalways
+    endif
+  endtry
+  set bufhidden=wipe
+  call s:InitializeBuffer(a:state)
+  let bufnr = bufnr('')
+  let s:edit_jobs[bufnr] = [a:state, a:tmp, a:job, sentinel]
+  call fugitive#DidChange(a:state.git_dir)
+  if bufnr == bufnr('') && !exists('g:fugitive_event')
+    try
+      let g:fugitive_event = a:state.git_dir
+      let g:fugitive_result = a:state
+      exe s:DoAutocmd('User FugitiveEditor')
+    finally
+      unlet! g:fugitive_event g:fugitive_result
+    endtry
+  endif
+  return 1
+endfunction
+
+function! s:RunReceive(state, tmp, type, job, data, ...) abort
+  if a:type ==# 'err' || a:state.pty
+    let data = type(a:data) == type([]) ? join(a:data, "\n") : a:data
+    let data = a:tmp.escape . data
+    let escape = "\033]51;[^\007]*"
+    let a:tmp.escape = matchstr(data, escape . '$')
+    if len(a:tmp.escape)
+      let data = strpart(data, 0, len(data) - len(a:tmp.escape))
+    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
+    let lines = split(a:tmp.err . data, "\r\\=\n", 1)
+    let a:tmp.err = lines[-1]
+    let lines[-1] = ''
+    call map(lines, 'substitute(v:val, ".*\r", "", "")')
+  else
+    let lines = type(a:data) == type([]) ? a:data : split(a:data, "\n", 1)
+    if len(a:tmp.out)
+      let lines[0] = a:tmp.out . lines[0]
+    endif
+    let a:tmp.out = lines[-1]
+    let lines[-1] = ''
+  endif
+  call writefile(lines, a:state.file, 'ba')
+  if has_key(a:tmp, 'echo')
+    if !exists('l:data')
+      let data = type(a:data) == type([]) ? join(a:data, "\n") : a:data
+    endif
+    let a:tmp.echo .= data
+  endif
+  let line_count = a:tmp.line_count
+  let a:tmp.line_count += len(lines) - 1
+  if !has_key(a:state, 'capture_bufnr') || !bufloaded(a:state.capture_bufnr)
+    return
+  endif
+  call remove(lines, -1)
+  try
+    call setbufvar(a:state.capture_bufnr, '&modifiable', 1)
+    if !line_count && len(lines) > 1000
+      let first = remove(lines, 0, 999)
+      call setbufline(a:state.capture_bufnr, 1, first)
+      redraw
+      call setbufline(a:state.capture_bufnr, 1001, lines)
+    else
+      call setbufline(a:state.capture_bufnr, line_count + 1, lines)
+    endif
+    call setbufvar(a:state.capture_bufnr, '&modifiable', 0)
+    if !a:state.pager && getwinvar(bufwinid(a:state.capture_bufnr), '&previewwindow')
+      let winnr = bufwinnr(a:state.capture_bufnr)
+      if winnr > 0
+        let old_winnr = winnr()
+        exe 'noautocmd' winnr.'wincmd w'
+        $
+        exe 'noautocmd' old_winnr.'wincmd w'
+      endif
+    endif
+  catch
+  endtry
+endfunction
+
+function! s:RunExit(state, tmp, job, exit_status) abort
+  let a:state.exit_status = a:exit_status
+  if has_key(a:state, 'job')
+    return
+  endif
+  call s:RunFinished(a:state)
+endfunction
+
+function! s:RunClose(state, tmp, job, ...) abort
+  if a:0
+    call s:RunExit(a:state, a:tmp, a:job, a:1)
+  endif
+  let noeol = substitute(substitute(a:tmp.err, "\r$", '', ''), ".*\r", '', '') . a:tmp.out
+  call writefile([noeol], a:state.file, 'ba')
+  call remove(a:state, 'job')
+  if has_key(a:state, 'capture_bufnr') && bufloaded(a:state.capture_bufnr)
+    if len(noeol)
+      call setbufvar(a:state.capture_bufnr, '&modifiable', 1)
+      call setbufline(a:state.capture_bufnr, a:tmp.line_count + 1, [noeol])
+      call setbufvar(a:state.capture_bufnr, '&eol', 0)
+      call setbufvar(a:state.capture_bufnr, '&modifiable', 0)
+    endif
+    call setbufvar(a:state.capture_bufnr, '&modified', 0)
+    call setbufvar(a:state.capture_bufnr, '&buflisted', 0)
+    if a:state.filetype !=# getbufvar(a:state.capture_bufnr, '&filetype', '')
+      call setbufvar(a:state.capture_bufnr, '&filetype', a:state.filetype)
+    endif
+  endif
+  if !has_key(a:state, 'exit_status')
+    return
+  endif
+  call s:RunFinished(a:state)
+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
+
+function! s:RunCloseIn(job) abort
+  try
+    if type(a:job) ==# type(0)
+      call chanclose(a:job, 'stdin')
+    else
+      call ch_close_in(a:job)
+    endif
+    return 1
+  catch /^Vim\%((\a\+)\)\=:E90[06]:/
+    return 0
+  endtry
+endfunction
+
+function! s:RunEcho(tmp) abort
+  if !has_key(a:tmp, 'echo')
+    return
+  endif
+  let data = a:tmp.echo
+  let a:tmp.echo = matchstr(data, "[\r\n]\\+$")
+  if len(a:tmp.echo)
+    let data = strpart(data, 0, len(data) - len(a:tmp.echo))
+  endif
+  echon substitute(data, "\r\\ze\n", '', 'g')
+endfunction
+
+function! s:RunTick(job) abort
+  if type(a:job) == v:t_number
+    return jobwait([a:job], 1)[0] == -1
+  elseif type(a:job) == 8
+    let running = ch_status(a:job) !~# '^closed$\|^fail$' || job_status(a:job) ==# 'run'
+    sleep 1m
+    return running
+  endif
+endfunction
+
+if !exists('s:edit_jobs')
+  let s:edit_jobs = {}
+endif
+function! s:RunWait(state, tmp, job, ...) abort
+  if a:0 && filereadable(a:1)
+    call delete(a:1)
+  endif
+  try
+    if a:tmp.no_more && &more
+      let more = &more
+      let &more = 0
+    endif
+    while get(a:state, 'request', '') !=# 'edit' && s:RunTick(a:job)
+      call s:RunEcho(a:tmp)
+      if !get(a:tmp, 'closed_in')
+        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>" || c ==# "\<Esc>"
+            let a:tmp.closed_in = 1
+            let can_pedit = s:RunCloseIn(a:job) && exists('*setbufline')
+            for winnr in range(1, winnr('$'))
+              if getwinvar(winnr, '&previewwindow') && getbufvar(winbufnr(winnr), '&modified')
+                let can_pedit = 0
+              endif
+            endfor
+            if can_pedit
+              if has_key(a:tmp, 'echo')
+                call remove(a:tmp, 'echo')
+              endif
+              call writefile(['fugitive: aborting edit due to background operation.'], a:state.file . '.exit')
+              exe (&splitbelow ? 'botright' : 'topleft') 'silent pedit ++ff=unix' s:fnameescape(a:state.file)
+              let a:state.capture_bufnr = bufnr(a:state.file)
+              call setbufvar(a:state.capture_bufnr, '&modified', 1)
+              let finished = 0
+              redraw!
+              return ''
+            endif
+          else
+            call s:RunSend(a:job, c)
+            if !a:state.pty
+              echon c
+            endif
+          endif
+        endif
+      endif
+    endwhile
+    if !has_key(a:state, 'request') && has_key(a:state, 'job') && exists('*job_status') && job_status(a:job) ==# "dead"
+      throw 'fugitive: close callback did not fire; this should never happen'
+    endif
+    call s:RunEcho(a:tmp)
+    if has_key(a:tmp, 'echo')
+      let a:tmp.echo = substitute(a:tmp.echo, "^\r\\=\n", '', '')
+      echo
+    endif
+    let finished = !s:RunEdit(a:state, a:tmp, a:job)
+  finally
+    if exists('l:more')
+      let &more = more
+    endif
+    if !exists('finished')
+      try
+        if a:state.pty && !get(a:tmp, 'closed_in')
+          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
+    elseif finished
+      call fugitive#DidChange(a:state)
+    endif
+  endtry
+  return ''
+endfunction
+
+if !exists('s:resume_queue')
+  let s:resume_queue = []
+endif
+function! fugitive#Resume() abort
+  while len(s:resume_queue)
+    let enqueued = remove(s:resume_queue, 0)
+    if enqueued[2] isnot# ''
+      try
+        call call('s:RunWait', enqueued)
+      endtry
+    endif
+  endwhile
+endfunction
+
+function! s:RunBufDelete(bufnr) abort
+  let state = s:TempState(+a:bufnr)
+  if has_key(state, 'job')
+    try
+      if type(state.job) == type(0)
+        call jobstop(state.job)
+      else
+        call job_stop(state.job)
+      endif
+    catch
+    endtry
+  endif
+  if has_key(s:edit_jobs, a:bufnr) |
+    call add(s:resume_queue, remove(s:edit_jobs, a:bufnr))
+    call feedkeys("\<C-\>\<C-N>:redraw!|call delete(" . string(s:resume_queue[-1][0].file . '.edit') .
+          \ ")|call fugitive#Resume()|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(['Aborting edit due to Vim exit.'], s:edit_jobs[s:jobbuf][0].file . '.exit') |
+        \   redraw! |
+        \   call call('s:RunWait', remove(s:edit_jobs, s:jobbuf)) |
+        \ endfor
+augroup END
+
+function! fugitive#CanPty() abort
+  return get(g:, 'fugitive_pty_debug_override',
+        \ has('unix') && !has('win32unix') && (has('patch-8.0.0744') || has('nvim')) && fugitive#GitVersion() !~# '\.windows\>')
+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(fugitive#ConfigGetAll('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] =~# '^\%(branch\|config\|diff\|grep\|log\|range-diff\|shortlog\|show\|tag\|whatchanged\)$' ||
+        \ (args[0] ==# 'stash' && get(args, 1, '') ==# 'show') ||
+        \ (args[0] ==# 'reflog' && get(args, 1, '') !~# '^\%(expire\|delete\|exists\)$') ||
+        \ (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
+  exe s:VersionCheck()
+  let dir = call('s:Dir', a:000)
+  if len(dir)
+    exe s:DirCheck(dir)
+  endif
+  let config = copy(fugitive#Config(dir))
+  let curwin = a:arg =~# '^++curwin\>' || !a:line2
+  let [args, after] = s:SplitExpandChain(substitute(a:arg, '^++curwin\>\s*', '', ''), s:Tree(dir))
+  let flags = []
+  let pager = -1
+  let explicit_pathspec_option = 0
+  while len(args)
+    if args[0] ==# '-c' && len(args) > 1
+      call extend(flags, remove(args, 0, 1))
+    elseif args[0] =~# '^-p$\|^--paginate$'
+      let pager = 2
+      call remove(args, 0)
+    elseif args[0] =~# '^-P$\|^--no-pager$'
+      let pager = 0
+      call remove(args, 0)
+    elseif args[0] =~# '^--\%([[:lower:]-]\+-pathspecs\)$'
+      let explicit_pathspec_option = 1
+      call add(flags, remove(args, 0))
+    elseif args[0] =~# '^\%(--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 !explicit_pathspec_option
+    call insert(flags, '--no-literal-pathspecs')
+  endif
+  let no_pager = pager is# 0
+  if no_pager
+    call add(flags, '--no-pager')
+  endif
+  let 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 options = {'git': s:UserCommandList(), 'git_dir': s:GitDir(dir), 'flags': flags, 'curwin': curwin}
+  if empty(args) && pager is# -1
+    let cmd = s:StatusCommand(a:line1, a:line2, a:range, curwin ? 0 : a:line2, a:bang, a:mods, '', '', [], options)
+    return (empty(cmd) ? 'exe' : cmd) . after
+  endif
+  let alias = FugitiveConfigGet('alias.' . get(args, 0, ''), config)
+  if get(args, 1, '') !=# '--help' && alias !~# '^$\|^!\|[\"'']' && !filereadable(s:VimExecPath() . '/git-' . args[0])
+        \ && !(has('win32') && filereadable(s:VimExecPath() . '/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')
+  if pager is# -1 && name =~# '^\a\+$' && 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
+  call extend(env, get(overrides, 'env', {}))
+  call s:PrepareEnv(env, dir)
+  if pager is# -1
+    let pager = fugitive#PagerFor(args, config)
+  endif
+  let wants_terminal = type(pager) ==# type('') ||
+        \ (s:HasOpt(args, ['add', 'checkout', 'commit', 'reset', 'restore', 'stage', 'stash'], '-p', '--patch') ||
+        \ s:HasOpt(args, ['add', 'clean', 'stage'], '-i', '--interactive')) && pager is# 0
+  if wants_terminal
+    let mods = substitute(s:Mods(a:mods), '\<tab\>', '-tab', 'g')
+    let assign = len(dir) ? "|call FugitiveDetect({'git_dir':" . string(options.git_dir) . '})' : ''
+    let argv = s:UserCommandList(options) + args
+    let term_opts = len(env) ? {'env': env} : {}
+    if has('nvim')
+      call fugitive#Autowrite()
+      return mods . (curwin ? 'enew' : 'new') . '|call termopen(' . string(argv) . ', ' . string(term_opts) . ')' . assign . '|startinsert' . after
+    elseif exists('*term_start')
+      call fugitive#Autowrite()
+      if curwin
+        let term_opts.curwin = 1
+      endif
+      return mods . 'call term_start(' . string(argv) . ', ' . string(term_opts) . ')' . assign . after
+    endif
+  endif
+  let state = {
+        \ 'git': options.git,
+        \ 'flags': flags,
+        \ 'args': args,
+        \ 'git_dir': options.git_dir,
+        \ 'cwd': s:UserCommandCwd(dir),
+        \ 'filetype': 'git',
+        \ 'mods': s:Mods(a:mods),
+        \ 'file': s:Resolve(tempname())}
+  let allow_pty = 1
+  let after_edit = ''
+  let stream = 0
+  if a:bang && pager isnot# 2
+    let state.pager = pager
+    let pager = 1
+    let stream = exists('*setbufline')
+    let do_edit = substitute(s:Mods(a:mods, 'Edge'), '\<tab\>', '-tab', 'g') . 'pedit!'
+  elseif pager
+    let allow_pty = get(args, 0, '') is# 'shortlog'
+    if pager is# 2 && a:bang && a:line2 >= 0
+      let [do_edit, after_edit] = s:ReadPrepare(a:line1, a:line2, a:range, a:mods)
+    elseif pager is# 2 && a:bang
+      let do_edit = s:Mods(a:mods, 'SpanOrigin') . 'pedit'
+    elseif !curwin
+      let do_edit = s:Mods(a:mods, 'SpanOrigin') . 'split'
+    else
+      let do_edit = s:Mods(a:mods) . 'edit'
+      call s:BlurStatus()
+    endif
+    call extend(env, {'COLUMNS': '' . get(g:, 'fugitive_columns', 80)}, 'keep')
+  endif
+  if s:run_jobs
+    call extend(env, {'COLUMNS': '' . (&columns - 1)}, 'keep')
+    let state.pty = allow_pty && fugitive#CanPty()
+    if !state.pty
+      let args = s:AskPassArgs(dir) + args
+    endif
+    let tmp = {
+          \ 'no_more': no_pager || get(overrides, 'no_more'),
+          \ 'line_count': 0,
+          \ 'err': '',
+          \ 'out': '',
+          \ 'escape': ''}
+    let env.FUGITIVE = state.file
+    let editor = 'sh ' . s:TempScript(
+          \ '[ -f "$FUGITIVE.exit" ] && cat "$FUGITIVE.exit" >&2 && 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_PAGER': 'cat',
+          \ 'PAGER': 'cat'}, 'keep')
+    if len($GPG_TTY) && !has_key(env, 'GPG_TTY')
+      let env.GPG_TTY = ''
+      let did_override_gpg_tty = 1
+    endif
+    if stream
+      call writefile(['fugitive: aborting edit due to background operation.'], state.file . '.exit')
+    elseif pager
+      call writefile(['fugitive: aborting edit due to use of pager.'], state.file . '.exit')
+      let after = '|' . do_edit . ' ' . s:fnameescape(state.file) . after_edit . after
+    else
+      let env.GIT_MERGE_AUTOEDIT = '1'
+      let tmp.echo = ''
+    endif
+    let args = s:disable_colors + flags + ['-c', 'advice.waitingForEditor=false'] + args
+    let argv = s:UserCommandList({'git': options.git, 'git_dir': options.git_dir}) + args
+    let [argv, jobopts] = s:JobOpts(argv, env)
+    call fugitive#Autowrite()
+    call writefile([], state.file, 'b')
+    call s:RunSave(state)
+    if has_key(tmp, 'echo')
+      echo ""
+    endif
+    if exists('*ch_close_in')
+      call extend(jobopts, {
+            \ 'mode': 'raw',
+            \ 'out_cb': function('s:RunReceive', [state, tmp, 'out']),
+            \ 'err_cb': function('s:RunReceive', [state, tmp, 'err']),
+            \ 'close_cb': function('s:RunClose', [state, tmp]),
+            \ 'exit_cb': function('s:RunExit', [state, tmp]),
+            \ })
+      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, tmp, 'out']),
+            \ 'on_stderr': function('s:RunReceive', [state, tmp, 'err']),
+            \ 'on_exit': function('s:RunClose', [state, tmp]),
+            \ }))
+    endif
+    let state.job = job
+    if pager
+      let tmp.closed_in = 1
+      call s:RunCloseIn(job)
+    endif
+    if stream
+      exe 'silent' do_edit '++ff=unix' s:fnameescape(state.file)
+      let state.capture_bufnr = bufnr(state.file)
+      call setbufvar(state.capture_bufnr, '&modified', 1)
+      return (after_edit . after)[1:-1]
+    endif
+    call add(s:resume_queue, [state, tmp, job])
+    return 'call fugitive#Resume()|checktime' . after
+  elseif pager
+    let pre = s:BuildEnvPrefix(env)
+    try
+      if exists('+guioptions') && &guioptions =~# '!'
+        let guioptions = &guioptions
+        set guioptions-=!
+      endif
+      silent! execute '!' . escape(pre . s:shellesc(s:UserCommandList(options) + s:disable_colors + flags + ['--no-pager'] + args), '!#%') .
+            \ (&shell =~# 'csh' ? ' >& ' . s:shellesc(state.file) : ' > ' . s:shellesc(state.file) . ' 2>&1')
+      let state.exit_status = v:shell_error
+    finally
+      if exists('guioptions')
+        let &guioptions = guioptions
+      endif
+    endtry
+    redraw!
+    call s:RunSave(state)
+    call s:RunFinished(state)
+    return do_edit . ' ' . s:fnameescape(state.file) . after_edit .
+          \ '|call fugitive#DidChange(fugitive#Result(' . string(state.file) . '))' . 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
+    if !explicit_pathspec_option && get(options.flags, 0, '') ==# '--no-literal-pathspecs'
+      call remove(options.flags, 0)
+    endif
+    if exists('l:did_override_gpg_tty')
+      call remove(env, 'GPG_TTY')
+    endif
+    let cmd = s:BuildEnvPrefix(env) . s:shellesc(s:UserCommandList(options) + args)
+    let after = '|call fugitive#DidChange(' . string(dir) . ')' . after
+    if !wants_terminal && (no_pager || index(['add', 'clean', 'reset', 'restore', 'stage'], get(args, 0, '')) >= 0 || s:HasOpt(args, ['checkout'], '-q', '--quiet', '--no-progress'))
+      let output = substitute(s:SystemError(cmd)[0], "\n$", '', '')
+      if len(output)
+        try
+          if &more && no_pager
+            let more = 1
+            set nomore
+          endif
+          echo substitute(output, "\n$", "", "")
+        finally
+          if exists('l:more')
+            set more
+          endif
+        endtry
+      endif
+      return 'checktime' . after
+    else
+      return 'exe ' . string('noautocmd !' . escape(cmd, '!#%')) . after
+    endif
+  endif
+endfunction
+
+let s:exec_paths = {}
+function! s:ExecPath() abort
+  let git = s:GitShellCmd()
+  if !has_key(s:exec_paths, git)
+    let path = get(s:JobExecute(s:GitCmd() + ['--exec-path'], {}, [], [], {}).stdout, 0, '')
+    let s:exec_paths[git] = [path, FugitiveVimPath(path)]
+  endif
+  return s:exec_paths[git]
+endfunction
+
+function! s:VimExecPath() abort
+  return s:ExecPath()[1]
+endfunction
+
+let s:subcommands_before_2_5 = [
+      \ 'add', 'am', 'apply', 'archive', 'bisect', 'blame', 'branch', 'bundle',
+      \ 'checkout', 'cherry', 'cherry-pick', 'citool', 'clean', 'clone', 'commit', 'config',
+      \ 'describe', 'diff', 'difftool', 'fetch', 'format-patch', 'fsck',
+      \ 'gc', 'grep', 'gui', 'help', 'init', 'instaweb', 'log',
+      \ 'merge', 'mergetool', 'mv', 'notes', 'pull', 'push',
+      \ 'rebase', 'reflog', 'remote', 'repack', 'replace', 'request-pull', 'reset', 'revert', 'rm',
+      \ 'send-email', 'shortlog', 'show', 'show-branch', 'stash', 'stage', 'status', 'submodule',
+      \ 'tag', 'whatchanged',
+      \ ]
+let s:path_subcommands = {}
+function! s:CompletableSubcommands(dir) abort
+  let c_exec_path = s:cpath(s:VimExecPath())
+  if !has_key(s:path_subcommands, c_exec_path)
+    if fugitive#GitVersion(2, 18)
+      let [lines, exec_error] = s:LinesError([a:dir, '--list-cmds=list-mainporcelain,nohelpers,list-complete'])
+      call filter(lines, 'v:val =~# "^\\S\\+$"')
+      if !exec_error && len(lines)
+        let s:path_subcommands[c_exec_path] = lines
+      else
+        let s:path_subcommands[c_exec_path] = s:subcommands_before_2_5 +
+              \ ['maintenance', 'prune', 'range-diff', 'restore', 'sparse-checkout', 'switch', 'worktree']
+      endif
+    else
+      let s:path_subcommands[c_exec_path] = s:subcommands_before_2_5 +
+            \ (fugitive#GitVersion(2, 5) ? ['worktree'] : [])
+    endif
+  endif
+  let commands = copy(s:path_subcommands[c_exec_path])
+  for path in split($PATH, has('win32') ? ';' : ':')
+    if path !~# '^/\|^\a:[\\/]'
+      continue
+    endif
+    let cpath = s:cpath(path)
+    if !has_key(s:path_subcommands, cpath)
+      let s:path_subcommands[cpath] = filter(map(s:GlobComplete(path.'/git-', '*', 1),'substitute(v:val,"\\.exe$","","")'), 'v:val !~# "--\\|/"')
+    endif
+    call extend(commands, s:path_subcommands[cpath])
+  endfor
+  call extend(commands, keys(fugitive#ConfigGetRegexp('^alias\.\zs[^.]\+$', a:dir)))
+  let configured = split(FugitiveConfigGet('completion.commands', a:dir), '\s\+')
+  let rejected = {}
+  for command in configured
+    if command =~# '^-.'
+      let rejected[strpart(command, 1)] = 1
+    endif
+  endfor
+  call filter(configured, 'v:val !~# "^-"')
+  let results = filter(sort(commands + configured), '!has_key(rejected, v:val)')
+  if exists('*uniq')
+    return uniq(results)
+  else
+    let i = 1
+    while i < len(results)
+      if results[i] ==# results[i-1]
+        call remove(results, i)
+      else
+        let i += 1
+      endif
+    endwhile
+    return results
+  endif
+endfunction
+
+function! fugitive#Complete(lead, ...) abort
+  let dir = a:0 == 1 ? a:1 : a:0 >= 3 ? s:Dir(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*[! ] *\%(\%(++\S\+\|--\S\+-pathspecs\|-c\s\+\S\+\)\s\+\)*\zs[[:alnum:]][[:alnum:]-]*\ze ')
+  if empty(subcmd) && a:lead =~# '^+'
+    let results = ['++curwin']
+  elseif empty(subcmd) && a:lead =~# '^-'
+    let results = ['--literal-pathspecs', '--no-literal-pathspecs', '--glob-pathspecs', '--noglob-pathspecs', '--icase-pathspecs', '--no-optional-locks']
+  elseif empty(subcmd)
+    let results = s:CompletableSubcommands(dir)
+  elseif a:0 ==# 2 && subcmd =~# '^\%(commit\|revert\|push\|fetch\|pull\|merge\|rebase\|bisect\)$'
+    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 ') . fnameescape(s:VimSlash(path))
+endfunction
+
+" Section: :Gstatus
+
+function! s:StatusCommand(line1, line2, range, count, bang, mods, reg, arg, args, ...) abort
+  let dir = a:0 ? s:Dir(a:1) : s:Dir()
+  exe s:DirCheck(dir)
+  try
+    let mods = s:Mods(a:mods, 'Edge')
+    let file = fugitive#Find(':', dir)
+    let arg = ' +setl\ foldmarker=<<<<<<<<,>>>>>>>>\|let\ w:fugitive_status=FugitiveGitDir() ' .
+          \ s:fnameescape(file)
+    for tabnr in [tabpagenr()] + (mods =~# '\<tab\>' ? range(1, tabpagenr('$')) : [])
+      let bufs = tabpagebuflist(tabnr)
+      for winnr in range(1, tabpagewinnr(tabnr, '$'))
+        if s:cpath(file, fnamemodify(bufname(bufs[winnr-1]), ':p'))
+          if tabnr == tabpagenr() && winnr == winnr()
+            call s:ReloadStatus()
+          else
+            call s:ExpireStatus(dir)
+            exe tabnr . 'tabnext'
+            exe winnr . 'wincmd w'
+          endif
+          let w:fugitive_status = dir
+          1
+          return ''
+        endif
+      endfor
+    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.heading)
+    return a:fallback
+  endif
+  let line = search('^' . escape(info.heading, '^$.*[]~\') . ' (\d\++\=)$', '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
+    if type(a:dir) == type({}) && has_key(a:dir, 'args') && has_key(a:dir, 'exit_status')
+      let g:fugitive_result = a:dir
+    endif
+    exe s:DoAutocmd('User FugitiveChanged')
+  finally
+    unlet! g:fugitive_event g:fugitive_result
+    " Force statusline reload with the buffer's Git dir
+    if dir isnot# FugitiveGitDir()
+      let &l:ro = &l:ro
+    endif
+  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)
+  exe fugitive#BufReadStatus(0)
+  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 is# -2 || a:bufnr is# 0
+    let s:head_cache = {}
+    let s:last_time = reltime()
+    return ''
+  endif
+  let head_file = fugitive#Find('.git/HEAD', a:bufnr)
+  if !empty(head_file)
+    let s:last_times[s:Tree(a:bufnr) . '/'] = reltime()
+    if has_key(s:head_cache, head_file)
+      call remove(s:head_cache, head_file)
+    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:Tree() . '/', 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#DidChange(...) abort
+  call s:ExpireStatus(a:0 ? a:1 : -1)
+  if a:0 > 1 ? a:2 : (!a:0 || a:1 isnot# 0)
+    let t = reltime()
+    let t:fugitive_reload_status = t
+    for tabnr in range(1, tabpagenr('$'))
+      call settabvar(tabnr, 'fugitive_reload_status', t)
+    endfor
+    call s:ReloadTabStatus()
+  else
+    call s:ReloadWinStatus()
+    return ''
+  endif
+  exe s:DoAutocmdChanged(a:0 ? a:1 : -1)
+  return ''
+endfunction
+
+function! fugitive#ReloadStatus(...) abort
+  return call('fugitive#DidChange', a:000)
+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#DidChange(+expand('<abuf>'), 0)
+  autocmd User FileChmodPost,FileUnlinkPost call fugitive#DidChange(+expand('<abuf>'), 0)
+  autocmd ShellCmdPost,ShellFilterPost * nested call fugitive#DidChange(0)
+  autocmd BufDelete * nested
+        \ if getbufvar(+expand('<abuf>'), 'buftype') ==# 'terminal' |
+        \   if !empty(FugitiveGitDir(+expand('<abuf>'))) |
+        \     call fugitive#DidChange(+expand('<abuf>')) |
+        \   else |
+        \     call fugitive#DidChange(0) |
+        \  endif |
+        \ endif
+  autocmd QuickFixCmdPost make,lmake,[cl]file,[cl]getfile nested
+        \ call fugitive#DidChange(fugitive#EfmDir())
+  autocmd FocusGained        *
+        \ if get(g:, 'fugitive_focus_gained', !has('win32')) |
+        \   call fugitive#DidChange(0) |
+        \ endif
+  autocmd BufEnter index,index.lock,fugitive://*//
+        \ 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 [lnum, old_lnum, new_lnum] = s:HunkPosition(lnum)
+    let offset = sigil ==# '-' ? old_lnum : new_lnum
+    while getline(lnum) =~# '^[ @\+-]'
+      let lnum -= 1
+    endwhile
+  endif
+  let slnum = lnum + 1
+  let heading = ''
+  let index = 0
+  while len(getline(slnum - 1)) && empty(heading)
+    let slnum -= 1
+    let heading = matchstr(getline(slnum), '^\u\l\+.\{-\}\ze (\d\++\=)$')
+    if empty(heading) && getline(slnum) !~# '^[ @\+-]'
+      let index += 1
+    endif
+  endwhile
+  let text = matchstr(getline(lnum), '^[A-Z?] \zs.*')
+  let file = get(get(b:fugitive_files, heading, {}), text, {})
+  let relative = get(file, 'relative', len(text) ? [text] : [])
+  return {'section': matchstr(heading, '^\u\l\+'),
+        \ 'heading': heading,
+        \ 'sigil': sigil,
+        \ 'offset': offset,
+        \ 'filename': text,
+        \ 'relative': copy(relative),
+        \ 'paths': map(copy(relative), '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]'),
+        \ 'submodule': get(file, 'submodule', ''),
+        \ '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 first <= line('$') && 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 heading = ''
+  let index = 0
+  while empty(heading)
+    let slnum -= 1
+    let heading = matchstr(getline(slnum), '^\u\l\+.\{-\}\ze (\d\++\=)$')
+    if empty(heading) && getline(slnum) !~# '^[ @\+-]'
+      let index += 1
+    endif
+  endwhile
+  let results = []
+  let template = {
+        \ 'heading': heading,
+        \ 'section': matchstr(heading, '^\u\l\+'),
+        \ '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
+    let heading = matchstr(line, '^\u\l\+\ze.\{-\}\ze (\d\++\=)$')
+    if len(heading)
+      let template.heading = heading
+      let template.section = matchstr(heading, '^\u\l\+')
+      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 text = matchstr(line, '^[A-Z?] \zs.*')
+      let file = get(get(b:fugitive_files, template.heading, {}), text, {})
+      let relative = get(file, 'relative', len(text) ? [text] : [])
+      call add(results, extend(deepcopy(template), {
+            \ 'lnum': lnum,
+            \ 'filename': text,
+            \ 'relative': copy(relative),
+            \ 'paths': map(copy(relative), '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
+  normal! 0
+  for i in range(a:count)
+    if &filetype ==# 'fugitive'
+      if getline('.') =~# '^@' && getline(line('.') - 1) =~# s:file_pattern
+        -
+      endif
+      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')
+  normal! 0
+  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
+  normal! 0
+  for i in range(a:count)
+    if !search(s:item_pattern, 'Wb') && getline('.') !~# s:item_pattern
+      call search('^commit ', 'Wb')
+    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
+  normal! 0
+  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 = []
+    if info.status ==# 'U'
+      let diff_header = 'diff --cc ' . s:Quote(info.relative[0])
+    else
+      let diff_header = 'diff --git ' . s:Quote(info.relative[-1]) . ' ' . s:Quote(info.relative[0])
+    endif
+    let stdout = fugitive#Wait(b:fugitive_diff[info.section]).stdout
+    let start = index(stdout, diff_header)
+    if start == -1
+      continue
+    endif
+    let index = start + 1
+    while get(stdout, index, '@@') !~# '^@@\|^diff '
+      let index += 1
+    endwhile
+    while get(stdout, index, '') =~# '^[@ \+-]'
+      call add(diff, stdout[index])
+      let index += 1
+    endwhile
+    if len(diff)
+      setlocal modifiable noreadonly
+      silent call append(lnum, diff)
+      let b:fugitive_expanded[info.section][info.filename] = [start]
+      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.submodule =~# '^S'
+    if info.section ==# 'Staged'
+      return 'Git --paginate diff --no-ext-diff --submodule=log --cached -- ' . info.paths[0]
+    elseif info.submodule =~# '^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 . '! @:'.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'
+    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: could 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 = []
+  let diff_lines = fugitive#Wait(b:fugitive_diff[info.section]).stdout
+  while get(diff_lines, i, '@') !~# '^@'
+    let line = diff_lines[i]
+    if line ==# '--- /dev/null'
+      call add(head, '--- ' . get(diff_lines, 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 = s:ChompStderr(cmd)
+  if empty(output)
+    return 1
+  endif
+  call s:throw(output)
+endfunction
+
+function! s:StageDelete(lnum1, lnum2, count) abort
+  let restore = []
+
+  let err = ''
+  let did_conflict_err = 0
+  let reset_commit = matchstr(getline(a:lnum1), '^Un\w\+ \%(to\| from\) \zs\S\+')
+  try
+    for info in s:Selection(a:lnum1, a:lnum2)
+      if empty(info.paths)
+        if len(info.commit)
+          let reset_commit = info.commit . '^'
+        endif
+        continue
+      endif
+      let sub = get(get(get(b:fugitive_files, info.section, {}), info.filename, {}), 'submodule')
+      if sub =~# '^S' && info.status ==# 'M'
+        let undo = 'Git checkout ' . fugitive#RevParse('HEAD', FugitiveExtractGitDir(info.paths[0]))[0:10] . ' --'
+      elseif sub =~# '^S'
+        let err .= '|echoerr ' . string('fugitive: will not touch submodule ' . string(info.relative[0]))
+        break
+      elseif 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 sub =~# '^S'
+        if info.section ==# 'Staged'
+          call s:TreeChomp('reset', '--', info.paths[0])
+        endif
+        call s:TreeChomp('submodule', 'update', '--', info.paths[0])
+      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(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(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(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', '@', '--', 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)
+    if len(reset_commit) && empty(err)
+      call feedkeys(':Git reset ' . reset_commit)
+    endif
+    return err[1:-1]
+  endif
+  exe s:ReloadStatus()
+  call s:StageReveal()
+  return 'checktime|redraw|echomsg ' . string('To restore, ' . join(restore, '|')) . err
+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')
+  if !a:0
+    let dir = fugitive#Find('.git/info/')
+    if !isdirectory(dir)
+      try
+        call mkdir(dir)
+      catch
+      endtry
+    endif
+  endif
+  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' fnameescape(fugitive#Find('.git/'))
+  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\+')
+  if branch ==# '*'
+    return
+  endif
+  call feedkeys(':Git push ' . remote . ' ' . '@:' . '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\+')
+  if branch ==# '*'
+    return
+  endif
+  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'
+      execute 'tab Git reset --patch'
+      break
+    elseif empty(info.paths) && info.section ==# 'Unstaged'
+      execute 'tab Git add --patch'
+      break
+    elseif empty(info.paths) && info.section ==# 'Untracked'
+      execute 'tab Git add --interactive'
+      break
+    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 "tab Git add --patch -- ".join(map(add,'fnameescape(v:val)'))
+    endif
+    if !empty(reset)
+      execute "tab Git reset --patch -- ".join(map(reset,'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, get(a:options, 'curwin') && a:line2 < 0 ? 0 : a:line2, a:bang, a:mods, '', '', [], a:options)
+  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
+  if empty(a:options.subcommand_args) && (
+        \ filereadable(fugitive#Find('.git/MERGE_MSG', a:options)) ||
+        \ isdirectory(fugitive#Find('.git/rebase-apply', a:options)) ||
+        \  !empty(s:TreeChomp([a:options.git_dir, 'diff-files', '--diff-filter=U'])))
+    return 'echoerr ":Git merge for loading conflicts has been removed in favor of :Git 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 bisect
+
+function! s:CompleteBisect(A, L, P, ...) abort
+  let bisect_subcmd = matchstr(a:L, '\u\w*[! ] *.\{-\}\s\@<=\zs[^-[:space:]]\S*\ze ')
+  if empty(bisect_subcmd)
+    let subcmds = ['start', 'bad', 'new', 'good', 'old', 'terms', 'skip', 'next', 'reset', 'replay', 'log', 'run']
+    return s:FilterEscape(subcmds, a:A)
+  endif
+  let dir = a:0 ? a:1 : s:Dir()
+  return fugitive#CompleteObject(a:A, dir)
+endfunction
+
+function! fugitive#BisectComplete(A, L, P, ...) abort
+  return s:CompleteSub('bisect', a:A, a:L, a:P, function('s:CompleteBisect'), a:000)
+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 . s:VimSlash(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 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
+  call fugitive#Autowrite()
+  let a:state.mode = 'init'
+  let a:state.from = ''
+  let a:state.to = ''
+  let exec = s:UserCommandList({'git': a:options.git, 'git_dir': a:options.git_dir}) + ['-c', 'diff.context=0']
+  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(get(a:options, 'curwin') && a:line2 < 0 ? 0 : 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 s:SystemList(exec)[0]
+      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') . ' vertical 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.git_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 = s:Dir(a:options)
+  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(options, quiet, dir, line) abort
+  if !a:quiet
+    echo a:line
+  endif
+  let entry = {'valid': 1}
+  let match = matchlist(a:line, '^\(.\{-\}\):\([1-9]\d*\):\([1-9]\d*:\)\=\(.*\)$')
+  if a:line =~# '^git: \|^usage: \|^error: \|^fatal: \|^BUG: '
+    return {'text': a:line}
+  elseif len(match)
+    let entry.module = match[1]
+    let entry.lnum = +match[2]
+    let entry.col = +match[3]
+    let entry.text = match[4]
+  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:options.line_number
+    let match = matchlist(a:line, '^\(.\{-\}\):\(.*\)$')
+    if len(match)
+      let entry.module = match[1]
+      let entry.pattern = '\M^' . escape(match[2], '\.^$/') . '$'
+    endif
+  endif
+  if empty(entry.module) && a:options.name_count && a:line =~# ':\d\+$'
+    let entry.text = matchstr(a:line, '\d\+$')
+    let entry.module = strpart(a:line, 0, len(a:line) - len(entry.text) - 1)
+  endif
+  if empty(entry.module) && a:options.name_only
+    let entry.module = a:line
+  endif
+  if empty(entry.module)
+    return {'text': a:line}
+  endif
+  if entry.module !~# ':'
+    let entry.filename = s:PathJoin(a:options.prefix, entry.module)
+  else
+    let entry.filename = fugitive#Find(entry.module, a:dir)
+  endif
+  return entry
+endfunction
+
+let s:grep_combine_flags = '[aiIrhHEGPFnlLzocpWq]\{-\}'
+function! s:GrepOptions(args, dir) abort
+  let options = {'name_only': 0, 'name_count': 0, 'line_number': 0}
+  let tree = s:Tree(a:dir)
+  let prefix = empty(tree) ? fugitive#Find(':0:', a:dir) :
+        \ s:cpath(getcwd(), tree) ? '' : s:VimSlash(tree . '/')
+  let options.prefix = prefix
+  for arg in a:args
+    if arg ==# '--'
+      break
+    endif
+    if arg =~# '^\%(-' . s:grep_combine_flags . 'c\|--count\)$'
+      let options.name_count = 1
+    endif
+    if arg =~# '^\%(-' . s:grep_combine_flags . 'n\|--line-number\)$'
+      let options.line_number = 1
+    elseif arg =~# '^\%(--no-line-number\)$'
+      let options.line_number = 0
+    endif
+    if arg =~# '^\%(-' . s:grep_combine_flags . '[lL]\|--files-with-matches\|--name-only\|--files-without-match\)$'
+      let options.name_only = 1
+    endif
+    if arg ==# '--cached'
+      let options.prefix = fugitive#Find(':0:', a:dir)
+    elseif arg ==# '--no-cached'
+      let options.prefix = prefix
+    endif
+  endfor
+  return options
+endfunction
+
+function! s:GrepCfile(result) abort
+  let options = s:GrepOptions(a:result.args, a:result)
+  let entry = s:GrepParseLine(options, 1, a:result, getline('.'))
+  if get(entry, 'col')
+    return [entry.filename, entry.lnum, "norm!" . entry.col . "|"]
+  elseif has_key(entry, 'lnum')
+    return [entry.filename, entry.lnum]
+  elseif has_key(entry, 'pattern')
+    return [entry.filename, '', 'silent /' . entry.pattern]
+  elseif has_key(entry, 'filename')
+    return [entry.filename]
+  else
+    return []
+  endif
+endfunction
+
+function! s:GrepSubcommand(line1, line2, range, bang, mods, options) abort
+  let args = copy(a:options.subcommand_args)
+  let handle = -1
+  let quiet = 0
+  let i = 0
+  while i < len(args) && args[i] !=# '--'
+    let partition = matchstr(args[i], '^-' . s:grep_combine_flags . '\ze[qzO]')
+    if len(partition) > 1
+      call insert(args, '-' . strpart(args[i], len(partition)), i+1)
+      let args[i] = partition
+    elseif args[i] =~# '^\%(-' . s:grep_combine_flags . '[eABC]\|--max-depth\|--context\|--after-context\|--before-context\|--threads\)$'
+      let i += 1
+    elseif args[i] =~# '^\%(-O\|--open-files-in-pager\)$'
+      let handle = 1
+      call remove(args, i)
+      continue
+    elseif args[i] =~# '^\%(-O\|--open-files-in-pager=\)'
+      let handle = 0
+    elseif args[i] =~# '^-[qz].'
+      let args[i] = '-' . args[i][2:-1]
+      let quiet = 1
+    elseif args[i] =~# '^\%(-[qz]\|--quiet\)$'
+      let quiet = 1
+      call remove(args, i)
+      continue
+    elseif args[i] =~# '^--no-quiet$'
+      let quiet = 0
+    elseif args[i] =~# '^\%(--heading\)$'
+      call remove(args, i)
+      continue
+    endif
+    let i += 1
+  endwhile
+  if handle < 0 ? !quiet : !handle
+    return {}
+  endif
+  call fugitive#Autowrite()
+  let listnr = get(a:options, 'curwin') && a:line2 < 0 ? 0 : a:line2
+  if s:HasOpt(args, '--no-line-number')
+    let lc = []
+  else
+    let lc = fugitive#GitVersion(2, 19) ? ['-n', '--column'] : ['-n']
+  endif
+  let cmd = ['grep', '--no-color', '--full-name'] + lc
+  let dir = s:Dir(a:options)
+  let options = s:GrepOptions(lc + args, dir)
+  if listnr > 0
+    exe listnr 'wincmd w'
+  else
+    call s:BlurStatus()
+  endif
+  let title = (listnr < 0 ? ':Ggrep ' : ':Glgrep ') . s:fnameescape(args)
+  call s:QuickfixCreate(listnr, {'title': title})
+  let tempfile = tempname()
+  let state = {
+        \ 'git': a:options.git,
+        \ 'flags': a:options.flags,
+        \ 'args': cmd + args,
+        \ 'git_dir': s:GitDir(a:options),
+        \ 'cwd': s:UserCommandCwd(a:options),
+        \ 'filetype': 'git',
+        \ 'mods': s:Mods(a:mods),
+        \ 'file': s:Resolve(tempfile)}
+  let event = listnr < 0 ? 'grep-fugitive' : 'lgrep-fugitive'
+  exe s:DoAutocmd('QuickFixCmdPre ' . event)
+  try
+    if !quiet && &more
+      let more = 1
+      set nomore
+    endif
+    if !quiet
+      echo title
+    endif
+    let list = s:SystemList(s:UserCommandList(a:options) + cmd + args)[0]
+    call writefile(list + [''], tempfile, 'b')
+    call s:RunSave(state)
+    call map(list, 's:GrepParseLine(options, ' . quiet . ', dir, v:val)')
+    call s:QuickfixSet(listnr, list, 'a')
+    let press_enter_shortfall = &cmdheight - len(list)
+    if press_enter_shortfall > 0 && !quiet
+      echo repeat("\n", press_enter_shortfall - 1)
+    endif
+  finally
+    if exists('l:more')
+      let &more = more
+    endif
+  endtry
+  call s:RunFinished(state)
+  exe s:DoAutocmd('QuickFixCmdPost ' . event)
+  if quiet
+    let bufnr = bufnr('')
+    exe s:QuickfixOpen(listnr, a:mods)
+    if bufnr != bufnr('') && !a:bang
+      wincmd p
+    endif
+  end
+  if !a:bang && !empty(list)
+    return 'silent ' . (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 " . 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, prefix, 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 = a:prefix . 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': s:PathJoin(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': s:VimSlash(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, '^ \%(copy\|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('log ' . a:args, s:Tree(dir))
+  call remove(args, 0)
+  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 . (owner =~# '^\x\{40,}' ? '' : '^{}'))
+    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']
+  call extend(cmd, ['-c', 'diff.context=0', '-c', 'diff.noprefix=false', 'log'] +
+        \ ['--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)
+  return s:QuickfixStream(listnr, 'log', title, s:UserCommandList(dir) + cmd, !a:bang, a:mods, s:function('s:LogParse'), state, dir, s:DirUrlPrefix(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*\%(\\.\|\S\)\+')
+    let string = strpart(string, len(arg))
+    let arg = substitute(arg, '^\s\+', '', '')
+    call add(args, substitute(arg, '\\\+[|" ]', '\=submatch(0)[len(submatch(0))/2 : -1]', 'g'))
+  endwhile
+  return args
+endfunction
+
+function! s:PlusEscape(string) abort
+  return substitute(a:string, '\\*[|" ]', '\=repeat("\\", len(submatch(0))).submatch(0)', 'g')
+endfunction
+
+function! s:OpenParse(string, wants_cmd, wants_multiple) abort
+  let opts = []
+  let cmds = []
+  let args = s:ArgSplit(a:string)
+  while !empty(args)
+    if args[0] =~# '^++'
+      call add(opts, ' ' . s:PlusEscape(remove(args, 0)))
+    elseif a:wants_cmd && args[0] ==# '+'
+      call remove(args, 0)
+      call add(cmds, '$')
+    elseif a:wants_cmd && args[0] =~# '^+'
+      call add(cmds, remove(args, 0)[1:-1])
+    else
+      break
+    endif
+  endwhile
+  if !a:wants_multiple && empty(args)
+    let args = ['>:']
+  endif
+  let dir = s:Dir()
+  let wants_cmd = a:wants_cmd
+  let urls = []
+  for arg in args
+    let [url, lnum] = s:OpenExpand(dir, arg, wants_cmd)
+    if lnum
+      call insert(cmds, lnum)
+    endif
+    call add(urls, url)
+    let wants_cmd = 0
+  endfor
+
+  let pre = join(opts, '')
+  if len(cmds) > 1
+    let pre .= ' +' . s:PlusEscape(join(map(cmds, '"exe ".string(v:val)'), '|'))
+  elseif len(cmds)
+    let pre .= ' +' . s:PlusEscape(cmds[0])
+  endif
+  return [a:wants_multiple ? urls : urls[0], pre]
+endfunction
+
+function! s:OpenExpand(dir, file, wants_cmd) abort
+  if a:file ==# '-'
+    let result = fugitive#Result()
+    if has_key(result, 'file')
+      let efile = result.file
+    else
+      throw 'fugitive: no previous command output'
+    endif
+  else
+    let efile = s:Expand(a:file)
+  endif
+  let url = s:Generate(efile, a:dir)
+  if a:wants_cmd && a:file[0] ==# '>' && efile[0] !=# '>' && get(b:, 'fugitive_type', '') isnot# 'tree' && &filetype !=# 'netrw'
+    let line = line('.')
+    if s:Slash(expand('%:p')) !=# s:Slash(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([a: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
+    return [url, line]
+  endif
+  return [url, 0]
+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 +setl\ bufhidden=delete
+    endif
+    if &diff
+      call fugitive#DiffClose()
+    endif
+  endif
+endfunction
+
+let s:bang_edits = {'split': 'Git', 'vsplit': 'vertical Git', 'tabedit': 'tab Git', 'pedit': 'Git!'}
+function! fugitive#Open(cmd, bang, mods, arg, ...) abort
+  exe s:VersionCheck()
+  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
+
+  try
+    let [file, pre] = s:OpenParse(a:arg, 1, 0)
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  let mods = s:Mods(a:mods)
+  if a:cmd ==# 'edit'
+    call s:BlurStatus()
+  endif
+  return mods . a:cmd . pre . ' ' . s:fnameescape(file)
+endfunction
+
+function! fugitive#DropCommand(line1, count, range, bang, mods, arg, ...) abort
+  exe s:VersionCheck()
+
+  let mods = s:Mods(a:mods)
+  try
+    let [files, pre] = s:OpenParse(a:arg, 1, 1)
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if empty(files)
+    return 'drop'
+  endif
+  call s:BlurStatus()
+  return mods . 'drop' . ' ' . s:fnameescape(files) . substitute(pre, '^ *+', '|', '')
+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 . 'keepalt ' . mods . after . 'read', '|' . delete . 'diffupdate' . (a:count < 0 ? '|' . line('.') : '')]
+endfunction
+
+function! fugitive#ReadCommand(line1, count, range, bang, mods, arg, ...) abort
+  exe s:VersionCheck()
+  let [read, post] = s:ReadPrepare(a:line1, a:count, a:range, a:mods)
+  try
+    let [file, pre] = s:OpenParse(a:arg, 0, 0)
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if file =~# '^fugitive:' && a:count is# 0
+    return 'exe ' .string('keepalt ' . 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
+  return fugitive#EditComplete(a:A, a:L, a:P)
+endfunction
+
+" Section: :Gwrite, :Gwq
+
+function! fugitive#WriteCommand(line1, line2, range, bang, mods, arg, ...) abort
+  exe s:VersionCheck()
+  if s:cpath(expand('%:p'), fugitive#Find('.git/COMMIT_EDITMSG')) && empty(a:arg)
+    return (empty($GIT_INDEX_FILE) ? 'write|bdelete' : 'wq') . (a:bang ? '!' : '')
+  elseif get(b:, 'fugitive_type', '') ==# 'index' && empty(a:arg)
+    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('')
+  let args = s:ArgSplit(a:arg)
+  let after = ''
+  if get(args, 0) =~# '^+'
+    let after = '|' . remove(args, 0)[1:-1]
+  endif
+  try
+    let file = len(args) ? s:Generate(s:Expand(join(args, ' '))) : 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
+
+  let message = s:ChompStderr(['add'] + (a:bang ? ['--force'] : []) + ['--', file])
+  if len(message)
+    let v:errmsg = 'fugitive: '.message
+    return 'echoerr v:errmsg'
+  endif
+  if s:cpath(fugitive#Real(@%), file) && s:DirCommitFile(@%)[1] =~# '^\d$'
+    setlocal nomodified
+  endif
+
+  let one = fugitive#Find(':1:'.file)
+  let two = fugitive#Find(':2:'.file)
+  let three = fugitive#Find(':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 = fugitive#Find(':0:'.file)
+  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#DidChange()
+  return 'checktime' . after
+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! s:CompletePush(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, 'remote'])[0]
+  elseif a:A =~# ':'
+    let lead = matchstr(a:A, '^[^:]*:')
+    let matches = s:LinesError([dir, 'ls-remote', remote])[0]
+    call filter(matches, 'v:val =~# "\t" && v:val !~# "{"')
+    call map(matches, 'lead . s:sub(v:val, "^.*\t", "")')
+  else
+    let matches = s:CompleteHeads(dir)
+    if a:A =~# '^[\''"]\=+'
+      call map(matches, '"+" . v:val')
+    endif
+  endif
+  return s:FilterEscape(matches, a:A)
+endfunction
+
+function! fugitive#PushComplete(A, L, P, ...) abort
+  return s:CompleteSub('push', a:A, a:L, a:P, function('s:CompletePush'), 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
+
+function! s:PushSubcommand(...) abort
+  return {'no_more': 1}
+endfunction
+
+function! s:FetchSubcommand(...) abort
+  return {'no_more': 1}
+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:DiffModifier(count, default) abort
+  let fdc = matchstr(&diffopt, 'foldcolumn:\zs\d\+')
+  if &diffopt =~# 'horizontal' && &diffopt !~# 'vertical'
+    return ''
+  elseif &diffopt =~# 'vertical'
+    return 'vertical '
+  elseif !get(g:, 'fugitive_diffsplit_directional_fit', a:default)
+    return ''
+  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:diffthis() abort
+  if !&diff
+    let w:fugitive_diff_restore = 1
+    diffthis
+  endif
+endfunction
+
+function! s:diffoff() abort
+  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'))
+      call setwinvar(nr, 'fugitive_diff_restore', '')
+    endif
+  endfor
+  if curwin != winnr()
+    execute curwin.'wincmd w'
+  endif
+  diffoff!
+endfunction
+
+function! s:IsConflicted() abort
+  return len(@%) && !empty(s:ChompDefault('', ['ls-files', '--unmerged', '--', expand('%:p')]))
+endfunction
+
+function! fugitive#Diffsplit(autodir, keepfocus, mods, arg, ...) abort
+  exe s:VersionCheck()
+  let args = s:ArgSplit(a:arg)
+  let post = ''
+  let autodir = a:autodir
+  while get(args, 0, '') =~# '^++'
+    if args[0] =~? '^++novertical$'
+      let autodir = 0
+    else
+      return 'echoerr ' . string('fugitive: unknown option ' . args[0])
+    endif
+    call remove(args, 0)
+  endwhile
+  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 commit =~# '^1\=$' && 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('@:')]
+    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 = (autodir ? s:DiffModifier(len(parents) + 1, empty(args) || args[0] =~# '^>') : '') . s:Mods(mods, 'leftabove')
+      let nr = bufnr('')
+      if len(parents) > 1 && !&equalalways
+        let equalalways = 0
+        set equalalways
+      endif
+      execute mods 'split' s:fnameescape(fugitive#Find(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(fugitive#Find(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()
+      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 = len(commit) ? s:Relative() : s:Relative(s:IsConflicted() ? ':1:' : ':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
+      if a:keepfocus || arg =~# '^>'
+        let mods = s:Mods(a:mods, 'leftabove')
+      else
+        let mods = s:Mods(a:mods)
+      endif
+    elseif exists('parents')
+      let file = get(parents, -1, s:Relative(repeat('0', 40). ':'))
+      let mods = s:Mods(a:mods, 'leftabove')
+    elseif len(commit)
+      let file = s:Relative()
+      let mods = s:Mods(a:mods, 'rightbelow')
+    elseif s:IsConflicted()
+      let file = s:Relative(':1:')
+      let mods = s:Mods(a:mods, 'leftabove')
+      if get(g:, 'fugitive_legacy_commands', 1)
+        let post = 'echohl WarningMsg|echo "Use :Gdiffsplit! for 3 way diff"|echohl NONE|' . post
+      endif
+    else
+      exe s:DirCheck()
+      let file = s:Relative(':0:')
+      let mods = s:Mods(a:mods, 'leftabove')
+    endif
+    let spec = s:Generate(file)
+    if spec =~# '^fugitive:' && empty(s:DirCommitFile(spec)[2])
+      let spec = s:VimSlash(spec . s:Relative('/'))
+    endif
+    exe pre
+    let w:fugitive_diff_restore = 1
+    let mods = (autodir ? s:DiffModifier(2, empty(args) || args[0] =~# '^>') : '') . mods
+    if &diffopt =~# 'vertical'
+      let diffopt = &diffopt
+      set diffopt-=vertical
+    endif
+    execute mods 'diffsplit' s:fnameescape(spec)
+    let w:fugitive_diff_restore = 1
+    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('l:equalalways')
+      let &g:equalalways = equalalways
+    endif
+    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:rename
+    let default_root = expand('%:p:s?[\/]$??:h') . '/'
+  else
+    let default_root = s:Tree(dir) . '/'
+  endif
+  if a:destination =~# '^:/:\='
+    let destination = s:Tree(dir) . s:Expand(substitute(a:destination, '^:/:\=', '', ''))
+  elseif a:destination =~# '^:(top)'
+    let destination = s:Expand(matchstr(a:destination, ')\zs.*'))
+    if destination !~# '^/\|^\a\+:'
+      let destination = s:Tree(dir) . '/' . destination
+    endif
+    let destination = s:Tree(dir) .
+  elseif a:destination =~# '^:(\%(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:destination =~# '^:(literal)'
+    let destination = simplify(default_root . matchstr(a:destination, ')\zs.*'))
+  else
+    let destination = s:Expand(a:destination)
+    if destination =~# '^\.\.\=\%(/\|$\)'
+      let destination = simplify(getcwd() . '/' . destination)
+    elseif destination !~# '^\a\+:\|^/'
+      let destination = default_root . destination
+    endif
+  endif
+  let destination = s:Slash(destination)
+  if isdirectory(@%)
+    setlocal noswapfile
+  endif
+  let exec = fugitive#Execute(['mv'] + (a:force ? ['-f'] : []) + ['--', expand('%:p'), destination], dir)
+  if exec.exit_status && exec.stderr !=# ['']
+    return 'echoerr ' .string('fugitive: '.s:JoinChomp(exec.stderr))
+  endif
+  if isdirectory(destination)
+    let destination = fnamemodify(s:sub(destination,'/$','').'/'.expand('%:t'),':.')
+  endif
+  let reload = '|call fugitive#DidChange(' . string(exec) . ')'
+  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, ...) abort
+  return s:Move(a:bang, 0, a:arg)
+endfunction
+
+function! fugitive#RenameCommand(line1, line2, range, bang, mods, arg, ...) 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 = s:ChompStderr(cmd + ['--', expand('%:p')], dir)
+  if len(message)
+    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#DidChange(' . string(dir) . ')'
+  endif
+endfunction
+
+function! fugitive#RemoveCommand(line1, line2, range, bang, mods, arg, ...) abort
+  return s:Remove('edit', a:bang)
+endfunction
+
+function! fugitive#UnlinkCommand(line1, line2, range, bang, mods, arg, ...) abort
+  return s:Remove('edit', a:bang)
+endfunction
+
+function! fugitive#DeleteCommand(line1, line2, range, bang, mods, arg, ...) abort
+  return s:Remove('bdelete', a:bang)
+endfunction
+
+" Section: :Git blame
+
+function! s:Keywordprg() abort
+  let args = ' --git-dir=' . escape(FugitiveGitPath(s:GitDir()), "\\\"' ")
+  if has('gui_running') && !has('win32')
+    return s:GitShellCmd() . ' --no-pager' . args . ' log -1'
+  else
+    return s:GitShellCmd() . args . ' show'
+  endif
+endfunction
+
+function! s:linechars(pattern) abort
+  let chars = strlen(s:gsub(matchstr(getline('.'), a:pattern), '.', '.'))
+  if &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(a:0 ? a:1 : bufnr(''))
+  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 > 1 ? a:2 : s:TempState()
+  if get(state, 'filetype', '') !=# 'fugitiveblame'
+    return ['', '', 0]
+  endif
+  let commit = matchstr(line, '^\^\=[?*]*\zs\x\+')
+  if commit =~# '^0\+$'
+    let commit = ''
+  elseif has_key(state, 'blame_reverse_end')
+    let commit = get(s:LinesError([state.git_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 state = s:TempState()
+  let bufwinnr = exists('*win_id2win') ? win_id2win(get(state, 'origin_winid')) : 0
+  if bufwinnr == 0
+    let bufwinnr = bufwinnr(get(state, 'origin_bufnr', -1))
+  endif
+  if get(state, 'filetype', '') ==# 'fugitiveblame' && 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(a:options)
+  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:ChompStderr([dir, 'blame', arg])
+        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')
+      if &modified || !empty(s:DirCommitFile(@%)[1])
+        let cmd += ['--contents', tempname . '.in']
+        silent execute 'noautocmd keepalt %write ' . s:fnameescape(tempname . '.in')
+        let delete_in = 1
+      elseif &autoread
+        exe 'checktime ' . bufnr('')
+      endif
+    else
+      call fugitive#Autowrite()
+    endif
+    let basecmd = [{'git': a:options.git}, dir, '--literal-pathspecs'] + cmd + ['--'] + (len(files) ? files : [file])
+    let [err, exec_error] = s:StdoutToFile(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 = {
+            \ 'git': a:options.git,
+            \ 'flags': a:options.flags,
+            \ 'args': [a:options.subcommand] + a:options.subcommand_args,
+            \ 'git_dir': s:GitDir(a:options),
+            \ 'cwd': s:UserCommandCwd(a:options),
+            \ 'filetype': (raw ? 'git' : '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:count == 1
+        if get(a:options, 'curwin')
+          let edit = 'edit'
+        elseif a:bang
+          let edit = 'pedit'
+        else
+          let edit = 'split'
+        endif
+        return s:BlameCommit(s:Mods(a:mods) . edit, get(readfile(temp), 0, ''), temp_state)
+      elseif (a:line1 == 0 || a:range == 1) && a:count > 0
+        let edit = s:Mods(a:mods) . get(['edit', 'split', 'pedit', 'vsplit', 'tabedit', 'edit'], 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 temp_state.file = temp
+        call s:RunSave(temp_state)
+        if len(ranges + commits + files) || raw
+          let reload = '|call fugitive#DidChange(fugitive#Result(' . string(temp_state.file) . '))'
+          let mods = s:Mods(a:mods)
+          if a:count != 0
+            exe 'silent keepalt' mods get(a:options, 'curwin') ? 'edit' : '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) . reload
+          endif
+          return reload[1 : -1]
+        endif
+        if a:mods =~# '\<tab\>'
+          silent tabedit %
+        endif
+        let temp_state.origin_bufnr = bufnr('')
+        if exists('*win_getid')
+          let temp_state.origin_winid = win_getid()
+        endif
+        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
+          let win_blame_bufnr = s:BlameBufnr(winbufnr(winnr))
+          if getwinvar(winnr, '&scrollbind') ? win_blame_bufnr == temp_state.origin_bufnr : win_blame_bufnr > 0
+            execute winbufnr(winnr).'bdelete'
+          endif
+        endfor
+        let restore_winnr = get(temp_state, 'origin_winid', 'bufwinnr(' . temp_state.origin_bufnr . ')')
+        if !&l:scrollbind
+          call add(restore, 'call setwinvar(' . restore_winnr . ',"&scrollbind",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
+        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
+        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)
+        redraw
+        syncbind
+        exe s:DoAutocmdChanged(temp_state)
+      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 = '@'
+    let suffix = ''
+  endif
+  let offset = line('.') - line('w0')
+  let state = s:TempState()
+  let flags = get(state, 'blame_flags', [])
+  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
+  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 x in split('01234567890abcdef', '\zs')
+    exe 'syn match FugitiveblameHashGroup'.x '"\%(^\^\=[*?]*\)\@<='.x.'\x\{5,\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite'
+  endfor
+  for lnum in range(1, line('$'))
+    let orig_hash = matchstr(getline(lnum), '^\^\=[*?]*\zs\x\{6\}')
+    let hash = orig_hash
+    let hash = substitute(hash, '\(\x\)\x', '\=submatch(1).printf("%x", 15-str2nr(submatch(1),16))', 'g')
+    let hash = substitute(hash, '\(\x\x\)', '\=printf("%02x", str2nr(submatch(1),16)*3/4+32)', 'g')
+    if hash ==# '' || orig_hash ==# '000000' || has_key(seen, hash)
+      continue
+    endif
+    let seen[hash] = 1
+    if &t_Co == 256
+      let [s, r, g, b; __] = map(matchlist(orig_hash, '\(\x\)\x\(\x\)\x\(\x\)\x'), 'str2nr(v:val,16)')
+      let color = 16 + (r + 1) / 3 * 36 + (g + 1) / 3 * 6 + (b + 1) / 3
+      if color == 16
+        let color = 235
+      elseif color == 231
+        let color = 255
+      endif
+      let s:hash_colors[hash] = ' ctermfg='.color
+    else
+      let s:hash_colors[hash] = ''
+    endif
+    let pattern = substitute(orig_hash, '^\(\x\)\x\(\x\)\x\(\x\)\x$', '\1\\x\2\\x\3\\x', '') . '*'
+    exe 'syn match FugitiveblameHash'.hash.'       "\%(^\^\=[*?]*\)\@<='.pattern.'" contained containedin=FugitiveblameHashGroup' . orig_hash[0]
+  endfor
+  syn match FugitiveblameUncommitted "\%(^\^\=[?*]*\)\@<=\<0\{7,\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameScoreDebug,FugitiveblameOriginalLineNumber,FugitiveblameOriginalFile skipwhite
+  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 . cterm
+    else
+      exe 'hi link FugitiveblameHash'.hash.' Identifier'
+    endif
+  endfor
+endfunction
+
+function! s:BlameMaps(is_ftplugin) abort
+  let ft = a:is_ftplugin
+  call s:MapGitOps(ft)
+  call s:Map('n', '<F1>', ':help :Git_blame<CR>', '<silent>', ft)
+  call s:Map('n', 'g?',   ':help :Git_blame<CR>', '<silent>', ft)
+  call s:Map('n', 'gq',   ':exe <SID>BlameQuit()<CR>', '<silent>', ft)
+  call s:Map('n', '<2-LeftMouse>', ':<C-U>exe <SID>BlameCommit("exe <SID>BlameLeave()<Bar>edit")<CR>', '<silent>', ft)
+  call s:Map('n', '<CR>', ':<C-U>exe <SID>BlameCommit("exe <SID>BlameLeave()<Bar>edit")<CR>', '<silent>', ft)
+  call s:Map('n', '-',    ':<C-U>exe <SID>BlameJump("")<CR>', '<silent>', ft)
+  call s:Map('n', 's',    ':<C-U>exe <SID>BlameJump("")<CR>', '<silent>', ft)
+  call s:Map('n', 'u',    ':<C-U>exe <SID>BlameJump("")<CR>', '<silent>', ft)
+  call s:Map('n', 'P',    ':<C-U>exe <SID>BlameJump("^".v:count1)<CR>', '<silent>', ft)
+  call s:Map('n', '~',    ':<C-U>exe <SID>BlameJump("~".v:count1)<CR>', '<silent>', ft)
+  call s:Map('n', 'i',    ':<C-U>exe <SID>BlameCommit("exe <SID>BlameLeave()<Bar>edit")<CR>', '<silent>', ft)
+  call s:Map('n', 'o',    ':<C-U>exe <SID>BlameCommit("split")<CR>', '<silent>', ft)
+  call s:Map('n', 'O',    ':<C-U>exe <SID>BlameCommit("tabedit")<CR>', '<silent>', ft)
+  call s:Map('n', 'p',    ':<C-U>exe <SID>BlameCommit("pedit")<CR>', '<silent>', ft)
+  exe s:Map('n', '.',    ":<C-U> <C-R>=substitute(<SID>BlameCommitFileLnum()[0],'^$','@','')<CR><Home>", '', ft)
+  exe s:Map('n', '(',    "-", '', ft)
+  exe s:Map('n', ')',    "+", '', ft)
+  call s:Map('n', 'A',    ":<C-u>exe 'vertical resize '.(<SID>linechars('.\\{-\\}\\ze [0-9:/+-][0-9:/+ -]* \\d\\+)')+1+v:count)<CR>", '<silent>', ft)
+  call s:Map('n', 'C',    ":<C-u>exe 'vertical resize '.(<SID>linechars('^\\S\\+')+1+v:count)<CR>", '<silent>', ft)
+  call s:Map('n', 'D',    ":<C-u>exe 'vertical resize '.(<SID>linechars('.\\{-\\}\\ze\\d\\ze\\s\\+\\d\\+)')+1-v:count)<CR>", '<silent>', ft)
+endfunction
+
+function! fugitive#BlameFileType() abort
+  setlocal nomodeline
+  setlocal foldmethod=manual
+  if len(s:GitDir())
+    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:BlameMaps(1)
+endfunction
+
+function! s:BlameCursorSync(bufnr, line) abort
+  if a:line == line('.')
+    return
+  endif
+  if get(s:TempState(), 'origin_bufnr') == a:bufnr || get(s:TempState(a:bufnr), 'origin_bufnr') == bufnr('')
+    if &startofline
+      execute a:line
+    else
+      let pos = getpos('.')
+      let pos[1] = a:line
+      call setpos('.', pos)
+    endif
+  endif
+endfunction
+
+augroup fugitive_blame
+  autocmd!
+  autocmd ColorScheme,GUIEnter * call s:BlameRehighlight()
+  autocmd BufWinLeave * execute getwinvar(+bufwinnr(+expand('<abuf>')), 'fugitive_leave')
+  autocmd WinLeave * let s:cursor_for_blame = [bufnr(''), line('.')]
+  autocmd WinEnter * if exists('s:cursor_for_blame') | call call('s:BlameCursorSync', s:cursor_for_blame) | endif
+augroup END
+
+" Section: :GBrowse
+
+function! s:BrowserOpen(url, mods, echo_copy) abort
+  let [_, main, query, anchor; __] = matchlist(a:url, '^\([^#?]*\)\(?[^#]*\)\=\(#.*\)\=')
+  let url = main . tr(query, ' ', '+') . anchor
+  let url = substitute(url, '[ <>\|"]', '\="%".printf("%02X",char2nr(submatch(0)))', 'g')
+  let mods = s:Mods(a:mods)
+  if a:echo_copy
+    if has('clipboard')
+      let @+ = url
+    endif
+    return 'echo '.string(url)
+  elseif exists(':Browse') == 2
+    return 'echo '.string(url).'|' . mods . 'Browse '.url
+  elseif exists(':OpenBrowser') == 2
+    return 'echo '.string(url).'|' . mods . 'OpenBrowser '.url
+  else
+    if !exists('g:loaded_netrw')
+      runtime! autoload/netrw.vim
+    endif
+    if exists('*netrw#BrowseX')
+      return 'echo '.string(url).'|' . mods . 'call netrw#BrowseX('.string(url).', 0)'
+    elseif exists('*netrw#NetrwBrowseX')
+      return 'echo '.string(url).'|' . mods . 'call netrw#NetrwBrowseX('.string(url).', 0)'
+    else
+      return 'echoerr ' . string('Netrw not found. Define your own :Browse to use :GBrowse')
+    endif
+  endif
+endfunction
+
+function! fugitive#BrowseCommand(line1, count, range, bang, mods, arg, ...) abort
+  exe s:VersionCheck()
+  let dir = s:Dir()
+  try
+    let arg = a:arg
+    if arg =~# '^++\%([Gg]it\)\=[Rr]emote='
+      let remote = matchstr(arg, '^++\%([Gg]it\)\=[Rr]emote=\zs\S\+')
+      let arg = matchstr(arg, '\s\zs\S.*')
+    endif
+    let validremote = '\.\%(git\)\=\|\.\=/.*\|\a[[:alnum:]_-]*\%(://.\{-\}\)\='
+    if arg ==# '-'
+      let remote = ''
+      let rev = ''
+      let result = fugitive#Result()
+      if filereadable(get(result, 'file', ''))
+        let rev = s:fnameescape(result.file)
+      else
+        return 'echoerr ' . string('fugitive: could not find prior :Git invocation')
+      endif
+    elseif !exists('l:remote')
+      let remote = matchstr(arg, '\\\@<!\%(\\\\\)*[!@]\zs\%('.validremote.'\)$')
+      let rev = strpart(arg, 0, len(arg) - len(remote) - (empty(remote) ? 0 : 1))
+    else
+      let rev = arg
+    endif
+    let expanded = s:Expand(rev)
+    if expanded =~? '^\a\a\+:[\/][\/]' && expanded !~? '^fugitive:'
+      return s:BrowserOpen(s:Slash(expanded), a:mods, a:bang)
+    endif
+    if !exists('l:result')
+      let result = s:TempState(empty(expanded) ? bufnr('') : expanded)
+    endif
+    if !get(result, 'origin_bufnr', 1) && filereadable(get(result, 'file', ''))
+      for line in readfile(result.file, '', 4096)
+        let rev = s:fnameescape(matchstr(line, '\<https\=://[^[:space:]<>]*[^[:space:]<>.,;:"''!?]'))
+        if len(rev)
+          return s:BrowserOpen(rev, a:mods, a:bang)
+        endif
+      endfor
+      return 'echoerr ' . string('fugitive: no URL found in output of :Git')
+    endif
+    if empty(remote) && expanded =~# '^[^-./:^~][^:^~]*$' && !empty(dir)
+      let config = fugitive#Config(dir)
+      if !empty(FugitiveConfigGet('remote.' . expanded . '.url', config))
+        let remote = expanded
+        let expanded = ''
+      endif
+    endif
+    if empty(expanded)
+      let bufname = &buftype =~# '^\%(nofile\|terminal\)$' ? '' : s:BufName('%')
+      let expanded = s:DirRev(bufname)[1]
+      if empty(expanded)
+        let expanded = fugitive#Path(bufname, ':(top)', dir)
+      endif
+      if a:count > 0 && has_key(result, 'origin_bufnr') && a:range != 2
+        let blame = s:BlameCommitFileLnum(getline(a:count))
+        if len(blame[0])
+          let expanded = blame[0]
+        endif
+      endif
+    endif
+    let full = s:Generate(expanded, dir)
+    let commit = ''
+    let ref = ''
+    let forbid_ref_as_commit = 0
+    if full =~# '^fugitive:'
+      let [dir, commit, path] = s:DirCommitFile(full)
+      if commit =~# '^\d\=$'
+        let commit = ''
+        let type = path =~# '^/\=$' ? 'tree' : 'blob'
+      else
+        let ref_match = matchlist(expanded, '^\(@{\@!\|[^:~^@]\+\)\(:\%(//\)\@!\|[~^@]\|$\)')
+        let ref = get(ref_match, 1, '')
+        let forbid_ref_as_commit = ref =~# '^@\=$' || ref_match[2] !~# '^:\=$'
+        if empty(path) && !forbid_ref_as_commit
+          let type = 'ref'
+        else
+          let type = s:ChompDefault(empty(path) ? 'commit': 'blob',
+                \ ['cat-file', '-t', commit . substitute(path, '^/', ':', '')], dir)
+        endif
+      endif
+      let path = path[1:-1]
+    elseif !empty(s:Tree(dir))
+      let relevant_dir = FugitiveExtractGitDir(full)
+      if !empty(relevant_dir)
+        let dir = relevant_dir
+      endif
+      let path = fugitive#Path(full, '/', dir)[1:-1]
+      if empty(path) || isdirectory(full)
+        let type = 'tree'
+      else
+        let type = 'blob'
+      endif
+    else
+      let path = '.git/' . full[strlen(dir)+1:-1]
+      let type = ''
+    endif
+    exe s:DirCheck(dir)
+    if path =~# '^\.git/'
+      let ref = matchstr(path, '^.git/\zs\%(refs/[^/]\+/[^/].*\|\w*HEAD\)$')
+      let type = empty(ref) ? 'root': 'ref'
+      let path = ''
+    endif
+    if empty(ref) || ref ==# 'HEAD' || ref ==# '@'
+      let ref = fugitive#Head(-1, dir)
+    endif
+    if ref =~# '^\x\{40,\}$'
+      let ref = ''
+    elseif !empty(ref) && ref !~# '^refs/'
+      let ref = FugitiveExecute(['rev-parse', '--symbolic-full-name', ref], dir).stdout[0]
+      if ref !~# '^refs/'
+        let ref = ''
+      endif
+    endif
+
+    if !exists('l:config') || s:Dir(config) !=# dir
+      let config = fugitive#Config(dir)
+    endif
+    let merge = ''
+    if !empty(remote) && ref =~# '^refs/remotes/[^/]\+/[^/]\|^refs/heads/[^/]'
+      let merge = matchstr(ref, '^refs/\%(heads/\|remotes/[^/]\+/\)\zs.\+')
+      let ref = 'refs/heads/' . merge
+    elseif ref =~# '^refs/remotes/[^/]\+/[^/]'
+      let remote = matchstr(ref, '^refs/remotes/\zs[^/]\+')
+      let merge = matchstr(ref, '^refs/remotes/[^/]\+/\zs.\+')
+      let ref = 'refs/heads/' . merge
+    elseif ref =~# '^refs/heads/[^/]'
+      let merge = strpart(ref, 11)
+      let r = FugitiveConfigGet('branch.' . merge . '.remote', config)
+      let m = FugitiveConfigGet('branch.' . merge . '.merge', config)[11:-1]
+      if r ==# '.' && !empty(m)
+        let r2 = FugitiveConfigGet('branch.'.m.'.remote', config)
+        if r2 !~# '^\.\=$'
+          let r = r2
+          let m = FugitiveConfigGet('branch.'.m.'.merge', config)[11:-1]
+        endif
+      endif
+      if r !~# '^\.\=$'
+        let remote = r
+      endif
+      if !empty(remote)
+        let remote_ref = 'refs/remotes/' . remote . '/' . merge
+        if FugitiveConfigGet('push.default', config) ==# 'upstream' ||
+              \ !filereadable(FugitiveFind('.git/' . remote_ref, dir)) && empty(s:ChompDefault('', ['rev-parse', '--verify', remote_ref, '--'], dir))
+          let merge = m
+          let ref = 'refs/heads/' . merge
+        endif
+      endif
+    endif
+
+    if empty(remote) || remote ==# '.'
+      let remote = s:RemoteDefault(config)
+    endif
+    if empty(merge) || empty(remote)
+      let provider_ref = ref
+    else
+      let provider_ref = 'refs/remotes/' . remote . '/' . merge
+    endif
+    if forbid_ref_as_commit || a:count >= 0
+      let ref = ''
+      if type ==# 'ref'
+        let type = 'commit'
+      endif
+    elseif type ==# 'ref' && ref =~# '^refs/\%(heads\|tags\)/[^/]'
+        let commit = matchstr(ref, '^\Crefs/\%(heads\|tags\)/\zs.*')
+    endif
+
+    let line1 = a:count > 0 && type ==# 'blob' ? a:line1 : 0
+    let line2 = a:count > 0 && type ==# 'blob' ? a:count : 0
+    if empty(commit) && type =~# '^\%(tree\|blob\)$'
+      if a:count < 0
+        let commit = matchstr(ref, '^\Crefs/\%(heads\|tags\)/\zs.*')
+      elseif len(provider_ref)
+        let owner = s:Owner(@%, dir)
+        let commit = s:ChompDefault('', ['merge-base', provider_ref, empty(owner) ? '@' : owner, '--'], dir)
+        if line2 > 0 && empty(arg) && commit =~# '^\x\{40,\}$' && type ==# 'blob'
+          let blame_list = tempname()
+          call writefile([commit, ''], blame_list, 'b')
+          let blame_cmd = ['-c', 'blame.coloring=none', 'blame', '-L', line1.','.line2, '-S', blame_list, '-s', '--show-number']
+          if !&l:modified || has_key(result, 'origin_bufnr')
+            let [blame, exec_error] = s:LinesError(blame_cmd + ['./' . path], dir)
+          else
+            let blame_in = tempname()
+            silent exe 'noautocmd keepalt %write' blame_in
+            let [blame, exec_error] = s:LinesError(blame_cmd + ['--contents', blame_in, './' . path], dir)
+            call delete(blame_in)
+          endif
+          call delete(blame_list)
+          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
+              throw "fugitive: can't browse to unpushed change"
+            endif
+          endif
+        endif
+      endif
+      if empty(commit)
+        let commit = fugitive#RevParse(empty(ref) ? 'HEAD' : ref, dir)
+      endif
+    endif
+
+    if remote =~# ':'
+      let remote_url = remote
+    else
+      let remote_url = fugitive#RemoteUrl(remote, config)
+    endif
+    let raw = empty(remote_url) ? remote : remote_url
+    let git_dir = s:GitDir(dir)
+
+    let opts = {
+          \ 'git_dir': git_dir,
+          \ 'repo': {'git_dir': git_dir},
+          \ 'remote': raw,
+          \ 'remote_name': remote,
+          \ 'commit': s:UrlEncode(commit),
+          \ 'path': substitute(s:UrlEncode(path), '%20', ' ', 'g'),
+          \ 'type': type,
+          \ 'line1': line1,
+          \ 'line2': line2}
+
+    if empty(path)
+      if type ==# 'ref' && ref =~# '^refs/'
+        let opts.path = '.git/' . s:UrlEncode(ref)
+        let opts.type = ''
+      elseif type ==# 'root'
+        let opts.path ='.git/index'
+        let opts.type = ''
+      endif
+    elseif type ==# 'tree' && !empty(path)
+      let opts.path = s:sub(opts.path, '/\=$', '/')
+    endif
+
+    for l:.Handler in get(g:, 'fugitive_browse_handlers', [])
+      let l:.url = call(Handler, [copy(opts)])
+      if type(url) == type('') && url =~# '://'
+        return s:BrowserOpen(url, a:mods, a:bang)
+      endif
+    endfor
+
+    if !empty(remote_url)
+      return 'echoerr ' . string("fugitive: no GBrowse handler installed for '".remote_url."'")
+    else
+      return 'echoerr ' . string("fugitive: could not find remote named '".remote."'")
+    endif
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+endfunction
+
+" Section: Maps
+
+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>', '<unique>', 1)
+  endif
+endfunction
+
+function! s:ContainingCommit() abort
+  let commit = s:Owner(@%)
+  return empty(commit) ? '@' : 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('.'), '\S\@<!\x\{4,\}\S\@!')
+  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 = '@^{}'
+    elseif rev =~# ':$'
+      let rev = rev[0:-2]
+    else
+      return rev.'~'.c
+    endif
+    let c -= 1
+  endwhile
+  return rev
+endfunction
+
+function! s:ParseDiffHeader(str) abort
+  let list = matchlist(a:str, '\Cdiff --git \("\=\w/.*\|/dev/null\) \("\=\w/.*\|/dev/null\)$')
+  if empty(list)
+    let list = matchlist(a:str, '\Cdiff --git \("\=[^/].*\|/dev/null\) \("\=[^/].*\|/dev/null\)$')
+  endif
+  return [fugitive#Unquote(get(list, 1, '')), fugitive#Unquote(get(list, 2, ''))]
+endfunction
+
+function! s:HunkPosition(lnum) abort
+  let lnum = a:lnum + get({'@': 1, '\': -1}, getline(a:lnum)[0], 0)
+  let offsets = {' ': -1, '+': 0, '-': 0}
+  let sigil = getline(lnum)[0]
+  let line_char = sigil
+  while has_key(offsets, line_char)
+    let offsets[line_char] += 1
+    let lnum -= 1
+    let line_char = getline(lnum)[0]
+  endwhile
+  let starts = matchlist(getline(lnum), '^@@\+[ 0-9,-]* -\(\d\+\)\%(,\d\+\)\= +\(\d\+\)[ ,]')
+  if empty(starts)
+    return [0, 0, 0]
+  endif
+  return [lnum,
+        \ sigil ==# '+' ? 0 : starts[1] + offsets[' '] + offsets['-'],
+        \ sigil ==# '-' ? 0 : starts[2] + offsets[' '] + offsets['+']]
+endfunction
+
+function! s:MapMotion(lhs, rhs) abort
+  let maps = [
+        \ s:Map('n', a:lhs, ":<C-U>" . a:rhs . "<CR>", "<silent>"),
+        \ s:Map('o', a:lhs, ":<C-U>" . a:rhs . "<CR>", "<silent>"),
+        \ s:Map('x', a:lhs, ":<C-U>exe 'normal! gv'<Bar>" . a:rhs . "<CR>", "<silent>")]
+  call filter(maps, '!empty(v:val)')
+  return join(maps, '|')
+endfunction
+
+function! s:MapGitOps(is_ftplugin) abort
+  let ft = a:is_ftplugin
+  if &modifiable
+    return ''
+  endif
+  exe s:Map('n', 'c<Space>', ':Git commit<Space>', '', ft)
+  exe s:Map('n', 'c<CR>', ':Git commit<CR>', '', ft)
+  exe s:Map('n', 'cv<Space>', ':tab Git commit -v<Space>', '', ft)
+  exe s:Map('n', 'cv<CR>', ':tab Git commit -v<CR>', '', ft)
+  exe s:Map('n', 'ca', ':<C-U>Git commit --amend<CR>', '<silent>', ft)
+  exe s:Map('n', 'cc', ':<C-U>Git commit<CR>', '<silent>', ft)
+  exe s:Map('n', 'ce', ':<C-U>Git commit --amend --no-edit<CR>', '<silent>', ft)
+  exe s:Map('n', 'cw', ':<C-U>Git commit --amend --only<CR>', '<silent>', ft)
+  exe s:Map('n', 'cva', ':<C-U>tab Git commit -v --amend<CR>', '<silent>', ft)
+  exe s:Map('n', 'cvc', ':<C-U>tab Git commit -v<CR>', '<silent>', ft)
+  exe s:Map('n', 'cRa', ':<C-U>Git commit --reset-author --amend<CR>', '<silent>', ft)
+  exe s:Map('n', 'cRe', ':<C-U>Git commit --reset-author --amend --no-edit<CR>', '<silent>', ft)
+  exe s:Map('n', 'cRw', ':<C-U>Git commit --reset-author --amend --only<CR>', '<silent>', ft)
+  exe s:Map('n', 'cf', ':<C-U>Git commit --fixup=<C-R>=<SID>SquashArgument()<CR>', '', ft)
+  exe 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>', '', ft)
+  exe s:Map('n', 'cs', ':<C-U>Git commit --no-edit --squash=<C-R>=<SID>SquashArgument()<CR>', '', ft)
+  exe 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>', '', ft)
+  exe s:Map('n', 'cA', ':<C-U>Git commit --edit --squash=<C-R>=<SID>SquashArgument()<CR>', '', ft)
+  exe s:Map('n', 'c?', ':<C-U>help fugitive_c<CR>', '<silent>', ft)
+
+  exe s:Map('n', 'cr<Space>', ':Git revert<Space>', '', ft)
+  exe s:Map('n', 'cr<CR>', ':Git revert<CR>', '', ft)
+  exe s:Map('n', 'crc', ':<C-U>Git revert <C-R>=<SID>SquashArgument()<CR><CR>', '<silent>', ft)
+  exe s:Map('n', 'crn', ':<C-U>Git revert --no-commit <C-R>=<SID>SquashArgument()<CR><CR>', '<silent>', ft)
+  exe s:Map('n', 'cr?', ':<C-U>help fugitive_cr<CR>', '<silent>', ft)
+
+  exe s:Map('n', 'cm<Space>', ':Git merge<Space>', '', ft)
+  exe s:Map('n', 'cm<CR>', ':Git merge<CR>', '', ft)
+  exe s:Map('n', 'cmt', ':Git mergetool', '', ft)
+  exe s:Map('n', 'cm?', ':<C-U>help fugitive_cm<CR>', '<silent>', ft)
+
+  exe s:Map('n', 'cz<Space>', ':Git stash<Space>', '', ft)
+  exe s:Map('n', 'cz<CR>', ':Git stash<CR>', '', ft)
+  exe s:Map('n', 'cza', ':<C-U>Git stash apply --quiet --index stash@{<C-R>=v:count<CR>}<CR>', '', ft)
+  exe s:Map('n', 'czA', ':<C-U>Git stash apply --quiet stash@{<C-R>=v:count<CR>}<CR>', '', ft)
+  exe s:Map('n', 'czp', ':<C-U>Git stash pop --quiet --index stash@{<C-R>=v:count<CR>}<CR>', '', ft)
+  exe s:Map('n', 'czP', ':<C-U>Git stash pop --quiet stash@{<C-R>=v:count<CR>}<CR>', '', ft)
+  exe s:Map('n', 'czs', ':<C-U>Git stash push --staged<CR>', '', ft)
+  exe s:Map('n', 'czv', ':<C-U>exe "Gedit" fugitive#RevParse("stash@{" . v:count . "}")<CR>', '<silent>', ft)
+  exe s:Map('n', 'czw', ':<C-U>Git stash push --keep-index<C-R>=v:count > 1 ? " --all" : v:count ? " --include-untracked" : ""<CR><CR>', '', ft)
+  exe s:Map('n', 'czz', ':<C-U>Git stash push <C-R>=v:count > 1 ? " --all" : v:count ? " --include-untracked" : ""<CR><CR>', '', ft)
+  exe s:Map('n', 'cz?', ':<C-U>help fugitive_cz<CR>', '<silent>', ft)
+
+  exe s:Map('n', 'co<Space>', ':Git checkout<Space>', '', ft)
+  exe s:Map('n', 'co<CR>', ':Git checkout<CR>', '', ft)
+  exe s:Map('n', 'coo', ':<C-U>Git checkout <C-R>=substitute(<SID>SquashArgument(),"^$",get(<SID>TempState(),"filetype","") ==# "git" ? expand("<cfile>") : "","")<CR> --<CR>', '', ft)
+  exe s:Map('n', 'co?', ':<C-U>help fugitive_co<CR>', '<silent>', ft)
+
+  exe s:Map('n', 'cb<Space>', ':Git branch<Space>', '', ft)
+  exe s:Map('n', 'cb<CR>', ':Git branch<CR>', '', ft)
+  exe s:Map('n', 'cb?', ':<C-U>help fugitive_cb<CR>', '<silent>', ft)
+
+  exe s:Map('n', 'r<Space>', ':Git rebase<Space>', '', ft)
+  exe s:Map('n', 'r<CR>', ':Git rebase<CR>', '', ft)
+  exe s:Map('n', 'ri', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><CR>', '<silent>', ft)
+  exe s:Map('n', 'rf', ':<C-U>Git -c sequence.editor=true rebase --interactive --autosquash<C-R>=<SID>RebaseArgument()<CR><CR>', '<silent>', ft)
+  exe s:Map('n', 'ru', ':<C-U>Git rebase --interactive @{upstream}<CR>', '<silent>', ft)
+  exe s:Map('n', 'rp', ':<C-U>Git rebase --interactive @{push}<CR>', '<silent>', ft)
+  exe s:Map('n', 'rw', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/reword/e<CR>', '<silent>', ft)
+  exe s:Map('n', 'rm', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/edit/e<CR>', '<silent>', ft)
+  exe s:Map('n', 'rd', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/drop/e<CR>', '<silent>', ft)
+  exe s:Map('n', 'rk', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/drop/e<CR>', '<silent>', ft)
+  exe s:Map('n', 'rx', ':<C-U>Git rebase --interactive<C-R>=<SID>RebaseArgument()<CR><Bar>s/^pick/drop/e<CR>', '<silent>', ft)
+  exe s:Map('n', 'rr', ':<C-U>Git rebase --continue<CR>', '<silent>', ft)
+  exe s:Map('n', 'rs', ':<C-U>Git rebase --skip<CR>', '<silent>', ft)
+  exe s:Map('n', 're', ':<C-U>Git rebase --edit-todo<CR>', '<silent>', ft)
+  exe s:Map('n', 'ra', ':<C-U>Git rebase --abort<CR>', '<silent>', ft)
+  exe s:Map('n', 'r?', ':<C-U>help fugitive_r<CR>', '<silent>', ft)
+endfunction
+
+function! fugitive#MapJumps(...) abort
+  if !&modifiable
+    if get(b:, 'fugitive_type', '') ==# 'blob'
+      let blame_tail = '<C-R>=v:count ? " --reverse" : ""<CR><CR>'
+      exe s:Map('n', '<2-LeftMouse>', ':<C-U>0,1Git ++curwin blame' . blame_tail, '<silent>')
+      exe s:Map('n', '<CR>', ':<C-U>0,1Git ++curwin blame' . blame_tail, '<silent>')
+      exe s:Map('n', 'o',    ':<C-U>0,1Git blame' . blame_tail, '<silent>')
+      exe s:Map('n', 'p',    ':<C-U>0,1Git blame!' . blame_tail, '<silent>')
+      if has('patch-7.4.1898')
+        exe s:Map('n', 'gO',   ':<C-U>vertical 0,1Git blame' . blame_tail, '<silent>')
+        exe s:Map('n', 'O',    ':<C-U>tab 0,1Git blame' . blame_tail, '<silent>')
+      else
+        exe s:Map('n', 'gO',   ':<C-U>0,4Git blame' . blame_tail, '<silent>')
+        exe s:Map('n', 'O',    ':<C-U>0,5Git blame' . blame_tail, '<silent>')
+      endif
+
+      call s:Map('n', 'D', ":echoerr 'fugitive: D has been removed in favor of dd'<CR>", '<silent><unique>')
+      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')
+        call s:Map('n', '<C-P>', ':exe <SID>PreviousItem(v:count1)<Bar>echohl WarningMsg<Bar>echo "CTRL-P is deprecated in favor of ("<Bar>echohl NONE<CR>', '<unique>')
+        call s:Map('n', '<C-N>', ':exe <SID>NextItem(v:count1)<Bar>echohl WarningMsg<Bar>echo "CTRL-N is deprecated in favor of )"<Bar>echohl NONE<CR>', '<unique>')
+      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><unique>')
+    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><unique>')
+    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-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
+  call s:MapGitOps(0)
+endfunction
+
+function! fugitive#GX() abort
+  try
+    let results = &filetype ==# 'fugitive' ? s:CfilePorcelain() : &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:CfilePorcelain(...) 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#PorcelainCfile() abort
+  let file = fugitive#Find(s:CfilePorcelain()[0])
+  return empty(file) ? fugitive#Cfile() : s:fnameescape(file)
+endfunction
+
+function! s:StatusCfile(...) 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 = fugitive#Find(get(s:StatusCfile(), 0, ''))
+  return empty(file) ? fugitive#Cfile() : s:fnameescape(file)
+endfunction
+
+function! s:BranchCfile(result) abort
+  return matchstr(getline('.'), '^. \zs\S\+')
+endfunction
+
+let s:diff_header_pattern = '^diff --git \%("\=[abciow12]/.*\|/dev/null\) \%("\=[abciow12]/.*\|/dev/null\)$'
+function! s:cfile() abort
+  let temp_state = s:TempState()
+  let name = substitute(get(get(temp_state, 'args', []), 0, ''), '\%(^\|-\)\(\l\)', '\u\1', 'g')
+  if exists('*s:' . name . 'Cfile')
+    let cfile = s:{name}Cfile(temp_state)
+    if !empty(cfile)
+      return type(cfile) == type('') ? [cfile] : cfile
+    endif
+  endif
+  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(temp_state, '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('.') =~# '^[A-Z]\d*\t\S' && len(myhash)
+        let files = split(getline('.'), "\t")[1:-1]
+        let ref = 'b/' . files[-1]
+        if getline('.') =~# '^D'
+          let ref = 'a/' . files[0]
+        elseif getline('.') !~# '^A'
+          let dcmds = ['', 'Gdiffsplit! >' . myhash . '^:' . fnameescape(files[0])]
+        endif
+
+      elseif getline('.') =~# '^[+-]'
+        let [header_lnum, old_lnum, new_lnum] = s:HunkPosition(line('.'))
+        if new_lnum > 0
+          let ref = s:ParseDiffHeader(getline(search(s:diff_header_pattern, 'bnW')))[1]
+          let dcmds = [new_lnum, 'normal!zv']
+        elseif old_lnum > 0
+          let ref = s:ParseDiffHeader(getline(search(s:diff_header_pattern, 'bnW')))[0]
+          let dcmds = [old_lnum, 'normal!zv']
+        else
+          let ref = fugitive#Unquote(matchstr(getline('.'), '\C[+-]\{3\} \zs"\=[abciow12]/.*'))
+        endif
+
+      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(s:diff_header_pattern, 'bcnW'))
+        let offset = matchstr(getline('.'), '+\zs\d\+')
+
+        let [dref, ref] = s:ParseDiffHeader(diff)
+        let dcmd = 'Gdiffsplit! +'.offset
+
+      elseif getline('.') =~# s:diff_header_pattern
+        let [dref, ref] = s:ParseDiffHeader(getline('.'))
+        let dcmd = 'Gdiffsplit!'
+
+      elseif getline('.') =~# '^index ' && getline(line('.')-1) =~# s:diff_header_pattern
+        let [dref, ref] = s:ParseDiffHeader(getline(line('.') - '.'))
+        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), "@:")', '')
+      if exists('dref')
+        let dref = substitute(dref, '^\(\w\)/', '\=get(prefixes, submatch(1), "@:")', '')
+      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:CfilePorcelain() : &filetype ==# 'gitcommit' ? s:StatusCfile() : s:cfile()
+  catch /^fugitive:/
+    return 'echoerr ' . string(v:exception)
+  endtry
+  if len(results) > 1
+    let cmd = 'G' . a:mode .
+          \ (empty(results[1]) ? '' : ' +' . s:PlusEscape(results[1])) . ' ' .
+          \ fnameescape(results[0])
+    let tail = join(map(results[2:-1], '"|" . v:val'), '')
+    if a:mode ==# 'pedit' && len(tail)
+      return cmd . '|wincmd P|exe ' . string(tail[1:-1]) . '|wincmd p'
+    else
+      return cmd . tail
+    endif
+  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)
+    if !empty(s:TempState())
+      let cfile = s:TempDotMap()
+      if !empty(cfile)
+        return fnameescape(s:Generate(cfile))
+      endif
+    endif
+    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 . 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 .= '('.fugitive#Head(7, dir).')'
+  return '[Git'.status.']'
+endfunction
+
+function! fugitive#statusline(...) abort
+  return fugitive#Statusline()
+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 = fugitive#Unquote(line[4:-1])[2:-1]
+      endif
+      if line =~# '^+'
+        let add += 1
+      elseif line =~# '^-'
+        let remove += 1
+      elseif line =~# '^Binary '
+        let binary = 1
+      endif
+    endfor
+    if filename ==# ''
+      let filename = fugitive#Unquote(matchstr(line_foldstart, '^diff .\{-\} \zs"\=[abciow12]/\zs.*\ze "\=[abciow12]/'))[2:-1]
+    endif
+    if filename ==# ''
+      let filename = line_foldstart[5:-1]
+    endif
+    if exists('binary')
+      return 'Binary: '.filename
+    else
+      return '+-' . v:folddashes . ' ' . (add<10&&remove<100?' ':'') . add . '+ ' . (remove<10&&add<100?' ':'') . remove . '- ' . filename
+    endif
+  elseif line_foldstart =~# '^@@\+ .* @@'
+    return '+-' . v:folddashes . ' ' . line_foldstart
+  elseif &filetype ==# 'fugitive' && line_foldstart =~# '^[A-Z][a-z].* (\d\+)$'
+    let c = +matchstr(line_foldstart, '(\zs\d\+\ze)$')
+    return '+-' . v:folddashes . printf('%3d item', c) . (c == 1 ? ':  ' : 's: ') . matchstr(line_foldstart, '.*\ze (\d\+)$')
+  elseif &filetype ==# 'gitcommit' && 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: End
diff --git a/.vim/bundle/vim-fugitive/doc/fugitive.txt b/.vim/bundle/vim-fugitive/doc/fugitive.txt
new file mode 100644
index 0000000..c91c104
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/doc/fugitive.txt
@@ -0,0 +1,730 @@
+*fugitive.txt*  A Git wrapper so awesome, it should be illegal
+
+Author:  Tim Pope <http://tpo.pe/>
+License: Same terms as Vim itself (see |license|)
+
+This plugin is only available if 'compatible' is not set.
+
+INTRODUCTION                                    *fugitive*
+
+Whenever you edit a file from a Git repository, a set of commands is defined
+that serve as a gateway to Git.
+
+COMMANDS                                        *fugitive-commands*
+
+These commands are local to the buffers in which they work (generally, buffers
+that are part of Git repositories).
+
+                                                *fugitive-:G*
+:G [args]               Same as :Git, but two characters shorter.
+
+                                                *:Git*
+:Git {args}             Run an arbitrary git command and display any output.
+                        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!*
+:Git! {args}            Run an arbitrary git command in the background and
+                        stream the output to the preview window.  Requires a
+                        Vim with |setbufline()|.  Press CTRL-D during an
+                        interactive :Git invocation to switch to this mode
+                        retroactively.
+
+                                                *: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.  Pass ++curwin as
+                        the first argument to |:edit| the temp file instead.
+                        A temp file is always used for commands like diff and
+                        log that typically uses a pager, and for any command
+                        that has the pager.<cmd> Git configuration option set.
+
+:{range}Git! --paginate {args}
+:{range}Git! -p {args}  Run an arbitrary git command, and insert the output
+                        after {range} in the current buffer.
+
+                                                *fugitive-summary*
+:Git                    With no arguments, bring up a summary window vaguely
+                        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:
+
+                        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
+
+                                                *g:fugitive_dynamic_colors*
+                        In the GUI or a 256 color terminal, commit hashes will
+                        be highlighted in different colors. To disable this:
+>
+                        let g:fugitive_dynamic_colors = 0
+<
+:[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.
+
+                                                *: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.
+
+:Git difftool -y [args] Invoke `git diff [args]`, open each changed file in a
+                        new tab, and invoke |:Gdiffsplit!| against the
+                        appropriate commit.
+
+                                                *:Git_mergetool*
+:Git mergetool [args]   Like |:Git_difftool|, but target merge conflicts.
+
+Wrappers for Vim built-ins ~
+
+These all directly map onto a built-in Vim command, and generally have names
+that prepend "G" to the command they are wrapping.  For example, :Ggrep is G
+plus |:grep|.
+
+                                                *:Ggrep* *:Git_grep*
+:Ggrep[!] [args]        An approximation of |:grep|[!] with git-grep as
+:Git[!] grep -O [args]  'grepprg'.
+
+:Ggrep[!] --quiet [args]
+:Ggrep[!] -q [args]     Like |:Ggrep|, but instead of displaying output, open
+                        the quickfix list.
+
+                                                *:Glgrep*
+:Glgrep[!] [args]       :Ggrep but for |:lgrep|.
+:0Git[!] grep -O [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.  This command wraps |:cfile|.
+
+                        The quickfix list can be awkward for many use cases
+                        and exhibits extremely poor performance with larger
+                        data sets.  Consider using |:Git| log --oneline
+                        instead.
+
+:{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.
+
+                                                *:Gllog*
+:Gllog [args]           Like |:Gclog|, but use the location list instead of the
+                        |quickfix| list.
+
+                                                *:Gcd*
+:Gcd [directory]        |:cd| relative to the repository.
+
+                                                *:Glcd*
+:Glcd [directory]       |:lcd| relative to the repository.
+
+                                                *:Gedit* *fugitive-:Ge*
+:Gedit [object]         |:edit| a |fugitive-object|.
+
+                                                *:Gsplit*
+:Gsplit [object]        |:split| a |fugitive-object|.
+
+                                                *:Gvsplit*
+:Gvsplit [object]       |:vsplit| a |fugitive-object|.
+
+                                                *:Gtabedit*
+:Gtabedit [object]      |:tabedit| a |fugitive-object|.
+
+                                                *:Gpedit*
+:Gpedit [object]        |:pedit| a |fugitive-object|.
+
+                                                *:Gdrop*
+:Gdrop [object]         |:drop| a |fugitive-object|.
+
+                                                *: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 [object]  |:read| in a |fugitive-object| after {range}.
+
+                                                *: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
+                        great deal of effort is expended to behave sensibly
+                        when the work tree or index version of the file is
+                        open in another buffer.
+
+: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 :0:% to write to just that stage in
+                        the index.
+
+                                                *:Gwq*
+:Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
+                        succeeded.
+
+:Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
+                        succeeded.
+
+                                                *: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, and the work tree version is always
+                        placed to the right or bottom, depending on available
+                        width.  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*
+:Gdiffsplit ++novertical [object]
+:Ghdiffsplit [object]   Like |:Gdiffsplit|, but with "vertical" removed from
+                        'diffopt'.  The split will still be vertical if
+                        combined with |:vertical|.
+
+Other commands ~
+
+These do not directly correspond to any built-in Vim command, and have a
+capital letter after the "G" to convey this. For example, the file move
+operation has nothing to do with the |:move| built-in, so it is named :GMove,
+not :Gmove.
+
+                                                *: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.
+
+                                                *:GRemove* *:GUnlink*
+:GRemove                Like |:GDelete|, but keep the (now empty) buffer around.
+:GUnlink
+
+                                                *:GBrowse*
+:GBrowse                Open the current file, blob, tree, commit, or tag
+                        in your browser at the upstream hosting provider.
+                        Upstream providers can be added by installing an
+                        appropriate Vim plugin.  For example, GitHub can be
+                        supported by installing rhubarb.vim, available at
+                        <https://github.com/tpope/vim-rhubarb>.
+
+:GBrowse {object}       Like :GBrowse, but for a given |fugitive-object|.
+
+:{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.
+
+:GBrowse [...]@{remote} Force using the given remote rather than the remote
+                        for the current branch.  The remote is used to
+                        determine which upstream repository to link to.
+
+:GBrowse {url}          Open an arbitrary URL in your browser.
+
+:[range]GBrowse! [args] Like :GBrowse, but put the URL on the clipboard rather
+                        than opening it.
+
+MAPS                                            *fugitive-maps*
+
+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-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_i*
+i                       Jump to the next file or hunk, expanding inline diffs
+                        automatically.
+
+                                                *fugitive_[[*
+[[                      Jump [count] sections backward.
+
+                                                *fugitive_]]*
+]]                      Jump [count] sections forward.
+
+                                                *fugitive_[]*
+[]                      Jump [count] section ends backward.
+
+                                                *fugitive_][*
+][                      Jump [count] section ends forward.
+
+                                                *fugitive_star*
+*                       On the first column of a + or - diff line, search for
+                        the corresponding - or + line.  Otherwise, defer to
+                        built-in |star|.
+
+                                                *fugitive_#*
+#                       Same as "*", but search backward.
+
+                                                *fugitive_gu*
+gu                      Jump to file [count] in the "Untracked" or "Unstaged"
+                        section.
+
+                                                *fugitive_gU*
+gU                      Jump to file [count] in the "Unstaged" section.
+
+                                                *fugitive_gs*
+gs                      Jump to file [count] in the "Staged" section.
+
+                                                *fugitive_gp*
+gp                      Jump to file [count] in the "Unpushed" section.
+
+                                                *fugitive_gP*
+gP                      Jump to file [count] in the "Unpulled" section.
+
+                                                *fugitive_gr*
+gr                      Jump to file [count] in the "Rebasing" section.
+
+                                                *fugitive_gi*
+gi                      Open .git/info/exclude in a split.  Use a count to
+                        open .gitignore.
+
+                                                *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 the work-tree.  Like `czz` with
+                        `--keep-index`.
+
+czs                     Push stash of the stage.  Does not accept a count.
+
+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
+@^:Makefile     The file named Makefile in the parent of HEAD
+:Makefile       The file named Makefile in the index (writable)
+@~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
+-               A temp file containing the last |:Git| invocation's output
+<cfile>         The file or commit under the cursor
+
+STATUSLINE                                      *fugitive-statusline*
+
+                                *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%{FugitiveStatusline()}%=%-14.(%l,%c%V%)\ %P
+<
+AUTOCOMMANDS                                    *fugitive-autocommands*
+
+A handful of |User| |autocommands| are provided to allow extending and
+overriding Fugitive behaviors.  Example usage:
+>
+        autocmd User FugitiveBlob,FugitiveStageBlob call s:BlobOverrides()
+<
+                                                *User_FugitiveTag*
+FugitiveTag             After loading a tag object.
+
+                                                *User_FugitiveCommit*
+FugitiveCommit          After loading a commit object.
+
+                                                *User_FugitiveTree*
+FugitiveTree            After loading a tree (directory) object.
+
+                                                *User_FugitiveBlob*
+FugitiveBlob            After loading a committed blob (file) object.
+
+                                                *User_FugitiveObject*
+FugitiveObject          After loading any of the 4 above buffer types.
+
+                                                *User_FugitiveStageBlob*
+FugitiveStageBlob       After loading a staged blob (file) object.  These
+                        buffers are 'modifiable' and oftentimes don't want the
+                        same behavior as the other buffer types.
+
+                                                *User_FugitiveIndex*
+FugitiveIndex           After loading the |fugitive-summary| buffer.
+
+                                                *User_FugitivePager*
+FugitivePager           After loading a temp file created by a command like
+                        :Git --paginate or :Git blame.
+
+                                                *User_FugitiveEditor*
+FugitiveEditor          After a :Git command (e.g., :Git commit) edits a file
+                        (e.g., the commit message).
+
+                                                *User_FugitiveChanged*
+FugitiveChanged         After any event which can potentially change the
+                        repository, for example, any invocation of |:Git|.
+                        Originally intended for expiring caches, but can have
+                        other uses.
+
+API                                             *fugitive-api*
+
+Officially supported functions are documented inline in plugin/fugitive.vim.
+
+DEPRECATIONS                                    *fugitive-deprecated*
+
+The following commands are deprecated in favor of replacements that adhere to
+a new naming scheme.  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).
+*:Gsplit!*      Superseded by |:Git_--paginate|.
+*:Gvsplit!*     Superseded by :vert Git --paginate.
+*:Gtabsplit!*   Superseded by :tab Git --paginate.
+*:Gpedit!*      Superseded by :Git! --paginate.
+
+                                                *User_Fugitive*
+Fugitive used to support `:autocmd User Fugitive` to run an autocommand after
+loading any buffer belonging to a Git repository, but this has been phased
+out.  Instead, one can leverage regular autocommand events like |BufNewFile|
+and |BufReadPost|, and check !empty(FugitiveGitDir()) to confirm Fugitive has
+found a repository.  See also |fugitive-autocommands| for other, more
+selective events.
+
+ABOUT                                           *fugitive-about*
+
+Grab the latest version or report a bug on GitHub:
+
+https://github.com/tpope/vim-fugitive
+
+ vim:tw=78:et:ft=help:norl:
diff --git a/.vim/bundle/vim-fugitive/doc/tags b/.vim/bundle/vim-fugitive/doc/tags
new file mode 100644
index 0000000..c180966
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/doc/tags
@@ -0,0 +1,153 @@
+:GBrowse	fugitive.txt	/*:GBrowse*
+:GDelete	fugitive.txt	/*:GDelete*
+:GMove	fugitive.txt	/*:GMove*
+:GRemove	fugitive.txt	/*:GRemove*
+:GRename	fugitive.txt	/*:GRename*
+:GUnlink	fugitive.txt	/*:GUnlink*
+:Gblame	fugitive.txt	/*:Gblame*
+:Gbrowse	fugitive.txt	/*:Gbrowse*
+:Gcd	fugitive.txt	/*:Gcd*
+:Gclog	fugitive.txt	/*:Gclog*
+:Gcommit	fugitive.txt	/*:Gcommit*
+:Gdelete	fugitive.txt	/*:Gdelete*
+:Gdiff	fugitive.txt	/*:Gdiff*
+:Gdiffsplit	fugitive.txt	/*:Gdiffsplit*
+:Gdiffsplit!	fugitive.txt	/*:Gdiffsplit!*
+:Gdrop	fugitive.txt	/*:Gdrop*
+:Gedit	fugitive.txt	/*:Gedit*
+:Gfetch	fugitive.txt	/*:Gfetch*
+:Ggrep	fugitive.txt	/*:Ggrep*
+:Ghdiffsplit	fugitive.txt	/*:Ghdiffsplit*
+:Git	fugitive.txt	/*:Git*
+:Git!	fugitive.txt	/*:Git!*
+:Git_--paginate	fugitive.txt	/*:Git_--paginate*
+:Git_-p	fugitive.txt	/*:Git_-p*
+:Git_blame	fugitive.txt	/*:Git_blame*
+:Git_difftool	fugitive.txt	/*:Git_difftool*
+:Git_grep	fugitive.txt	/*:Git_grep*
+:Git_mergetool	fugitive.txt	/*:Git_mergetool*
+:Glcd	fugitive.txt	/*:Glcd*
+:Glgrep	fugitive.txt	/*:Glgrep*
+:Gllog	fugitive.txt	/*:Gllog*
+:Glog	fugitive.txt	/*:Glog*
+:Gmerge	fugitive.txt	/*:Gmerge*
+:Gmove	fugitive.txt	/*:Gmove*
+:Gpedit	fugitive.txt	/*:Gpedit*
+:Gpedit!	fugitive.txt	/*:Gpedit!*
+:Gpull	fugitive.txt	/*:Gpull*
+:Gpush	fugitive.txt	/*:Gpush*
+:Gread	fugitive.txt	/*:Gread*
+:Grebase	fugitive.txt	/*:Grebase*
+:Gremove	fugitive.txt	/*:Gremove*
+:Grename	fugitive.txt	/*:Grename*
+:Grevert	fugitive.txt	/*:Grevert*
+:Gsdiff	fugitive.txt	/*:Gsdiff*
+:Gsplit	fugitive.txt	/*:Gsplit*
+:Gsplit!	fugitive.txt	/*:Gsplit!*
+:Gstatus	fugitive.txt	/*:Gstatus*
+:Gtabedit	fugitive.txt	/*:Gtabedit*
+:Gtabsplit!	fugitive.txt	/*:Gtabsplit!*
+:Gvdiff	fugitive.txt	/*:Gvdiff*
+:Gvdiffsplit	fugitive.txt	/*:Gvdiffsplit*
+:Gvsplit	fugitive.txt	/*:Gvsplit*
+:Gvsplit!	fugitive.txt	/*:Gvsplit!*
+:Gwq	fugitive.txt	/*:Gwq*
+:Gwrite	fugitive.txt	/*:Gwrite*
+FugitiveStatusline()	fugitive.txt	/*FugitiveStatusline()*
+User_Fugitive	fugitive.txt	/*User_Fugitive*
+User_FugitiveBlob	fugitive.txt	/*User_FugitiveBlob*
+User_FugitiveChanged	fugitive.txt	/*User_FugitiveChanged*
+User_FugitiveCommit	fugitive.txt	/*User_FugitiveCommit*
+User_FugitiveEditor	fugitive.txt	/*User_FugitiveEditor*
+User_FugitiveIndex	fugitive.txt	/*User_FugitiveIndex*
+User_FugitiveObject	fugitive.txt	/*User_FugitiveObject*
+User_FugitivePager	fugitive.txt	/*User_FugitivePager*
+User_FugitiveStageBlob	fugitive.txt	/*User_FugitiveStageBlob*
+User_FugitiveTag	fugitive.txt	/*User_FugitiveTag*
+User_FugitiveTree	fugitive.txt	/*User_FugitiveTree*
+fugitive	fugitive.txt	/*fugitive*
+fugitive#statusline()	fugitive.txt	/*fugitive#statusline()*
+fugitive-:G	fugitive.txt	/*fugitive-:G*
+fugitive-:Ge	fugitive.txt	/*fugitive-:Ge*
+fugitive-:Gr	fugitive.txt	/*fugitive-:Gr*
+fugitive-:Gw	fugitive.txt	/*fugitive-:Gw*
+fugitive-about	fugitive.txt	/*fugitive-about*
+fugitive-api	fugitive.txt	/*fugitive-api*
+fugitive-autocommands	fugitive.txt	/*fugitive-autocommands*
+fugitive-commands	fugitive.txt	/*fugitive-commands*
+fugitive-deprecated	fugitive.txt	/*fugitive-deprecated*
+fugitive-global-maps	fugitive.txt	/*fugitive-global-maps*
+fugitive-maps	fugitive.txt	/*fugitive-maps*
+fugitive-misc-maps	fugitive.txt	/*fugitive-misc-maps*
+fugitive-navigation-maps	fugitive.txt	/*fugitive-navigation-maps*
+fugitive-object	fugitive.txt	/*fugitive-object*
+fugitive-revision	fugitive.txt	/*fugitive-revision*
+fugitive-staging-maps	fugitive.txt	/*fugitive-staging-maps*
+fugitive-statusline	fugitive.txt	/*fugitive-statusline*
+fugitive-summary	fugitive.txt	/*fugitive-summary*
+fugitive.txt	fugitive.txt	/*fugitive.txt*
+fugitive_#	fugitive.txt	/*fugitive_#*
+fugitive_(	fugitive.txt	/*fugitive_(*
+fugitive_)	fugitive.txt	/*fugitive_)*
+fugitive_-	fugitive.txt	/*fugitive_-*
+fugitive_.	fugitive.txt	/*fugitive_.*
+fugitive_<	fugitive.txt	/*fugitive_<*
+fugitive_<CR>	fugitive.txt	/*fugitive_<CR>*
+fugitive_=	fugitive.txt	/*fugitive_=*
+fugitive_>	fugitive.txt	/*fugitive_>*
+fugitive_C	fugitive.txt	/*fugitive_C*
+fugitive_CTRL-N	fugitive.txt	/*fugitive_CTRL-N*
+fugitive_CTRL-P	fugitive.txt	/*fugitive_CTRL-P*
+fugitive_I	fugitive.txt	/*fugitive_I*
+fugitive_O	fugitive.txt	/*fugitive_O*
+fugitive_P	fugitive.txt	/*fugitive_P*
+fugitive_U	fugitive.txt	/*fugitive_U*
+fugitive_X	fugitive.txt	/*fugitive_X*
+fugitive_[/	fugitive.txt	/*fugitive_[\/*
+fugitive_[[	fugitive.txt	/*fugitive_[[*
+fugitive_[]	fugitive.txt	/*fugitive_[]*
+fugitive_[c	fugitive.txt	/*fugitive_[c*
+fugitive_[m	fugitive.txt	/*fugitive_[m*
+fugitive_]/	fugitive.txt	/*fugitive_]\/*
+fugitive_][	fugitive.txt	/*fugitive_][*
+fugitive_]]	fugitive.txt	/*fugitive_]]*
+fugitive_]c	fugitive.txt	/*fugitive_]c*
+fugitive_]m	fugitive.txt	/*fugitive_]m*
+fugitive_c	fugitive.txt	/*fugitive_c*
+fugitive_c_CTRL-R_CTRL-G	fugitive.txt	/*fugitive_c_CTRL-R_CTRL-G*
+fugitive_cb	fugitive.txt	/*fugitive_cb*
+fugitive_cm	fugitive.txt	/*fugitive_cm*
+fugitive_co	fugitive.txt	/*fugitive_co*
+fugitive_cr	fugitive.txt	/*fugitive_cr*
+fugitive_cz	fugitive.txt	/*fugitive_cz*
+fugitive_d	fugitive.txt	/*fugitive_d*
+fugitive_d?	fugitive.txt	/*fugitive_d?*
+fugitive_dd	fugitive.txt	/*fugitive_dd*
+fugitive_dh	fugitive.txt	/*fugitive_dh*
+fugitive_dp	fugitive.txt	/*fugitive_dp*
+fugitive_dq	fugitive.txt	/*fugitive_dq*
+fugitive_ds	fugitive.txt	/*fugitive_ds*
+fugitive_dv	fugitive.txt	/*fugitive_dv*
+fugitive_g?	fugitive.txt	/*fugitive_g?*
+fugitive_gI	fugitive.txt	/*fugitive_gI*
+fugitive_gO	fugitive.txt	/*fugitive_gO*
+fugitive_gP	fugitive.txt	/*fugitive_gP*
+fugitive_gU	fugitive.txt	/*fugitive_gU*
+fugitive_gi	fugitive.txt	/*fugitive_gi*
+fugitive_gp	fugitive.txt	/*fugitive_gp*
+fugitive_gq	fugitive.txt	/*fugitive_gq*
+fugitive_gr	fugitive.txt	/*fugitive_gr*
+fugitive_gs	fugitive.txt	/*fugitive_gs*
+fugitive_gu	fugitive.txt	/*fugitive_gu*
+fugitive_i	fugitive.txt	/*fugitive_i*
+fugitive_o	fugitive.txt	/*fugitive_o*
+fugitive_p	fugitive.txt	/*fugitive_p*
+fugitive_q	fugitive.txt	/*fugitive_q*
+fugitive_r	fugitive.txt	/*fugitive_r*
+fugitive_s	fugitive.txt	/*fugitive_s*
+fugitive_star	fugitive.txt	/*fugitive_star*
+fugitive_u	fugitive.txt	/*fugitive_u*
+fugitive_y_CTRL-G	fugitive.txt	/*fugitive_y_CTRL-G*
+fugitive_~	fugitive.txt	/*fugitive_~*
+g:fugitive_dynamic_colors	fugitive.txt	/*g:fugitive_dynamic_colors*
+g:fugitive_no_maps	fugitive.txt	/*g:fugitive_no_maps*
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/ftplugin/fugitiveblame.vim b/.vim/bundle/vim-fugitive/ftplugin/fugitiveblame.vim
new file mode 100644
index 0000000..1037b09
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/ftplugin/fugitiveblame.vim
@@ -0,0 +1,6 @@
+if exists("b:did_ftplugin") || !exists("*FugitiveGitDir")
+  finish
+endif
+let b:did_ftplugin = 1
+
+call fugitive#BlameFileType()
diff --git a/.vim/bundle/vim-fugitive/plugin/fugitive.vim b/.vim/bundle/vim-fugitive/plugin/fugitive.vim
new file mode 100644
index 0000000..d88fb8c
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/plugin/fugitive.vim
@@ -0,0 +1,754 @@
+" fugitive.vim - A Git wrapper so awesome, it should be illegal
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      3.7
+" GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim
+
+if exists('g:loaded_fugitive')
+  finish
+endif
+let g:loaded_fugitive = 1
+
+let s:bad_git_dir = '/$\|^fugitive:'
+
+" FugitiveGitDir() returns the detected Git dir for the given buffer number,
+" or the current buffer if no argument is passed.  This will be an empty
+" string if no Git dir was found.  Use !empty(FugitiveGitDir()) to check if
+" Fugitive is active in the current buffer.  Do not rely on this for direct
+" filesystem access; use FugitiveFind('.git/whatever') instead.
+function! FugitiveGitDir(...) abort
+  if v:version < 704
+    return ''
+  elseif !a:0 || type(a:1) == type(0) && a:1 < 0 || a:1 is# get(v:, 'true', -1)
+    if exists('g:fugitive_event')
+      return g:fugitive_event
+    endif
+    let dir = get(b:, 'git_dir', '')
+    if empty(dir) && (empty(bufname('')) && &filetype !=# 'netrw' || &buftype =~# '^\%(nofile\|acwrite\|quickfix\|terminal\|prompt\)$')
+      return FugitiveExtractGitDir(getcwd())
+    elseif (!exists('b:git_dir') || b:git_dir =~# s:bad_git_dir) && &buftype =~# '^\%(nowrite\)\=$'
+      let b:git_dir = FugitiveExtractGitDir(bufnr(''))
+      return b:git_dir
+    endif
+    return dir =~# s:bad_git_dir ? '' : dir
+  elseif type(a:1) == type(0) && a:1 isnot# 0
+    if a:1 == bufnr('') && (!exists('b:git_dir') || b:git_dir =~# s:bad_git_dir) && &buftype =~# '^\%(nowrite\)\=$'
+      let b:git_dir = FugitiveExtractGitDir(a:1)
+    endif
+    let dir = getbufvar(a:1, 'git_dir')
+    return dir =~# s:bad_git_dir ? '' : dir
+  elseif type(a:1) == type('')
+    return substitute(s:Slash(a:1), '/$', '', '')
+  elseif type(a:1) == type({})
+    return get(a:1, 'fugitive_dir', get(a:1, 'git_dir', ''))
+  else
+    return ''
+  endif
+endfunction
+
+" 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 type(file) ==# type({})
+    let dir = FugitiveGitDir(file)
+    let tree = s:Tree(dir)
+    return s:VimSlash(empty(tree) ? dir : tree)
+  elseif 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
+
+" 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
+  if a:0 && (type(a:1) ==# type({}) || type(a:1) ==# type(0))
+    return call('fugitive#Find', a:000[1:-1] + [FugitiveGitDir(a:1)])
+  else
+    return fugitive#Find(a:0 ? a:1 : bufnr(''), FugitiveGitDir(a:0 > 1 ? a:2 : -1))
+  endif
+endfunction
+
+" 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
+  let [rev, dir] = fugitive#Parse(path)
+  if !empty(dir)
+    return [rev, dir]
+  endif
+  throw 'fugitive: invalid Fugitive URL ' . path
+endfunction
+
+" FugitiveGitVersion() queries the version of Git in use.  Pass up to 3
+" arguments to return a Boolean of whether a certain minimum version is
+" available (FugitiveGitVersion(2,3,4) checks for 2.3.4 or higher) or no
+" arguments to get a raw string.
+function! FugitiveGitVersion(...) abort
+  return call('fugitive#GitVersion', a:000)
+endfunction
+
+" FugitiveResult() returns an object encapsulating the result of the most
+" recent :Git command.  Will be empty if no result is available.  During a
+" User FugitiveChanged event, this is guaranteed to correspond to the :Git
+" command that triggered the event, or be empty if :Git was not the trigger.
+" Pass in the name of a temp buffer to get the result object for that command
+" instead.  Contains the following keys:
+"
+" * "args": List of command arguments, starting with the subcommand.  Will be
+"   empty for usages like :Git --help.
+" * "git_dir": Git dir of the relevant repository.
+" * "exit_status": The integer exit code of the process.
+" * "flags": Flags passed directly to Git, like -c and --help.
+" * "file": Path to file containing command output.  Not guaranteed to exist,
+"   so verify with filereadable() before trying to access it.
+function! FugitiveResult(...) abort
+  return call('fugitive#Result', a:000)
+endfunction
+
+" FugitiveExecute() runs Git with a list of arguments and returns a dictionary
+" with the following keys:
+"
+" * "exit_status": The integer exit code of the process.
+" * "stdout": The stdout produced by the process, as a list of lines.
+" * "stderr": The stdout produced by the process, as a list of lines.
+"
+" 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.
+"
+" An optional final argument is a callback Funcref, for asynchronous
+" execution.
+function! FugitiveExecute(args, ...) abort
+  return call('fugitive#Execute', [a:args] + a:000)
+endfunction
+
+" FugitiveShellCommand() turns an array of arguments into 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.
+"
+" 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! FugitiveShellCommand(...) abort
+  return call('fugitive#ShellCommand', a:000)
+endfunction
+
+" FugitiveConfig() get returns an opaque structure that can be passed to other
+" FugitiveConfig functions in lieu of a Git directory.  This can be faster
+" when performing multiple config queries.  Do not rely on the internal
+" structure of the return value as it is not guaranteed.  If you want a full
+" dictionary of every config value, use FugitiveConfigGetRegexp('.*').
+"
+" An optional argument provides the Git dir, or the buffer number of a
+" buffer with a Git dir.  The default is the current buffer.  Pass a blank
+" string to limit to the global config.
+function! FugitiveConfig(...) abort
+  return call('fugitive#Config', a:000)
+endfunction
+
+" FugitiveConfigGet() retrieves a Git configuration value.  An optional second
+" argument can be either the object returned by FugitiveConfig(), or a Git
+" dir or buffer number to be passed along to FugitiveConfig().
+function! FugitiveConfigGet(name, ...) abort
+  return get(call('FugitiveConfigGetAll', [a:name] + (a:0 ? [a:1] : [])), 0, get(a:, 2, ''))
+endfunction
+
+" FugitiveConfigGetAll() is like FugitiveConfigGet() but returns a list of
+" all values.
+function! FugitiveConfigGetAll(name, ...) abort
+  return call('fugitive#ConfigGetAll', [a:name] + a:000)
+endfunction
+
+" FugitiveConfigGetRegexp() retrieves a dictionary of all configuration values
+" with a key matching the given pattern.  Like git config --get-regexp, but
+" using a Vim regexp.  Second argument has same semantics as
+" FugitiveConfigGet().
+function! FugitiveConfigGetRegexp(pattern, ...) abort
+  return call('fugitive#ConfigGetRegexp', [a:pattern] + a:000)
+endfunction
+
+" FugitiveRemoteUrl() retrieves the remote URL for the given remote name,
+" defaulting to the current branch's remote or "origin" if no argument is
+" given.  Similar to `git remote get-url`, but also attempts to resolve HTTP
+" redirects and SSH host aliases.
+"
+" 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! FugitiveRemoteUrl(...) abort
+  return call('fugitive#RemoteUrl', a:000)
+endfunction
+
+" FugitiveRemote() returns a data structure parsed from the remote URL.
+" For example, for remote URL "https://me@example.com:1234/repo.git", the
+" returned dictionary will contain the following:
+"
+" * "scheme": "https"
+" * "authority": "user@example.com:1234"
+" * "path": "/repo.git" (for SSH URLs this may be a relative path)
+" * "pathname": "/repo.git" (always coerced to absolute path)
+" * "host": "example.com:1234"
+" * "hostname": "example.com"
+" * "port": "1234"
+" * "user": "me"
+" * "path": "/repo.git"
+" * "url": "https://me@example.com:1234/repo.git"
+function! FugitiveRemote(...) abort
+  return call('fugitive#Remote', a:000)
+endfunction
+
+" FugitiveDidChange() triggers a FugitiveChanged event and reloads the summary
+" buffer for the current or given buffer number's repository.  You can also
+" give the result of a FugitiveExecute() and that context will be made
+" available inside the FugitiveChanged() event.
+"
+" Passing the special argument 0 (the number zero) softly expires summary
+" buffers for all repositories.  This can be used after a call to system()
+" with unclear implications.
+function! FugitiveDidChange(...) abort
+  return call('fugitive#DidChange', a:000)
+endfunction
+
+" FugitiveHead() retrieves 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.
+"
+" 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! FugitiveHead(...) abort
+  if a:0 && (type(a:1) ==# type({}) || type(a:1) ==# type('') && a:1 !~# '^\d\+$')
+    let dir = FugitiveGitDir(a:1)
+    let arg = get(a:, 2, 0)
+  elseif a:0 > 1
+    let dir = FugitiveGitDir(a:2)
+    let arg = a:1
+  else
+    let dir = FugitiveGitDir()
+    let arg = get(a:, 1, 0)
+  endif
+  if empty(dir)
+    return ''
+  endif
+  return fugitive#Head(arg, dir)
+endfunction
+
+function! FugitivePath(...) abort
+  if a:0 > 2 && type(a:1) ==# type({})
+    return fugitive#Path(a:2, a:3, FugitiveGitDir(a:1))
+  elseif a:0 && type(a:1) ==# type({})
+    return FugitiveReal(a:0 > 1 ? a:2 : @%)
+  elseif a:0 > 1
+    return fugitive#Path(a:1, a:2, FugitiveGitDir(a:0 > 2 ? a:3 : -1))
+  else
+    return FugitiveReal(a:0 ? a:1 : @%)
+  endif
+endfunction
+
+function! FugitiveStatusline(...) abort
+  if empty(FugitiveGitDir(bufnr('')))
+    return ''
+  endif
+  return fugitive#Statusline()
+endfunction
+
+let s:resolved_git_dirs = {}
+function! FugitiveActualDir(...) abort
+  let dir = call('FugitiveGitDir', a:000)
+  if empty(dir)
+    return ''
+  endif
+  if !has_key(s:resolved_git_dirs, dir)
+    let s:resolved_git_dirs[dir] = s:ResolveGitDir(dir)
+  endif
+  return empty(s:resolved_git_dirs[dir]) ? dir : s:resolved_git_dirs[dir]
+endfunction
+
+let s:commondirs = {}
+function! FugitiveCommonDir(...) abort
+  let dir = call('FugitiveActualDir', a:000)
+  if empty(dir)
+    return ''
+  endif
+  if has_key(s:commondirs, dir)
+    return s:commondirs[dir]
+  endif
+  if getfsize(dir . '/HEAD') >= 10
+    let cdir = get(s:ReadFile(dir . '/commondir', 1), 0, '')
+    if cdir =~# '^/\|^\a:/'
+      let s:commondirs[dir] = s:Slash(FugitiveVimPath(cdir))
+    elseif len(cdir)
+      let s:commondirs[dir] = simplify(dir . '/' . cdir)
+    else
+      let s:commondirs[dir] = dir
+    endif
+  else
+    let s:commondirs[dir] = dir
+  endif
+  return s:commondirs[dir]
+endfunction
+
+function! FugitiveWorkTree(...) abort
+  let tree = s:Tree(FugitiveGitDir(a:0 ? a:1 : -1))
+  if tree isnot# 0 || a:0 > 1
+    return tree
+  else
+    return ''
+  endif
+endfunction
+
+function! FugitiveIsGitDir(...) abort
+  if !a:0 || type(a:1) !=# type('')
+    return !empty(call('FugitiveGitDir', a:000))
+  endif
+  let path = substitute(a:1, '[\/]$', '', '') . '/'
+  return len(path) && getfsize(path.'HEAD') > 10 && (
+        \ isdirectory(path.'objects') && isdirectory(path.'refs') ||
+        \ getftype(path.'commondir') ==# 'file')
+endfunction
+
+function! s:ReadFile(path, line_count) abort
+  if v:version < 800 && !filereadable(a:path)
+    return []
+  endif
+  try
+    return readfile(a:path, 'b', a:line_count)
+  catch
+    return []
+  endtry
+endfunction
+
+let s:worktree_for_dir = {}
+let s:dir_for_worktree = {}
+function! s:Tree(path) abort
+  if a:path =~# '/\.git$'
+    return len(a:path) ==# 5 ? '/' : a:path[0:-6]
+  elseif a:path ==# ''
+    return ''
+  endif
+  let dir = FugitiveActualDir(a:path)
+  if !has_key(s:worktree_for_dir, dir)
+    let s:worktree_for_dir[dir] = ''
+    let ext_wtc_pat = 'v:val =~# "^\\s*worktreeConfig *= *\\%(true\\|yes\\|on\\|1\\) *$"'
+    let config = s:ReadFile(dir . '/config', 50)
+    if len(config)
+      let ext_wtc_config = filter(copy(config), ext_wtc_pat)
+      if len(ext_wtc_config) == 1 && filereadable(dir . '/config.worktree')
+         let config += s:ReadFile(dir . '/config.worktree', 50)
+      endif
+    else
+      let worktree = fnamemodify(FugitiveVimPath(get(s:ReadFile(dir . '/gitdir', 1), '0', '')), ':h')
+      if worktree ==# '.'
+        unlet! worktree
+      endif
+      if len(filter(s:ReadFile(FugitiveCommonDir(dir) . '/config', 50), ext_wtc_pat))
+        let config = s:ReadFile(dir . '/config.worktree', 50)
+      endif
+    endif
+    if len(config)
+      let wt_config = filter(copy(config), 'v:val =~# "^\\s*worktree *="')
+      if len(wt_config)
+        let worktree = FugitiveVimPath(matchstr(wt_config[0], '= *\zs.*'))
+      elseif !exists('worktree')
+        call filter(config,'v:val =~# "^\\s*bare *= *true *$"')
+        if empty(config)
+          let s:worktree_for_dir[dir] = 0
+        endif
+      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, s:Slash(resolve(dir)))
+      else
+        call add(s:ceiling_directories, s:Slash(dir))
+      endif
+    endfor
+  endif
+  return s:ceiling_directories + get(g:, 'ceiling_directories', [s:Slash(fnamemodify(expand('~'), ':h'))])
+endfunction
+
+function! s:ResolveGitDir(git_dir) abort
+  let type = getftype(a:git_dir)
+  if type ==# 'dir' && FugitiveIsGitDir(a:git_dir)
+    return a:git_dir
+  elseif type ==# 'link' && FugitiveIsGitDir(a:git_dir)
+    return resolve(a:git_dir)
+  elseif type !=# ''
+    let line = get(s:ReadFile(a:git_dir, 1), 0, '')
+    let file_dir = s:Slash(FugitiveVimPath(matchstr(line, '^gitdir: \zs.*')))
+    if file_dir !~# '^/\|^\a:\|^$' && a:git_dir =~# '/\.git$' && FugitiveIsGitDir(a:git_dir[0:-5] . file_dir)
+      return simplify(a:git_dir[0:-5] . file_dir)
+    elseif file_dir =~# '^/\|^\a:' && FugitiveIsGitDir(file_dir)
+      return file_dir
+    endif
+  endif
+  return ''
+endfunction
+
+function! FugitiveExtractGitDir(path) abort
+  if type(a:path) ==# type({})
+    return get(a:path, 'fugitive_dir', get(a:path, 'git_dir', ''))
+  elseif type(a:path) == type(0)
+    let path = s:Slash(a:path > 0 ? bufname(a:path) : bufname(''))
+    if getbufvar(a:path, '&filetype') ==# 'netrw'
+      let path = s:Slash(getbufvar(a:path, 'netrw_curdir', path))
+    endif
+  else
+    let path = s:Slash(a:path)
+  endif
+  if path =~# '^fugitive://'
+    return fugitive#Parse(path)[1]
+  elseif empty(path)
+    return ''
+  endif
+  let pre = substitute(matchstr(path, '^\a\a\+\ze:'), '^.', '\u&', '')
+  if len(pre) && exists('*' . pre . 'Real')
+    let path = {pre}Real(path)
+  endif
+  let root = s:Slash(fnamemodify(path, ':p:h'))
+  let previous = ""
+  let env_git_dir = len($GIT_DIR) ? s:Slash(simplify(fnamemodify(FugitiveVimPath($GIT_DIR), ':p:s?[\/]$??'))) : ''
+  call s:Tree(env_git_dir)
+  let ceiling_directories = s:CeilingDirectories()
+  while root !=# previous && root !~# '^$\|^//[^/]*$'
+    if index(ceiling_directories, root) >= 0
+      break
+    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 = substitute(root, '[\/]$', '', '') . '/.git'
+    let resolved = s:ResolveGitDir(dir)
+    if !empty(resolved)
+      let s:resolved_git_dirs[dir] = resolved
+      return dir is# resolved || s:Tree(resolved) is# 0 ? dir : resolved
+    elseif FugitiveIsGitDir(root)
+      let s:resolved_git_dirs[root] = root
+      return root
+    endif
+    let previous = root
+    let root = fnamemodify(root, ':h')
+  endwhile
+  return ''
+endfunction
+
+function! FugitiveDetect(...) abort
+  if v:version < 704
+    return ''
+  endif
+  if exists('b:git_dir') && b:git_dir =~# '^$\|' . s:bad_git_dir
+    unlet b:git_dir
+  endif
+  if !exists('b:git_dir')
+    let b:git_dir = FugitiveExtractGitDir(a:0 ? a:1 : bufnr(''))
+  endif
+  return ''
+endfunction
+
+function! FugitiveGitPath(path) abort
+  return s:Slash(a:path)
+endfunction
+
+if exists('+shellslash')
+
+  function! s:Slash(path) abort
+    return tr(a:path, '\', '/')
+  endfunction
+
+  function! s:VimSlash(path) abort
+    return tr(a:path, '\/', &shellslash ? '//' : '\\')
+  endfunction
+
+  function FugitiveVimPath(path) abort
+    return tr(a:path, '\/', &shellslash ? '//' : '\\')
+  endfunction
+
+else
+
+  function! s:Slash(path) abort
+    return a:path
+  endfunction
+
+  function! s:VimSlash(path) abort
+    return a:path
+  endfunction
+
+  if has('win32unix') && filereadable('/git-bash.exe')
+    function! FugitiveVimPath(path) abort
+      return substitute(a:path, '^\(\a\):', '/\l\1', '')
+    endfunction
+  else
+    function! FugitiveVimPath(path) abort
+      return a:path
+    endfunction
+  endif
+
+endif
+
+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
+  if !empty(base)
+    if exists('+shellslash') && !&shellslash
+      let base = tr(base, '/', '\')
+    endif
+    let file = FugitiveFind('.git/info/projections.json', dir)
+    if filereadable(file)
+      call projectionist#append(base, file)
+    endif
+  endif
+endfunction
+
+let s:addr_other = has('patch-8.1.560') || has('nvim-0.5.0') ? '-addr=other' : ''
+let s:addr_tabs  = has('patch-7.4.542') ? '-addr=tabs' : ''
+let s:addr_wins  = has('patch-7.4.542') ? '-addr=windows' : ''
+
+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>)
+
+if exists(':Gstatus') != 2 && get(g:, 'fugitive_legacy_commands', 0)
+  exe 'command! -bang -bar     -range=-1' s:addr_other 'Gstatus exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|echohl WarningMSG|echomsg ":Gstatus is deprecated in favor of :Git (with no arguments)"|echohl NONE'
+endif
+
+for s:cmd in ['Commit', 'Revert', 'Merge', 'Rebase', 'Pull', 'Push', 'Fetch', 'Blame']
+  if exists(':G' . tolower(s:cmd)) != 2 && get(g:, 'fugitive_legacy_commands', 0)
+    exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#' . s:cmd . 'Complete G' . tolower(s:cmd)
+          \ 'echohl WarningMSG|echomsg ":G' . tolower(s:cmd) . ' is deprecated in favor of :Git ' . tolower(s:cmd) . '"|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 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 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>)'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Gedit    exe fugitive#Open("edit<bang>", 0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Gpedit   exe fugitive#Open("pedit", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_other '-complete=customlist,fugitive#EditComplete   Gsplit   exe fugitive#Open((<count> > 0 ? <count> : "").(<count> ? "split" : "edit"), <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_other '-complete=customlist,fugitive#EditComplete   Gvsplit  exe fugitive#Open((<count> > 0 ? <count> : "").(<count> ? "vsplit" : "edit!"), <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_tabs  '-complete=customlist,fugitive#EditComplete   Gtabedit exe fugitive#Open((<count> >= 0 ? <count> : "")."tabedit", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Gdrop    exe fugitive#DropCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-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>)'
+endif
+exe 'command! -bar -bang -nargs=* -range=-1                -complete=customlist,fugitive#ReadComplete   Gread    exe fugitive#ReadCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gdiffsplit  exe fugitive#Diffsplit(1, <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Ghdiffsplit exe fugitive#Diffsplit(0, <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gvdiffsplit exe fugitive#Diffsplit(0, <bang>0, "vertical <mods>", <q-args>)'
+
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gw     exe fugitive#WriteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gwrite exe fugitive#WriteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gwq    exe fugitive#WqCommand(   <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+
+exe 'command! -bar -bang -nargs=0 GRemove exe fugitive#RemoveCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=0 GUnlink exe fugitive#UnlinkCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=0 GDelete exe fugitive#DeleteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#CompleteObject GMove   exe fugitive#MoveCommand(  <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#RenameComplete GRename exe fugitive#RenameCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+if exists(':Gremove') != 2 && get(g:, 'fugitive_legacy_commands', 0)
+  exe 'command! -bar -bang -nargs=0 Gremove exe fugitive#RemoveCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|echohl WarningMSG|echomsg ":Gremove is deprecated in favor of :GRemove"|echohl NONE'
+elseif exists(':Gremove') != 2 && !exists('g:fugitive_legacy_commands')
+  exe 'command! -bar -bang -nargs=0 Gremove echoerr ":Gremove has been removed in favor of :GRemove"'
+endif
+if exists(':Gdelete') != 2 && get(g:, 'fugitive_legacy_commands', 0)
+  exe 'command! -bar -bang -nargs=0 Gdelete exe fugitive#DeleteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|echohl WarningMSG|echomsg ":Gdelete is deprecated in favor of :GDelete"|echohl NONE'
+elseif exists(':Gdelete') != 2 && !exists('g:fugitive_legacy_commands')
+  exe 'command! -bar -bang -nargs=0 Gdelete echoerr ":Gdelete has been removed in favor of :GDelete"'
+endif
+if exists(':Gmove') != 2 && get(g:, 'fugitive_legacy_commands', 0)
+  exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#CompleteObject Gmove   exe fugitive#MoveCommand(  <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|echohl WarningMSG|echomsg ":Gmove is deprecated in favor of :GMove"|echohl NONE'
+elseif exists(':Gmove') != 2 && !exists('g:fugitive_legacy_commands')
+  exe 'command! -bar -bang -nargs=? -complete=customlist,fugitive#CompleteObject Gmove'
+        \ 'echoerr ":Gmove has been removed in favor of :GMove"'
+endif
+if exists(':Grename') != 2 && get(g:, 'fugitive_legacy_commands', 0)
+  exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#RenameComplete Grename exe fugitive#RenameCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|echohl WarningMSG|echomsg ":Grename is deprecated in favor of :GRename"|echohl NONE'
+elseif exists(':Grename') != 2 && !exists('g:fugitive_legacy_commands')
+  exe 'command! -bar -bang -nargs=? -complete=customlist,fugitive#RenameComplete Grename'
+        \ 'echoerr ":Grename has been removed in favor of :GRename"'
+endif
+
+exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject GBrowse exe fugitive#BrowseCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+if exists(':Gbrowse') != 2 && get(g:, 'fugitive_legacy_commands', 0)
+  exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject Gbrowse exe fugitive#BrowseCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|if <bang>1|redraw!|endif|echohl WarningMSG|echomsg ":Gbrowse is deprecated in favor of :GBrowse"|echohl NONE'
+elseif exists(':Gbrowse') != 2 && !exists('g:fugitive_legacy_commands')
+  exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject Gbrowse'
+        \ 'echoerr ":Gbrowse has been removed in favor of :GBrowse"'
+endif
+
+if v:version < 704
+  finish
+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')}
+
+augroup fugitive
+  autocmd!
+
+  autocmd BufNewFile,BufReadPost *
+        \ if exists('b:git_dir') && b:git_dir =~# '^$\|' . s:bad_git_dir |
+        \   unlet b:git_dir |
+        \ endif
+  autocmd FileType           netrw
+        \ if exists('b:git_dir') && b:git_dir =~# '^$\|' . s:bad_git_dir |
+        \   unlet b:git_dir |
+        \ endif
+  autocmd BufFilePost            *  unlet! b:git_dir
+
+  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#PorcelainCfile()')
+  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} nested
+        \ if FugitiveIsGitDir(expand('<amatch>:p:h')) |
+        \   let b:git_dir = s:Slash(expand('<amatch>:p:h')) |
+        \   exe fugitive#BufReadStatus(v:cmdbang) |
+        \   echohl WarningMSG |
+        \   echo "fugitive: Direct editing of .git/" . expand('%:t') . " is deprecated" |
+        \   echohl NONE |
+        \ elseif filereadable(expand('<amatch>')) |
+        \   silent doautocmd BufReadPre |
+        \   keepalt noautocmd read <amatch> |
+        \   silent 1delete_ |
+        \   silent doautocmd BufReadPost |
+        \ else |
+        \   silent doautocmd BufNewFile |
+        \ endif
+
+  autocmd BufReadCmd   fugitive://*          nested exe fugitive#BufReadCmd() |
+        \ if &path =~# '^\.\%(,\|$\)' |
+        \   let &l:path = substitute(&path, '^\.,\=', '', '') |
+        \ endif
+  autocmd BufWriteCmd  fugitive://*          nested exe fugitive#BufWriteCmd()
+  autocmd FileReadCmd  fugitive://*          nested exe fugitive#FileReadCmd()
+  autocmd FileWriteCmd fugitive://*          nested exe fugitive#FileWriteCmd()
+  if exists('##SourceCmd')
+    autocmd SourceCmd     fugitive://*       nested exe fugitive#SourceCmd()
+  endif
+
+  autocmd User Flags call Hoist('buffer', function('FugitiveStatusline'))
+
+  autocmd User ProjectionistDetect call s:ProjectionistDetect()
+augroup END
+
+nmap <script><silent> <Plug>fugitive:y<C-G> :<C-U>call setreg(v:register, fugitive#Object(@%))<CR>
+nmap <script> <Plug>fugitive: <Nop>
+
+if get(g:, 'fugitive_no_maps')
+  finish
+endif
+
+function! s:Map(mode, lhs, rhs, flags) abort
+  let flags = a:flags . (a:rhs =~# '<Plug>' ? '' : '<script>') . '<nowait>'
+  let head = a:lhs
+  let tail = ''
+  let keys = get(g:, a:mode.'remap', {})
+  if len(keys) && type(keys) == type({})
+    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
+  endif
+  if empty(mapcheck(head.tail, a:mode))
+    exe a:mode.'map' flags head.tail a:rhs
+  endif
+endfunction
+
+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..c7fe201
--- /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][^:]*:/
+syn match fugitiveHeader /^Head:/ nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
+syn match fugitiveHeader /^Pull:\|^Rebase:\|^Merge:\|^Push:/ nextgroup=fugitiveSymbolicRef skipwhite
+syn match fugitiveHelpHeader /^Help:/ nextgroup=fugitiveHelpTag skipwhite
+syn match fugitiveHelpTag    /\S\+/ contained
+
+syn region fugitiveSection start=/^\%(.*(\d\++\=)$\)\@=/ contains=fugitiveHeading end=/^$/ fold
+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=diffLine,diffRemoved,diffAdded,diffNoEOL 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=/^$/ fold'
+  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 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..70c1e74
--- /dev/null
+++ b/.vim/bundle/vim-fugitive/syntax/fugitiveblame.vim
@@ -0,0 +1,7 @@
+if exists("b:current_syntax") || !exists("*FugitiveGitDir")
+  finish
+endif
+
+call fugitive#BlameSyntax()
+
+let b:current_syntax = "fugitiveblame"
diff --git a/.vim/bundle/vim-nerdtree-fugitive b/.vim/bundle/vim-nerdtree-fugitive
new file mode 160000
index 0000000..f7acffd
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree-fugitive
@@ -0,0 +1 @@
+Subproject commit f7acffdc05b5db893daa8201f3ff85945da50fcb
diff --git a/.vim/bundle/vim-nerdtree/.vintrc.yaml b/.vim/bundle/vim-nerdtree/.vintrc.yaml
new file mode 100644
index 0000000..c44b6ab
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/.vintrc.yaml
@@ -0,0 +1,5 @@
+cmdargs:
+  severity: style_problem
+  color: true
+  env:
+    neovim: false
diff --git a/.vim/bundle/vim-nerdtree/CHANGELOG.md b/.vim/bundle/vim-nerdtree/CHANGELOG.md
new file mode 100644
index 0000000..6e6893a
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/CHANGELOG.md
@@ -0,0 +1,307 @@
+# NERDTree Change Log
+<!-- Introduce a new MAJOR or MINOR version with a 4-hash header.
+     PATCH versions are listed from newest to oldest under their respective MAJOR.MINOR
+     version in an unordered list.  The format is:
+        - **.PATCH**: Pull Request Title (PR Author) [PR Number](Link to PR)
+-->
+#### 6.10
+- **.16**: Fix documentation errors. (lifecrisis) [#1269](https://github.com/preservim/nerdtree/pull/1269)
+- **.15**: Ensure backward compatible testing of types. (lifecrisis) [#1266](https://github.com/preservim/nerdtree/pull/1266)
+- **.14**: Replace trim() with a version-compatible alternative. (PhilRunninger) [#1265](https://github.com/preservim/nerdtree/pull/1265)
+- **.13**: Change highlighting of bookmarks in the tree. (PhilRunninger) [#1261](https://github.com/preservim/nerdtree/pull/1261)
+- **.12**: Answer the question about accessing files over scp or ftp. (PhilRunninger) [#1259](https://github.com/preservim/nerdtree/pull/1259)
+- **.11**: Trim filenames created via the fs_menu (elanorigby) [#1243](https://github.com/preservim/nerdtree/pull/1243)
+- **.10**: Improve F.A.Q. Answers and Issue Templates (PhilRunninger) [#1249](https://github.com/preservim/nerdtree/pull/1249)
+- **.9**: `go` on a bookmark directory will NERDTreeFind it. (PhilRunninger) [#1236](https://github.com/preservim/nerdtree/pull/1236)
+- **.8**: Put `Callback` function variables in local scope. (PhilRunninger) [#1230](https://github.com/preservim/nerdtree/pull/1230)
+- **.7**: Fix mouse-clicking a file to open it. (PhilRunninger) [#1225](https://github.com/preservim/nerdtree/pull/1225)
+- **.6**: Restore the default behavior of the `<CR>` key. (PhilRunninger) [#1221](https://github.com/preservim/nerdtree/pull/1221)
+- **.5**: Fix `{'keepopen':0}` in NERDTreeCustomOpenArgs (PhilRunninger) [#1217](https://github.com/preservim/nerdtree/pull/1217)
+- **.4**: Removed directory separator from sort key (Daniel E) [#1219](https://github.com/preservim/nerdtree/pull/1219)
+- **.3**: Add new FAQ and answer: How to prevent buffers replacing NERDTree. (PhilRunninger) [#1215](https://github.com/preservim/nerdtree/pull/1215)
+- **.2**: New menu command: Run a system command in this directory. (PhilRunninger) [#1214](https://github.com/preservim/nerdtree/pull/1214)
+- **.1**: Escape quotation marks so they can be used in key mappings. (PhilRunninger) [#1213](https://github.com/preservim/nerdtree/pull/1213)
+- **.0**: Enable full path specifications for NERDTreeIgnore (PhilRunninger) [#1207](https://github.com/preservim/nerdtree/pull/1207)
+#### 6.9
+- **.12**: Respect NERDTreeCustomOpenArgs when opening bookmark (przepompownia) [#1200](https://github.com/preservim/nerdtree/pull/1200)
+- **.11**: Revamp the README. (buncis, PhilRunninger) [#1192](https://github.com/preservim/nerdtree/pull/1192), [#1193](https://github.com/preservim/nerdtree/pull/1193)
+- **.10**: Open a mirrored NERDTree with correct width (PhilRunninger) [#1177](https://github.com/preservim/nerdtree/pull/1177)
+- **.9**: Updated Readme, removed typo (H3RSKO) [#1167](https://github.com/preservim/nerdtree/pull/1167)
+- **.8**: Refactor sort comparison functions, removing redundancy (PhilRunninger) [#1166](https://github.com/preservim/nerdtree/pull/1166)
+- **.7**: Fix argument of `exists()` function calls checking for autocommands. (PhilRunninger) [#1165](https://github.com/preservim/nerdtree/pull/1165)
+- **.6**: Don't use silent when raising User events (PhilRunninger) [#1164](https://github.com/preservim/nerdtree/pull/1164)
+- **.5**: Fix highlight for file node.  (pirey) [#1157](https://github.com/preservim/nerdtree/pull/1157)
+- **.4**: Make sure symbolic links' flags are highlighted correctly.  (PhilRunninger) [#1156](https://github.com/preservim/nerdtree/pull/1156)
+- **.3**: Fix new NERDTrees' width when previous one was in the only window. (PhilRunninger) [#1153](https://github.com/preservim/nerdtree/pull/1153)
+- **.2**: Fix the scope of several key mappings (lifecrisis, PhilRunninger) [#1151](https://github.com/preservim/nerdtree/pull/1151)
+- **.1**: Respect user's `&shellslash` setting in CopyNode and RemoveNode functions (PhilRunninger) [#1150](https://github.com/preservim/nerdtree/pull/1150)
+- **.0**: Enable opening bookmarks in split windows. (PhilRunninger) [#1144](https://github.com/preservim/nerdtree/pull/1144)
+#### 6.8
+- **.0**: Allow concealed characters to show another character. (PhilRunninger) [#1138](https://github.com/preservim/nerdtree/pull/1138)
+#### 6.7
+- **.15**: Add curly braces to the list of characters to be escaped. (PhilRunninger) [#1128](https://github.com/preservim/nerdtree/pull/1128)
+- **.14**: Use backward-compatible `nerdtree#and()` in one place that was missed. (PhilRunninger) [#1134](https://github.com/preservim/nerdtree/pull/1134)
+- **.13**: `cmd.exe /c start "" <filename>` for windows default viewer support. (J. Altayó) [#1130](https://github.com/preservim/nerdtree/pull/1130)
+- **.12**: Fixed a bug that caused the file-tree construction to slow down significantly. (Eugenij-W) [#1126](https://github.com/preservim/nerdtree/pull/1126)
+- **.11**: Fix exception in NERDTreeFind (on windows OS and If the file is located in the root directory of the disk) (Eugenij-W) [#1122](https://github.com/preservim/nerdtree/pull/1122)
+- **.10**: Do not consider the tree root to be "cascadable". (lifecrisis) [#1120](https://github.com/preservim/nerdtree/pull/1120)
+- **.9**: Force `:NERDTreeFocus` to allow events to be fired when switching windows. (PhilRunninger) [#1118](https://github.com/preservim/nerdtree/pull/1118)
+- **.8**: Fix example code for the `NERDTreeAddKeyMap()` function. (PhilRunninger) [#1116](https://github.com/preservim/nerdtree/pull/1116)
+- **.7**: Put `'%'` argument in `bufname()` for backwards compatibility. (PhilRunninger) [#1105](https://github.com/preservim/nerdtree/pull/1105)
+- **.6**: If a file's already open in the window, don't edit it again. (PhilRunninger) [#1103](https://github.com/preservim/nerdtree/pull/1103)
+- **.5**: Prevent unneeded tree creation in `:NERDTreeToggle[VCS] <path>` (PhilRunninger) [#1101](https://github.com/preservim/nerdtree/pull/1101)
+- **.4**: Add missing calls to the `shellescape()` function (lifecrisis) [#1099](https://github.com/preservim/nerdtree/pull/1099)
+- **.3**: Fix vsplit to not open empty buffers when opening previously closed file (AwkwardKore) [#1098](https://github.com/preservim/nerdtree/pull/1098)
+- **.2**: Fix infinity loop (on winvim) in FindParentVCSRoot (Eugenij-W) [#1095](https://github.com/preservim/nerdtree/pull/1095)
+- **.1**: File Move: Escape existing directory name when looking for open files. (PhilRunninger) [#1094](https://github.com/preservim/nerdtree/pull/1094)
+- **.0**: Open the parent directory when revealing a non-existent file with :NERDTreeFind (bouk) [#1090](https://github.com/preservim/nerdtree/pull/1090)
+#### 6.6
+- **.1**: [add] How to install using dein.vim (kazukazuinaina) [#1087](https://github.com/preservim/nerdtree/pull/1087)
+- **.0**: Add the ability to turn off directory arrows (PhilRunninger) [#1085](https://github.com/preservim/nerdtree/pull/1085)
+#### 6.5
+- **.0**: `NERDTreeToggle <start-directory>` always sets NERDTree root. (PhilRunninger) [#1083](https://github.com/preservim/nerdtree/pull/1083)
+#### 6.4
+- **.6**: NERDTreeFind shows expected message if file doesn't exist e.g. with vim-startify (andys8). [#1081](https://github.com/preservim/nerdtree/pull/1081)
+- **.5**: Ensure events are (or aren't) being ignored correctly. (PhilRunninger) [#1080](https://github.com/preservim/nerdtree/pull/1080)
+- **.4**: Prevent overwriting existing files/dirs on node move. (PhilRunninger) [#1079](https://github.com/preservim/nerdtree/pull/1079)
+- **.3**: Fix regex that finds keyword for minimal menu. (PhilRunninger) [#1075](https://github.com/preservim/nerdtree/pull/1075)
+- **.2**: Lint vimscript, fix errors and warnings, add CI job to review PRs (Caleb Maclennan) [#1071](https://github.com/preservim/nerdtree/pull/1071)
+- **.1**: Ensure backward compatibility. v:t_func is not available before Vim 8.0 (Phil Runninger)
+- **.0**: Allow use of function references as callbacks (HiPhish) [#1067](https://github.com/preservim/nerdtree/pull/1067)
+#### 6.3
+- **.0**: Add new command that behaves like NERDTreeToggle but defaults to the root of a VCS repository. (willfindlay) [#1060](https://github.com/preservim/nerdtree/pull/1060)
+#### 6.2
+- **.1**: Menu option, 'copy path to clipboard' is aware of VIM clipboard option (jhzn) [#1056](https://github.com/preservim/nerdtree/pull/1056)
+- **.0**: Support tab-specific CWDs (PhilRunninger) [#1032](https://github.com/preservim/nerdtree/pull/1032)
+#### 6.1
+- **.4**: Add VIM built-in package management to read me file. (pesarkhobeee) [#1049](https://github.com/preservim/nerdtree/pull/1049)
+- **.3**: Save/Set screen state also on WinLeave and WinEnter. (PhilRunninger) [#1048](https://github.com/preservim/nerdtree/pull/1048)
+- **.2**: Wrap saveScreenState's statements in a try-catch block. (PhilRunninger) [#1047](https://github.com/preservim/nerdtree/pull/1047)
+- **.1**: Catch errors when trying to read CHANGELOG.md. (PhilRunninger) [#1045](https://github.com/preservim/nerdtree/pull/1045)
+- **.0**: If file path doesn't exist, :NERDTreeFind its parent directory instead. (PhilRunninger) [#1043](https://github.com/preservim/nerdtree/pull/1043)
+#### 6.0
+- **.1**: Reintroduce necessary variable mistakenly removed. (PhilRunninger) [#1040](https://github.com/preservim/nerdtree/pull/1040)
+- **.0**: Make the behavior of window splits consistent (dragonxlwang, PhilRunninger) [#1035](https://github.com/preservim/nerdtree/pull/1035)
+#### 5.3
+- **.3**: Fix (p)ath not displaying in the minimal menu (tuzz) [#1038](https://github.com/preservim/nerdtree/pull/1038)
+- **.2**: Enable events when closing NerdTree window. (PhilRunninger) [#1037](https://github.com/preservim/nerdtree/pull/1037)
+- **.1**: Fix the `e` key mapping to use netrw if desired (PhilRunninger) [#1031](https://github.com/preservim/nerdtree/pull/1031)
+- **.0**: Add file extension and size to sorting capabilities (PhilRunninger) [#1029](https://github.com/preservim/nerdtree/pull/1029)
+#### 5.2
+- **.9**: Suppress events for intermediate window/tab/buffer changes (PhilRunninger) [#1026](https://github.com/preservim/nerdtree/pull/1026)
+- **.8**: Revert [#1019](https://github.com/preservim/nerdtree/pull/1019) to fix nvim artifacts and flickering. (PhilRunninger) [#1021](https://github.com/preservim/nerdtree/pull/1021)
+- **.7**: Use :mode only in neovim. MacVim still needs to use :redraw! (PhilRunninger) [#1019](https://github.com/preservim/nerdtree/pull/1019)
+- **.6**: In CHANGELOG.md and PR template, make reference to PR a true HTML link. (PhilRunninger) [#1017](https://github.com/preservim/nerdtree/pull/1017)
+- **.5**: Use `:mode` instead of `:redraw!` when updating menu. (PhilRunninger) [#1016](https://github.com/preservim/nerdtree/pull/1016)
+- **.4**: When searching for root line num, stop at end of file. (PhilRunninger) [#1015](https://github.com/preservim/nerdtree/pull/1015)
+- **.3**: Fix `<CR>` key map on the bookmark (lkebin) [#1014](https://github.com/preservim/nerdtree/pull/1014)
+- **.2**: Make Enter work on the `.. ( up a dir )` line (PhilRunninger) [#1013](https://github.com/preservim/nerdtree/pull/1013)
+- **.1**: Fix nerdtree#version() on Windows. (PhilRunninger)
+- **.0**: Expand functionality of `<CR>` mapping. (PhilRunninger) [#1011](https://github.com/preservim/nerdtree/pull/1011)
+#### 5.1
+- **.3**: Remove @mentions from PR template and change log. They weren't working. (PhilRunninger) [#1009](https://github.com/preservim/nerdtree/pull/1009)
+- **.2**: Fix NERDTree opening with the wrong size. (PhilRunninger) [#1008](https://github.com/preservim/nerdtree/pull/1008)
+- **.1**: Update Changelog and create PR Template (PhilRunninger) [#1007](https://github.com/preservim/nerdtree/pull/1007)
+- **.0**: Too many changes for one patch...
+    - Refresh a dir_node if the file wasn't found in it, and look once more. (PhilRunninger) [#1005](https://github.com/preservim/nerdtree/pull/1005)
+    - Add a "copy path to clipboard" menu option (PhilRunninger) [#1002](https://github.com/preservim/nerdtree/pull/1002)
+    - Enable root refresh on "vim ." a different way than [#999](https://github.com/preservim/nerdtree/pull/999). (PhilRunninger) [#1001](https://github.com/preservim/nerdtree/pull/1001)
+    - Fix refreshroot (PhilRunninger) [#999](https://github.com/preservim/nerdtree/pull/999)
+    - Change version check to look for 703 not 730 (vhalis) [#994](https://github.com/preservim/nerdtree/pull/994)
+    - Change minimum vim (PhilRunninger) [#991](https://github.com/preservim/nerdtree/pull/991)
+    - Allow multi-character DirArrows (PhilRunninger) [#985](https://github.com/preservim/nerdtree/pull/985)
+    - Remove redraw! while still clearing last message empty string. (PhilRunninger) [#979](https://github.com/preservim/nerdtree/pull/979)
+    - fix `_initChildren` function value set to numChildrenCached error (terryding77) [#969](https://github.com/preservim/nerdtree/pull/969)
+    - On Windows, do a case-insensitive comparison of paths. (PhilRunninger) [#967](https://github.com/preservim/nerdtree/pull/967)
+    - Remove the **Please wait... DONE** messages. (PhilRunninger) [#966](https://github.com/preservim/nerdtree/pull/966)
+    - Smarter delimiter default (PhilRunninger) [#963](https://github.com/preservim/nerdtree/pull/963)
+    - Update directory .vimdc readme example (spencerdcarlson) [#961](https://github.com/preservim/nerdtree/pull/961)
+    - Preview bookmarks (PhilRunninger) [#956](https://github.com/preservim/nerdtree/pull/956)
+    - Add new value to NERDTreeQuitOnOpen to close bookmark table (PhilRunninger) [#955](https://github.com/preservim/nerdtree/pull/955)
+    - Add an :EditBookmarks command to edit the bookmarks file (PhilRunninger) [#954](https://github.com/preservim/nerdtree/pull/954)
+    - Before copying, turn off &shellslash. Restore after copy is finished. (PhilRunninger) [#952](https://github.com/preservim/nerdtree/pull/952)
+    - Set a maximum window size when zooming. (PhilRunninger) [#950](https://github.com/preservim/nerdtree/pull/950)
+    - Confirm the wipeout of a unsaved buffer whose file has been renamed. (PhilRunninger) [#949](https://github.com/preservim/nerdtree/pull/949)
+    - Escape a backslash so it can be used in a key mapping. (PhilRunninger) [#948](https://github.com/preservim/nerdtree/pull/948)
+    - Add a NERDTreeMinimalMenu feature (tuzz) [#938](https://github.com/preservim/nerdtree/pull/938)
+    - fixed root path error for windows (zcodes) [#935](https://github.com/preservim/nerdtree/pull/935)
+    - Restore getDirChildren for use in nerdtree-project-plugin. (PhilRunninger) [#929](https://github.com/preservim/nerdtree/pull/929)
+    - Document NERDTreeNodeDelimiter [#912](https://github.com/preservim/nerdtree/pull/912) (PhilRunninger) [#926](https://github.com/preservim/nerdtree/pull/926)
+    - Allow modification of menu keybindings (Leandros) [#923](https://github.com/preservim/nerdtree/pull/923)
+    - Add two more disqualifications for isCascadable(). (PhilRunninger) [#914](https://github.com/preservim/nerdtree/pull/914)
+    - Allow highlighting more than one flag. (kristijanhusak) [#908](https://github.com/preservim/nerdtree/pull/908)
+    - Support sorting files and directories by modification time. (PhilRunninger) [#901](https://github.com/preservim/nerdtree/pull/901)
+    - Parse . and .. from path string with trailing slash. (PhilRunninger) [#899](https://github.com/preservim/nerdtree/pull/899)
+    - Force sort to recalculate the cached sortKey. (PhilRunninger) [#898](https://github.com/preservim/nerdtree/pull/898)
+    - Add NERDTreeRefreshRoot command (wgfm) [#897](https://github.com/preservim/nerdtree/pull/897)
+    - Call Resolve on the file's path when calling :NERDTreeFind. (PhilRunninger) [#896](https://github.com/preservim/nerdtree/pull/896)
+    - Catch all errors, not just NERDTree errors. (PhilRunninger) [#894](https://github.com/preservim/nerdtree/pull/894)
+    - Fix typo in help file (lvoisin) [#892](https://github.com/preservim/nerdtree/pull/892)
+    - Make NERDTreeCreator set the `'nolist'` option (lifecrisis) [#889](https://github.com/preservim/nerdtree/pull/889)
+    - Refresh buffers after `m`, `m` operation on a folder (PhilRunninger) [#888](https://github.com/preservim/nerdtree/pull/888)
+    - Use a better arg for FINDSTR when using the m,l command in Windows. (PhilRunninger) [#887](https://github.com/preservim/nerdtree/pull/887)
+    - Fix the <C-J>/<C-K> motions, which currently fail with cascades (lifecrisis) [#886](https://github.com/preservim/nerdtree/pull/886)
+    - Function "s:UI.getLineNum()" doesn't always work on cascades. (lifecrisis) [#882](https://github.com/preservim/nerdtree/pull/882)
+    - NERDTreeCWD: reset CWD if changed by NERDTreeFocus (PhilRunninger) [#878](https://github.com/preservim/nerdtree/pull/878)
+    - Use <count>tabnext instead of <count>gt to allow users to remap gt. (PhilRunninger) [#877](https://github.com/preservim/nerdtree/pull/877)
+    - Do a case sensitive comparison of new/existing buffers. (PhilRunninger) [#875](https://github.com/preservim/nerdtree/pull/875)
+    - Fix opening sub-directories that have commas in their name. (PhilRunninger) [#873](https://github.com/preservim/nerdtree/pull/873)
+    - Add new command to open NERDTree in the root of a VCS repository. (PhilRunninger) [#872](https://github.com/preservim/nerdtree/pull/872)
+    - Make sure the path to the bookmarks file exists before writing it. (PhilRunninger) [#871](https://github.com/preservim/nerdtree/pull/871)
+    - Unzoom NERDTree when opening a file (PhilRunninger) [#870](https://github.com/preservim/nerdtree/pull/870)
+    - Support unusual characters in file and directory names (PhilRunninger) [#868](https://github.com/preservim/nerdtree/pull/868)
+    - Reword renamed-buffer prompt to be more clear (aflock) [#867](https://github.com/preservim/nerdtree/pull/867)
+    - Default to placing cursor on root when closing bookmark table (lifecrisis) [#866](https://github.com/preservim/nerdtree/pull/866)
+    - Fix issues with sorting of nodes (PhilRunninger) [#856](https://github.com/preservim/nerdtree/pull/856)
+    - Better OSX detection (bubba-h57) [#853](https://github.com/preservim/nerdtree/pull/853)
+    - Bugfix - ensure keymaps dictionary exists before using it (mnussbaum) [#852](https://github.com/preservim/nerdtree/pull/852)
+    - Decrease startup-time by avoiding linear-time iteration over key mappings (mnussbaum) [#851](https://github.com/preservim/nerdtree/pull/851)
+    - Add code to sort mappings in quickhelp (lifecrisis) [#849](https://github.com/preservim/nerdtree/pull/849)
+    - Use ":clearjumps" in new NERDTree windows (lifecrisis) [#844](https://github.com/preservim/nerdtree/pull/844)
+    - Like m-c did before, create parent directories if needed on m-m. (PhilRunninger) [#840](https://github.com/preservim/nerdtree/pull/840)
+    - BUGFIX: Repair a problem with the `'u'` mapping. (lifecrisis) [#838](https://github.com/preservim/nerdtree/pull/838)
+    - Make the NERDTree buffer writable when rendering it. (PhilRunninger) [#837](https://github.com/preservim/nerdtree/pull/837)
+    - Code cleanup: Remove unsupported bookmark table mappings (lifecrisis) [#835](https://github.com/preservim/nerdtree/pull/835)
+    - Replace strcharpart() with substitute() for backward compatibility (bravestarr) [#834](https://github.com/preservim/nerdtree/pull/834)
+    - Fixed error `unknown function strcharpart` for older versions of Vim (hav4ik) [#833](https://github.com/preservim/nerdtree/pull/833)
+    - Clear output when NERDTree menu is aborted (lifecrisis) [#832](https://github.com/preservim/nerdtree/pull/832)
+    - Display a path with multi-byte characters correctly when it is truncated (bravestarr) [#830](https://github.com/preservim/nerdtree/pull/830)
+    - Support revealing file and executing file with xdg-open for Linux (ngnmhieu) [#824](https://github.com/preservim/nerdtree/pull/824)
+    - If node isn't open, count children on disk before deleting. (PhilRunninger) [#822](https://github.com/preservim/nerdtree/pull/822)
+    - Add new variable g:NERDTreeRemoveFileCmd (kutsan) [#816](https://github.com/preservim/nerdtree/pull/816)
+    - Use a better check for existence of the NERDTree buffer. (PhilRunninger) [#814](https://github.com/preservim/nerdtree/pull/814)
+    - Fix focussing previous buffer when closing NERDTree (mrubli) [#801](https://github.com/preservim/nerdtree/pull/801)
+    - Update the docs for "NERDTreeStatusline" (lifecrisis) [#796](https://github.com/preservim/nerdtree/pull/796)
+    - BUGFIX: Unstable behavior in the "getPath()" method (lifecrisis) [#795](https://github.com/preservim/nerdtree/pull/795)
+    - Revert the bugfix from pull request [#785](https://github.com/preservim/nerdtree/pull/785) (lifecrisis) [#794](https://github.com/preservim/nerdtree/pull/794)
+    - BUGFIX: Allow ":NERDTreeFind" to discover hidden files (lifecrisis) [#786](https://github.com/preservim/nerdtree/pull/786)
+    - BUGFIX: Allow ":NERDTreeFind" to reveal new files (lifecrisis) [#785](https://github.com/preservim/nerdtree/pull/785)
+    - Add modelines (lifecrisis) [#782](https://github.com/preservim/nerdtree/pull/782)
+    - Change the type of completion used by NERDTreeFind (lifecrisis) [#781](https://github.com/preservim/nerdtree/pull/781)
+    - change NERDTreeFind with args (zhenyangze) [#778](https://github.com/preservim/nerdtree/pull/778)
+    - Style Choice: Using confirm() when deleting a bookmark (lifecrisis) [#777](https://github.com/preservim/nerdtree/pull/777)
+    - remove useless substitute when `file =~# "/$"` (skyblueee) [#773](https://github.com/preservim/nerdtree/pull/773)
+    - remove useless removeLeadingSpaces in _stripMarkup (skyblueee) [#772](https://github.com/preservim/nerdtree/pull/772)
+    - Make the "o" mapping consistent with "x" (lifecrisis) [#769](https://github.com/preservim/nerdtree/pull/769)
+    - Fix a problem with the "x" handler (lifecrisis) [#768](https://github.com/preservim/nerdtree/pull/768)
+    - Clean up the handler for the "x" mapping (lifecrisis) [#767](https://github.com/preservim/nerdtree/pull/767)
+    - Revert change to tab opening method (lifecrisis) [#766](https://github.com/preservim/nerdtree/pull/766)
+    - BUGFIX: Add back support for "b:NERDTreeRoot" (lifecrisis) [#765](https://github.com/preservim/nerdtree/pull/765)
+    - Fix broken "t" and "T" mappings, tabs now open at end (lifecrisis) [#759](https://github.com/preservim/nerdtree/pull/759)
+    - Update doc with already existing mapping variables (asnr) [#699](https://github.com/preservim/nerdtree/pull/699)
+    - Fix the broken g:NERDTreeBookmarksSort setting (lifecrisis) [#696](https://github.com/preservim/nerdtree/pull/696)
+    - Correct NERDTreeIgnore pattern in doc (cntoplolicon) [#648](https://github.com/preservim/nerdtree/pull/648)
+    - Remove empty segments when splitting path (sooth-sayer) [#574](https://github.com/preservim/nerdtree/pull/574)
+    - Suppress autocmds less agressively (wincent) [#578](https://github.com/preservim/nerdtree/pull/578) [#691](https://github.com/preservim/nerdtree/pull/691)
+    - Add an Issues template to ask for more info initially.
+    - Fix markdown headers in readme (josephfrazier) [#676](https://github.com/preservim/nerdtree/pull/676)
+    - Don't touch `@o` and `@h` registers when rendering
+    - Fix bug with files and directories with dollar signs (alegen) [#649](https://github.com/preservim/nerdtree/pull/649)
+    - Reuse/reopen existing window trees where possible [#244](https://github.com/preservim/nerdtree/pull/244)
+    - Remove NERDTree.previousBuf()
+    - Change color of arrow (Leeiio) [#630](https://github.com/preservim/nerdtree/pull/630)
+    - Improved a tip in README.markdown (ggicci) [#628](https://github.com/preservim/nerdtree/pull/628)
+    - Shorten delete confimration of empty directory to `y` (mikeperri) [#530](https://github.com/preservim/nerdtree/pull/530)
+    - Fix API call to open directory tree in window (devm33) [#533](https://github.com/preservim/nerdtree/pull/533)
+    - Change default arrows on non-Windows platforms (gwilk) [#546](https://github.com/preservim/nerdtree/pull/546)
+    - Update to README - combine cd and git clone (zwhitchcox) [#584](https://github.com/preservim/nerdtree/pull/584)
+    - Update to README - Tip: start NERDTree when vim starts (therealplato) [#593](https://github.com/preservim/nerdtree/pull/593)
+    - Escape filename when moving an open buffer (zacharyvoase) [#595](https://github.com/preservim/nerdtree/pull/595)
+    - Fixed incorrect :helptags command in README (curran) [#619](https://github.com/preservim/nerdtree/pull/619)
+    - Fixed incomplete escaping of folder arrows (adityanatraj) [#548](https://github.com/preservim/nerdtree/pull/548)
+    - Added NERDTreeCascadeSingleChildDir option (juanibiapina) [#558](https://github.com/preservim/nerdtree/pull/558)
+    - Replace strchars() with backward compatible workaround.
+    - Add support for copy command in Windows (SkylerLipthay) [#231](https://github.com/preservim/nerdtree/pull/231)
+    - Fixed typo in README.markdown - :Helptags -> :helptags
+    - Rename "primary" and "secondary" trees to "tab" and "window" trees.
+    - Move a bunch of buffer level variables into the NERDTree and UI classes.
+    - Display cascading dirs on one line to save vertical/horizontal space (matt-gardner: brainstorming/testing)
+    - Remove the old style UI - Remove `NERDTreeDirArrows` option.
+    - On windows default to + and ~ for expand/collapse directory symbols.
+    - Lots more refactoring. Move a bunch of b: level vars into b:NERDTree and friends.
+
+#### 5.0.0
+- Refactor the code significantly:
+    * Break the classes out into their own files.
+    * Make the majority of the code OO - previously large parts were effectively a tangle of "global" methods.
+- Add an API to assign flags to nodes. This allows VCS plugins like https://github.com/Xuyuanp/nerdtree-git-plugin to exist. Thanks to **Xuyuanp** for helping design/test/build said API.
+- add `scope` argument to the key map API see :help NERDTreeAddKeyMap()
+- add magic [[dir]] and [[file]] flags to NERDTreeIgnore
+- add support for custom path filters. See :help NERDTreeAddPathFilter()
+- add path listener API. See :help NERDTreePathListenerAPI.
+- expand the fs menu functionality to list file properties (PhilRunninger, apbarrero, JESii)
+- make bookmarks work with `~` home shortcuts (hiberabyss)
+- show OSX specific fsmenu options in regular vim on mac (evindor)
+- make dir arrow icons configurable (PickRelated)
+- optimise node sorting performance when opening large dirs (vtsang)
+- make the root note render prettier by truncating it at a path slash (gcmt)
+- remove NERDChristmasTree option - its always christmas now
+- add "cascade" open and closing for dirs containing only another single dir. See :help NERDTreeCascadeOpenSingleChildDir (pendulm)
+- Many other fixes, doc updates and contributions from: **actionshrimp**, **agrussellknives**, **alvan**, **AndrewRadev**, **cperl82** (*many small fixes*), **devmanhinton**, **egalpin**, **franksort**, **gastropoda**, **handcraftedbits**, **kelaban**, **lucascaton**, **mixvin**, **pendulm**, **SchDen**, **shanesmith**, **staeff**, **stephenprater**, **toiffel**, **Twinside**, **WoLpH**, **xiaodili**, **zhangoose**
+
+#### 4.2.0
+- Add NERDTreeDirArrows option to make the UI use pretty arrow chars instead of the old +~| chars to define the tree structure (sickill)
+- shift the syntax highlighting out into its own syntax file (gnap)
+- add some mac specific options to the filesystem menu - for macvim only (andersonfreitas)
+- Add NERDTreeMinimalUI option to remove some non functional parts of the nerdtree ui (camthompson)
+- tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the new behaviour (benjamingeiger)
+- if no name is given to :Bookmark, make it default to the name of the target file/dir (minyoung)
+- use `file` completion when doing copying, create, and move operations (EvanDotPro)
+- lots of misc bug fixes from: **AndrewRadev**, **Bogdanov**, **camthompson**, **kml**, **mathias**, **paddyoloughlin**, **scottstvnsn**, **sdewald**, **Vitaly**, **wycats**, me RAWR!
+
+#### 4.1.0
+- features:
+    - NERDTreeFind to reveal the node for the current buffer in the tree, see `|NERDTreeFind|`. This effectively merges the FindInNERDTree plugin (by **Doug McInnes**) into the script.
+    - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to **Stefan Ritter** and **Rémi Prévost**.
+    - truncate the root node if wider than the tree window. Thanks to **Victor Gonzalez**.
+
+- bugfixes:
+    - really fix window state restoring
+    - fix some win32 path escaping issues. Thanks to **Stephan Baumeister**, **Ricky**, **jfilip1024**, and **Chris Chambers**.
+
+#### 4.0.0
+- add a new programmable menu system (see `:help NERDTreeMenu`).
+- add new APIs to add menus/menu-items to the menu system as well as custom key mappings to the NERD tree buffer (see `:help NERDTreeAPI`).
+- removed the old API functions
+- added a mapping to maximize/restore the size of nerd tree window, thanks to Guillaume Duranceau for the patch. See :help NERDTree-A for details.
+- fix a bug where secondary nerd trees (netrw hijacked trees) and NERDTreeQuitOnOpen didnt play nicely, thanks to **Curtis Harvey**.
+- fix a bug where the script ignored directories whose name ended in a dot, thanks to **Aggelos Orfanakos** for the patch.
+- fix a bug when using the x mapping on the tree root, thanks to **Bryan Venteicher** for the patch.
+- fix a bug where the cursor position/window size of the nerd tree buffer wasnt being stored on closing the window, thanks to **Richard Hart**.
+- fix a bug where NERDTreeMirror would mirror the wrong tree
+
+#### 3.1.1
+- fix a bug where a non-listed no-name buffer was getting created every time the tree windows was created, thanks to **Derek Wyatt** and **owen1**
+- make `<CR>` behave the same as the `o` mapping
+- some helptag fixes in the doc, thanks **strull**.
+- fix a bug when using `:set nohidden` and opening a file where the previous buf was modified. Thanks **iElectric**.
+- other minor fixes
+
+#### 3.1.0
+- New features:
+    - add mappings to open files in a vsplit, see `:help NERDTree-s` and `:help NERDTree-gs`
+    - make the statusline for the nerd tree window default to something hopefully more useful. See `:help 'NERDTreeStatusline'`
+- Bugfixes:
+    - make the hijack netrw functionality work when vim is started with `vim <some dir>` (thanks to **Alf Mikula** for the patch).
+    - fix a bug where the CWD wasnt being changed for some operations even when NERDTreeChDirMode==2 (thanks to **Lucas S. Buchala**)
+    - add -bar to all the nerd tree :commands so they can chain with other :commands (thanks to **tpope**)
+    - fix bugs when ignorecase was set (thanks to **nach**)
+    - fix a bug with the relative path code (thanks to **nach**)
+    - fix a bug where doing a `:cd` would cause `:NERDTreeToggle` to fail (thanks **nach**)
+
+
+#### 3.0.1
+- Bugfixes:
+    - fix bugs with :NERDTreeToggle and :NERDTreeMirror when `'hidden'` was not set
+    - fix a bug where `:NERDTree <path>` would fail if `<path>` was relative and didnt start with a `./` or `../`  Thanks to **James Kanze**.
+    - make the `q` mapping work with secondary (`:e <dir>`  style) trees, thanks to **jamessan**
+    - fix a bunch of small bugs with secondary trees
+- More insane refactoring.
+
+#### 3.0.0
+- hijack netrw so that doing an `:edit <directory>`  will put a NERD tree in the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw'
+- allow sharing of trees across tabs, see `:help :NERDTreeMirror`
+- remove "top" and "bottom" as valid settings for NERDTreeWinPos
+- change the `'<tab>'` mapping to `'i'`
+- change the `'H'` mapping to `'I'`
+- lots of refactoring
diff --git a/.vim/bundle/vim-nerdtree/LICENCE b/.vim/bundle/vim-nerdtree/LICENCE
new file mode 100644
index 0000000..8b1a9d8
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/LICENCE
@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.
diff --git a/.vim/bundle/vim-nerdtree/README.markdown b/.vim/bundle/vim-nerdtree/README.markdown
new file mode 100644
index 0000000..27aa314
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/README.markdown
@@ -0,0 +1,227 @@
+![Help Wanted](http://blog.ncce.org/wp-content/uploads/2013/12/help-wanted.jpg)
+
+**NERDTree** is on the lookout for a new maintainer. See [issue #1280](https://github.com/preservim/nerdtree/issues/1280) to submit your name for consideration.
+
+---
+
+# The NERDTree [![Vint](https://github.com/preservim/nerdtree/workflows/Vint/badge.svg)](https://github.com/preservim/nerdtree/actions?workflow=Vint)
+
+## Introduction
+
+The NERDTree is a file system explorer for the Vim editor. Using this plugin, users can visually browse complex directory hierarchies, quickly open files for reading or editing, and perform basic file system operations.
+
+![NERDTree Screenshot](https://github.com/preservim/nerdtree/raw/master/screenshot.png)
+
+## Installation
+
+Use your favorite plugin manager to install this plugin. [tpope/vim-pathogen](https://github.com/tpope/vim-pathogen), [VundleVim/Vundle.vim](https://github.com/VundleVim/Vundle.vim), [junegunn/vim-plug](https://github.com/junegunn/vim-plug), and [Shougo/dein.vim](https://github.com/Shougo/dein.vim) are some of the more popular ones. A lengthy discussion of these and other managers can be found on [vi.stackexchange.com](https://vi.stackexchange.com/questions/388/what-is-the-difference-between-the-vim-plugin-managers). Basic instructions are provided below, but please **be sure to read, understand, and follow all the safety rules that come with your ~~power tools~~ plugin manager.**
+
+If you have no favorite, or want to manage your plugins without 3rd-party dependencies, consider using Vim 8+ packages, as described in Greg Hurrell's excellent Youtube video: [Vim screencast #75: Plugin managers](https://www.youtube.com/watch?v=X2_R3uxDN6g).
+
+<details>
+<summary>Pathogen</summary>
+Pathogen is more of a runtime path manager than a plugin manager. You must clone the plugins' repositories yourself to a specific location, and Pathogen makes sure they are available in Vim.
+
+
+1. In the terminal,
+    ```bash
+    git clone https://github.com/preservim/nerdtree.git ~/.vim/bundle/nerdtree
+    ```
+1. In your `vimrc`,
+    ```vim
+    call pathogen#infect()
+    syntax on
+    filetype plugin indent on
+    ```
+1. Restart Vim, and run `:helptags ~/.vim/bundle/nerdtree/doc/` or `:Helptags`.
+</details>
+
+<details>
+  <summary>Vundle</summary>
+
+1. Install Vundle, according to its instructions.
+1. Add the following text to your `vimrc`.
+    ```vim
+    call vundle#begin()
+      Plugin 'preservim/nerdtree'
+    call vundle#end()
+    ```
+1. Restart Vim, and run the `:PluginInstall` statement to install your plugins.
+</details>
+
+<details>
+  <summary>Vim-Plug</summary>
+
+1. Install Vim-Plug, according to its instructions.
+1. Add the following text to your `vimrc`.
+```vim
+call plug#begin()
+  Plug 'preservim/nerdtree'
+call plug#end()
+```
+1. Restart Vim, and run the `:PlugInstall` statement to install your plugins.
+</details>
+
+<details>
+  <summary>Dein</summary>
+
+1. Install Dein, according to its instructions.
+1. Add the following text to your `vimrc`.
+    ```vim
+    call dein#begin()
+      call dein#add('preservim/nerdtree')
+    call dein#end()
+    ```
+1. Restart Vim, and run the `:call dein#install()` statement to install your plugins.
+</details>
+
+<details>
+<summary>Vim 8+ packages</summary>
+
+If you are using Vim version 8 or higher you can use its built-in package management; see `:help packages` for more information. Just run these commands in your terminal:
+
+```bash
+git clone https://github.com/preservim/nerdtree.git ~/.vim/pack/vendor/start/nerdtree
+vim -u NONE -c "helptags ~/.vim/pack/vendor/start/nerdtree/doc" -c q
+```
+</details>
+
+## Getting Started
+After installing NERDTree, the best way to learn it is to turn on the Quick Help. Open NERDTree with the `:NERDTree` command, and press `?` to turn on the Quick Help, which will show you all the mappings and commands available in the NERDTree. Of course, your most complete source of information is the documentation: `:help NERDTree`.
+
+## NERDTree Plugins
+NERDTree can be extended with custom mappings and functions using its built-in API. The details of this API are described in the included documentation. Several plugins have been written, and are available on Github for installation like any other plugin. The plugins in this list are maintained (or not) by their respective owners, and certain combinations may be incompatible.
+
+* [Xuyuanp/nerdtree-git-plugin](https://github.com/Xuyuanp/nerdtree-git-plugin): Shows Git status flags for files and folders in NERDTree.
+* [ryanoasis/vim-devicons](https://github.com/ryanoasis/vim-devicons): Adds filetype-specific icons to NERDTree files and folders,
+* [tiagofumo/vim-nerdtree-syntax-highlight](https://github.com/tiagofumo/vim-nerdtree-syntax-highlight): Adds syntax highlighting to NERDTree based on filetype.
+* [scrooloose/nerdtree-project-plugin](https://github.com/scrooloose/nerdtree-project-plugin): Saves and restores the state of the NERDTree between sessions.
+* [PhilRunninger/nerdtree-buffer-ops](https://github.com/PhilRunninger/nerdtree-buffer-ops): 1) Highlights open files in a different color. 2) Closes a buffer directly from NERDTree.
+* [PhilRunninger/nerdtree-visual-selection](https://github.com/PhilRunninger/nerdtree-visual-selection): Enables NERDTree to open, delete, move, or copy multiple Visually-selected files at once.
+
+If any others should be listed, mention them in an issue or pull request.
+
+
+## Frequently Asked Questions
+
+In the answers to these questions, you will see code blocks that you can put in your `vimrc` file.
+
+### How can I map a specific key or shortcut to open NERDTree?
+
+NERDTree doesn't create any shortcuts outside of the NERDTree window, so as not to overwrite any of your other shortcuts. Use the `nnoremap` command in your `vimrc`. You, of course, have many keys and NERDTree commands to choose from. Here are but a few examples.
+```vim
+nnoremap <leader>n :NERDTreeFocus<CR>
+nnoremap <C-n> :NERDTree<CR>
+nnoremap <C-t> :NERDTreeToggle<CR>
+nnoremap <C-f> :NERDTreeFind<CR>
+```
+
+### How do I open NERDTree automatically when Vim starts?
+Each code block below is slightly different, as described in the `" Comment lines`.
+
+```vim
+" Start NERDTree and leave the cursor in it.
+autocmd VimEnter * NERDTree
+```
+---
+```vim
+" Start NERDTree and put the cursor back in the other window.
+autocmd VimEnter * NERDTree | wincmd p
+```
+---
+```vim
+" Start NERDTree when Vim is started without file arguments.
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * if argc() == 0 && !exists('s:std_in') | NERDTree | endif
+```
+---
+```vim
+" Start NERDTree. If a file is specified, move the cursor to its window.
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * NERDTree | if argc() > 0 || exists("s:std_in") | wincmd p | endif
+```
+---
+```vim
+" Start NERDTree, unless a file or session is specified, eg. vim -S session_file.vim.
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * if argc() == 0 && !exists('s:std_in') && v:this_session == '' | NERDTree | endif
+```
+---
+```vim
+" Start NERDTree when Vim starts with a directory argument.
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * if argc() == 1 && isdirectory(argv()[0]) && !exists('s:std_in') |
+    \ execute 'NERDTree' argv()[0] | wincmd p | enew | execute 'cd '.argv()[0] | endif
+```
+
+### How can I close Vim or a tab automatically when NERDTree is the last window?
+
+```vim
+" Exit Vim if NERDTree is the only window remaining in the only tab.
+autocmd BufEnter * if tabpagenr('$') == 1 && winnr('$') == 1 && exists('b:NERDTree') && b:NERDTree.isTabTree() | quit | endif
+```
+---
+```vim
+" Close the tab if NERDTree is the only window remaining in it.
+autocmd BufEnter * if winnr('$') == 1 && exists('b:NERDTree') && b:NERDTree.isTabTree() | quit | endif
+```
+
+### How can I prevent other buffers replacing NERDTree in its window?
+
+```vim
+" If another buffer tries to replace NERDTree, put it in the other window, and bring back NERDTree.
+autocmd BufEnter * if bufname('#') =~ 'NERD_tree_\d\+' && bufname('%') !~ 'NERD_tree_\d\+' && winnr('$') > 1 |
+    \ let buf=bufnr() | buffer# | execute "normal! \<C-W>w" | execute 'buffer'.buf | endif
+```
+
+### Can I have the same NERDTree on every tab automatically?
+
+```vim
+" Open the existing NERDTree on each new tab.
+autocmd BufWinEnter * if getcmdwintype() == '' | silent NERDTreeMirror | endif
+```
+or change your NERDTree-launching shortcut key like so:
+```vim
+" Mirror the NERDTree before showing it. This makes it the same on all tabs.
+nnoremap <C-n> :NERDTreeMirror<CR>:NERDTreeFocus<CR>
+```
+
+### How can I change the default arrows?
+
+```vim
+let g:NERDTreeDirArrowExpandable = '?'
+let g:NERDTreeDirArrowCollapsible = '?'
+```
+The preceding values are the non-Windows default arrow symbols. Setting these variables to empty strings will remove the arrows completely and shift the entire tree two character positions to the left. See `:h NERDTreeDirArrowExpandable` for more details.
+
+### Can NERDTree access remote files via scp or ftp?
+
+Short answer: No, and there are no plans to add that functionality. However, Vim ships with a plugin that does just that. It's called netrw, and by adding the following lines to your `.vimrc`, you can use it to open files over the `scp:`, `ftp:`, or other protocols, while still using NERDTree for all local files. The function seamlessly makes the decision to open NERDTree or netrw, and other supported protocols can be added to the regular expression.
+
+```vim
+" Function to open the file or NERDTree or netrw.
+"   Returns: 1 if either file explorer was opened; otherwise, 0.
+function! s:OpenFileOrExplorer(...)
+    if a:0 == 0 || a:1 == ''
+        NERDTree
+    elseif filereadable(a:1)
+        execute 'edit '.a:1
+        return 0
+    elseif a:1 =~? '^\(scp\|ftp\)://' " Add other protocols as needed.
+        execute 'Vexplore '.a:1
+    elseif isdirectory(a:1)
+        execute 'NERDTree '.a:1
+    endif
+    return 1
+endfunction
+
+" Auto commands to handle OS commandline arguments
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * if argc()==1 && !exists('s:std_in') | if <SID>OpenFileOrExplorer(argv()[0]) | wincmd p | enew | wincmd p | endif | endif
+
+" Command to call the OpenFileOrExplorer function.
+command! -n=? -complete=file -bar Edit :call <SID>OpenFileOrExplorer('<args>')
+
+" Command-mode abbreviation to replace the :edit Vim command.
+cnoreabbrev e Edit
+```
diff --git a/.vim/bundle/vim-nerdtree/_config.yml b/.vim/bundle/vim-nerdtree/_config.yml
new file mode 100644
index 0000000..c419263
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/_config.yml
@@ -0,0 +1 @@
+theme: jekyll-theme-cayman
\ No newline at end of file
diff --git a/.vim/bundle/vim-nerdtree/autoload/nerdtree.vim b/.vim/bundle/vim-nerdtree/autoload/nerdtree.vim
new file mode 100644
index 0000000..ba70871
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/autoload/nerdtree.vim
@@ -0,0 +1,249 @@
+if exists('g:loaded_nerdtree_autoload')
+    finish
+endif
+let g:loaded_nerdtree_autoload = 1
+
+let s:rootNERDTreePath = resolve(expand('<sfile>:p:h:h'))
+
+"FUNCTION: nerdtree#version(...) {{{1
+"  If any value is given as an argument, the entire line of text from the
+"  change log is shown for the current version; otherwise, only the version
+"  number is shown.
+function! nerdtree#version(...) abort
+    let l:text = 'Unknown'
+    try
+        let l:changelog = readfile(join([s:rootNERDTreePath, 'CHANGELOG.md'], nerdtree#slash()))
+        let l:line = 0
+        while l:line <= len(l:changelog)
+            if l:changelog[l:line] =~# '\d\+\.\d\+'
+                let l:text = substitute(l:changelog[l:line], '.*\(\d\+.\d\+\).*', '\1', '')
+                let l:text .= substitute(l:changelog[l:line+1], '^.\{-}\(\.\d\+\).\{-}:\(.*\)', a:0>0 ? '\1:\2' : '\1', '')
+                break
+            endif
+            let l:line += 1
+        endwhile
+    catch
+    endtry
+    return l:text
+endfunction
+
+" SECTION: General Functions {{{1
+"============================================================
+
+" FUNCTION: nerdtree#closeTreeOnOpen() {{{2
+function! nerdtree#closeTreeOnOpen() abort
+    return g:NERDTreeQuitOnOpen == 1 || g:NERDTreeQuitOnOpen == 3
+endfunction
+
+" FUNCTION: nerdtree#closeBookmarksOnOpen() {{{2
+function! nerdtree#closeBookmarksOnOpen() abort
+    return g:NERDTreeQuitOnOpen == 2 || g:NERDTreeQuitOnOpen == 3
+endfunction
+
+" FUNCTION: nerdtree#slash() {{{2
+" Return the path separator used by the underlying file system.  Special
+" consideration is taken for the use of the 'shellslash' option on Windows
+" systems.
+function! nerdtree#slash() abort
+    if nerdtree#runningWindows()
+        if exists('+shellslash') && &shellslash
+            return '/'
+        endif
+
+        return '\'
+    endif
+
+    return '/'
+endfunction
+
+"FUNCTION: nerdtree#checkForBrowse(dir) {{{2
+"inits a window tree in the current buffer if appropriate
+function! nerdtree#checkForBrowse(dir) abort
+    if !isdirectory(a:dir)
+        return
+    endif
+
+    if s:reuseWin(a:dir)
+        return
+    endif
+
+    call g:NERDTreeCreator.CreateWindowTree(a:dir)
+endfunction
+
+"FUNCTION: s:reuseWin(dir) {{{2
+"finds a NERDTree buffer with root of dir, and opens it.
+function! s:reuseWin(dir) abort
+    let path = g:NERDTreePath.New(fnamemodify(a:dir, ':p'))
+
+    for i in range(1, bufnr('$'))
+        unlet! nt
+        let nt = getbufvar(i, 'NERDTree')
+        if empty(nt)
+            continue
+        endif
+
+        if nt.isWinTree() && nt.root.path.equals(path)
+            call nt.setPreviousBuf(bufnr('#'))
+            exec 'buffer ' . i
+            return 1
+        endif
+    endfor
+
+    return 0
+endfunction
+
+" FUNCTION: nerdtree#completeBookmarks(A,L,P) {{{2
+" completion function for the bookmark commands
+function! nerdtree#completeBookmarks(A,L,P) abort
+    return filter(g:NERDTreeBookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"')
+endfunction
+
+"FUNCTION: nerdtree#compareNodes(n1, n2) {{{2
+function! nerdtree#compareNodes(n1, n2) abort
+    return nerdtree#compareNodePaths(a:n1.path, a:n2.path)
+endfunction
+
+"FUNCTION: nerdtree#compareNodePaths(p1, p2) {{{2
+function! nerdtree#compareNodePaths(p1, p2) abort
+    let sortKey1 = a:p1.getSortKey()
+    let sortKey2 = a:p2.getSortKey()
+    let i = 0
+    while i < min([len(sortKey1), len(sortKey2)])
+        " Compare chunks upto common length.
+        " If chunks have different type, the one which has
+        " integer type is the lesser.
+        if type(sortKey1[i]) == type(sortKey2[i])
+            if sortKey1[i] <# sortKey2[i]
+                return - 1
+            elseif sortKey1[i] ># sortKey2[i]
+                return 1
+            endif
+        elseif type(sortKey1[i]) == type(0)
+            return -1
+        elseif type(sortKey2[i]) == type(0)
+            return 1
+        endif
+        let i += 1
+    endwhile
+
+    " Keys are identical upto common length.
+    " The key which has smaller chunks is the lesser one.
+    if len(sortKey1) < len(sortKey2)
+        return -1
+    elseif len(sortKey1) > len(sortKey2)
+        return 1
+    else
+        return 0
+    endif
+endfunction
+
+" FUNCTION: nerdtree#deprecated(func, [msg]) {{{2
+" Issue a deprecation warning for a:func. If a second arg is given, use this
+" as the deprecation message
+function! nerdtree#deprecated(func, ...) abort
+    let msg = a:0 ? a:func . ' ' . a:1 : a:func . ' is deprecated'
+
+    if !exists('s:deprecationWarnings')
+        let s:deprecationWarnings = {}
+    endif
+    if !has_key(s:deprecationWarnings, a:func)
+        let s:deprecationWarnings[a:func] = 1
+        echomsg msg
+    endif
+endfunction
+
+" FUNCTION: nerdtree#exec(cmd, ignoreAll) {{{2
+" Same as :exec cmd but, if ignoreAll is TRUE, set eventignore=all for the duration
+function! nerdtree#exec(cmd, ignoreAll) abort
+    let old_ei = &eventignore
+    if a:ignoreAll
+        set eventignore=all
+    endif
+    try
+        exec a:cmd
+    finally
+        let &eventignore = old_ei
+    endtry
+endfunction
+
+" FUNCTION: nerdtree#has_opt(options, name) {{{2
+function! nerdtree#has_opt(options, name) abort
+    return has_key(a:options, a:name) && a:options[a:name] ==# 1
+endfunction
+
+" FUNCTION: nerdtree#loadClassFiles() {{{2
+function! nerdtree#loadClassFiles() abort
+    runtime lib/nerdtree/path.vim
+    runtime lib/nerdtree/menu_controller.vim
+    runtime lib/nerdtree/menu_item.vim
+    runtime lib/nerdtree/key_map.vim
+    runtime lib/nerdtree/bookmark.vim
+    runtime lib/nerdtree/tree_file_node.vim
+    runtime lib/nerdtree/tree_dir_node.vim
+    runtime lib/nerdtree/opener.vim
+    runtime lib/nerdtree/creator.vim
+    runtime lib/nerdtree/flag_set.vim
+    runtime lib/nerdtree/nerdtree.vim
+    runtime lib/nerdtree/ui.vim
+    runtime lib/nerdtree/event.vim
+    runtime lib/nerdtree/notifier.vim
+endfunction
+
+" FUNCTION: nerdtree#postSourceActions() {{{2
+function! nerdtree#postSourceActions() abort
+    call g:NERDTreeBookmark.CacheBookmarks(1)
+    call nerdtree#ui_glue#createDefaultBindings()
+
+    "load all nerdtree plugins
+    runtime! nerdtree_plugin/**/*.vim
+endfunction
+
+"FUNCTION: nerdtree#runningWindows(dir) {{{2
+function! nerdtree#runningWindows() abort
+    return has('win16') || has('win32') || has('win64')
+endfunction
+
+"FUNCTION: nerdtree#runningCygwin(dir) {{{2
+function! nerdtree#runningCygwin() abort
+    return has('win32unix')
+endfunction
+
+" SECTION: View Functions {{{1
+"============================================================
+
+"FUNCTION: nerdtree#echo  {{{2
+"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages
+"
+"Args:
+"msg: the message to echo
+function! nerdtree#echo(msg) abort
+    redraw
+    echomsg empty(a:msg) ? '' : ('NERDTree: ' . a:msg)
+endfunction
+
+"FUNCTION: nerdtree#echoError {{{2
+"Wrapper for nerdtree#echo, sets the message type to errormsg for this message
+"Args:
+"msg: the message to echo
+function! nerdtree#echoError(msg) abort
+    echohl errormsg
+    call nerdtree#echo(a:msg)
+    echohl normal
+endfunction
+
+"FUNCTION: nerdtree#echoWarning {{{2
+"Wrapper for nerdtree#echo, sets the message type to warningmsg for this message
+"Args:
+"msg: the message to echo
+function! nerdtree#echoWarning(msg) abort
+    echohl warningmsg
+    call nerdtree#echo(a:msg)
+    echohl normal
+endfunction
+
+"FUNCTION: nerdtree#renderView {{{2
+function! nerdtree#renderView() abort
+    call b:NERDTree.render()
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/autoload/nerdtree/ui_glue.vim b/.vim/bundle/vim-nerdtree/autoload/nerdtree/ui_glue.vim
new file mode 100644
index 0000000..fc22f21
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/autoload/nerdtree/ui_glue.vim
@@ -0,0 +1,732 @@
+if exists('g:loaded_nerdtree_ui_glue_autoload')
+    finish
+endif
+let g:loaded_nerdtree_ui_glue_autoload = 1
+
+" FUNCTION: nerdtree#ui_glue#createDefaultBindings() {{{1
+function! nerdtree#ui_glue#createDefaultBindings() abort
+    let s = '<SNR>' . s:SID() . '_'
+
+    call NERDTreeAddKeyMap({ 'key': '<MiddleMouse>', 'scope': 'all', 'callback': s . 'handleMiddleMouse' })
+    call NERDTreeAddKeyMap({ 'key': '<LeftRelease>', 'scope': 'all', 'callback': s.'handleLeftClick' })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'DirNode', 'callback': s.'activateDirNode' })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'FileNode', 'callback': s.'activateFileNode' })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'Bookmark', 'callback': s.'activateBookmark' })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'all', 'callback': s.'activateAll' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'FileNode', 'callback': s.'customOpenFile'})
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'DirNode', 'callback': s.'customOpenDir'})
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'Bookmark', 'callback': s.'customOpenBookmark'})
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'all', 'callback': s.'activateAll' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'DirNode', 'callback': s.'activateDirNode' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'FileNode', 'callback': s.'activateFileNode' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'Bookmark', 'callback': s.'activateBookmark' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': 'Bookmark', 'callback': s.'previewBookmark' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'all', 'callback': s.'activateAll' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': 'FileNode', 'callback': s.'openHSplit' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': 'Bookmark', 'callback': s.'openHSplitBookmark' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': 'FileNode', 'callback': s.'openVSplit' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': 'Bookmark', 'callback': s.'openVSplitBookmark' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': 'FileNode', 'callback': s.'previewNodeCurrent' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': 'FileNode', 'callback': s.'previewNodeHSplit' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': 'Bookmark', 'callback': s.'previewNodeHSplitBookmark' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': 'FileNode', 'callback': s.'previewNodeVSplit' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': 'Bookmark', 'callback': s.'previewNodeVSplitBookmark' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': 'DirNode', 'callback': s.'openNodeRecursively' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdir, 'scope': 'all', 'callback': s . 'upDirCurrentRootClosed' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': 'all', 'callback': s . 'upDirCurrentRootOpen' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': 'Node', 'callback': s . 'chRoot' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': 'Node', 'callback': s.'chCwd' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': 'all', 'callback': s.'closeTreeWindow' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': 'all', 'callback': 'nerdtree#ui_glue#chRootCwd' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': 'all', 'callback': s.'refreshRoot' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': 'Node', 'callback': s.'refreshCurrent' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': 'all', 'callback': s.'displayHelp' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': 'all', 'callback': s.'toggleZoom' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': 'all', 'callback': s.'toggleShowHidden' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': 'all', 'callback': s.'toggleIgnoreFilter' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': 'all', 'callback': s.'toggleShowFiles' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': 'all', 'callback': s.'toggleShowBookmarks' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': 'Node', 'callback': s.'closeCurrentDir' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': 'DirNode', 'callback': s.'closeChildren' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': 'Node', 'callback': s.'showMenu' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': 'Node', 'callback': s.'jumpToParent' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': 'Node', 'callback': s.'jumpToFirstChild' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': 'Node', 'callback': s.'jumpToLastChild' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': 'all', 'callback': s.'jumpToRoot' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': 'Node', 'callback': s.'jumpToNextSibling' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': 'Node', 'callback': s.'jumpToPrevSibling' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Node', 'callback': s . 'openInNewTab' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Node', 'callback': s . 'openInNewTabSilent' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Bookmark', 'callback': s . 'openInNewTab' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Bookmark', 'callback': s . 'openInNewTabSilent' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': 'DirNode', 'callback': s.'openExplorer' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': 'FileNode', 'callback': s.'openExplorer' })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': 'Bookmark', 'callback': s.'deleteBookmark' })
+endfunction
+
+
+"SECTION: Interface bindings {{{1
+"============================================================
+
+"FUNCTION: s:customOpenFile() {{{1
+" Open file node with the 'custom' key, initially <CR>.
+function! s:customOpenFile(node) abort
+    call a:node.activate(s:initCustomOpenArgs().file)
+endfunction
+
+"FUNCTION: s:customOpenDir() {{{1
+" Open directory node with the 'custom' key, initially <CR>.
+function! s:customOpenDir(node) abort
+    call s:activateDirNode(a:node, s:initCustomOpenArgs().dir)
+endfunction
+
+"FUNCTION: s:customOpenBookmark() {{{1
+" Open bookmark node with the 'custom' key, initially <CR>.
+function! s:customOpenBookmark(node) abort
+    if a:node.path.isDirectory
+        call a:node.activate(b:NERDTree, s:initCustomOpenArgs().dir)
+    else
+        call a:node.activate(b:NERDTree, s:initCustomOpenArgs().file)
+    endif
+endfunction
+
+"FUNCTION: s:initCustomOpenArgs() {{{1
+function! s:initCustomOpenArgs() abort
+    let l:defaultOpenArgs = {'file': {'reuse': 'all', 'where': 'p', 'keepopen':!nerdtree#closeTreeOnOpen()}, 'dir': {}}
+    try
+        let g:NERDTreeCustomOpenArgs = get(g:, 'NERDTreeCustomOpenArgs', {})
+        call  extend(g:NERDTreeCustomOpenArgs, l:defaultOpenArgs, 'keep')
+    catch /^Vim(\a\+):E712:/
+        call nerdtree#echoWarning('g:NERDTreeCustomOpenArgs is not set properly. Using default value.')
+        let g:NERDTreeCustomOpenArgs = l:defaultOpenArgs
+    finally
+        return g:NERDTreeCustomOpenArgs
+    endtry
+endfunction
+
+"FUNCTION: s:activateAll() {{{1
+"handle the user activating the updir line
+function! s:activateAll() abort
+    if getline('.') ==# g:NERDTreeUI.UpDirLine()
+        return nerdtree#ui_glue#upDir(0)
+    endif
+endfunction
+
+" FUNCTION: s:activateDirNode(directoryNode, options) {{{1
+" Open a directory with optional options
+function! s:activateDirNode(directoryNode, ...) abort
+
+    if a:directoryNode.isRoot() && a:directoryNode.isOpen
+        call nerdtree#echo('cannot close tree root')
+        return
+    endif
+
+    call a:directoryNode.activate((a:0 > 0) ? a:1 : {})
+endfunction
+
+"FUNCTION: s:activateFileNode() {{{1
+"handle the user activating a tree node
+function! s:activateFileNode(node) abort
+    call a:node.activate({'reuse': 'all', 'where': 'p', 'keepopen': !nerdtree#closeTreeOnOpen()})
+endfunction
+
+"FUNCTION: s:activateBookmark(bookmark) {{{1
+"handle the user activating a bookmark
+function! s:activateBookmark(bm) abort
+    call a:bm.activate(b:NERDTree, !a:bm.path.isDirectory ? {'where': 'p', 'keepopen': !nerdtree#closeTreeOnOpen()} : {})
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#bookmarkNode(name) {{{1
+" Associate the current node with the given name
+function! nerdtree#ui_glue#bookmarkNode(...) abort
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    if currentNode !=# {}
+        let name = a:1
+        if empty(name)
+            let name = currentNode.path.getLastPathComponent(0)
+        endif
+        try
+            call currentNode.bookmark(name)
+            call b:NERDTree.render()
+        catch /^NERDTree.IllegalBookmarkNameError/
+            call nerdtree#echo('bookmark names must not contain spaces')
+        endtry
+    else
+        call nerdtree#echo('select a node first')
+    endif
+endfunction
+
+" FUNCTION: s:chCwd(node) {{{1
+function! s:chCwd(node) abort
+    try
+        call a:node.path.changeToDir()
+    catch /^NERDTree.PathChangeError/
+        call nerdtree#echoWarning('could not change cwd')
+    endtry
+endfunction
+
+" FUNCTION: s:chRoot(node) {{{1
+" changes the current root to the selected one
+function! s:chRoot(node) abort
+    call b:NERDTree.changeRoot(a:node)
+endfunction
+
+" FUNCTION: s:nerdtree#ui_glue#chRootCwd() {{{1
+" Change the NERDTree root to match the current working directory.
+function! nerdtree#ui_glue#chRootCwd() abort
+    NERDTreeCWD
+endfunction
+
+" FUNCTION: nnerdtree#ui_glue#clearBookmarks(bookmarks) {{{1
+function! nerdtree#ui_glue#clearBookmarks(bookmarks) abort
+    if a:bookmarks ==# ''
+        let currentNode = g:NERDTreeFileNode.GetSelected()
+        if currentNode !=# {}
+            call currentNode.clearBookmarks()
+        endif
+    else
+        for name in split(a:bookmarks, ' ')
+            let bookmark = g:NERDTreeBookmark.BookmarkFor(name)
+            call bookmark.delete()
+        endfor
+    endif
+    call b:NERDTree.root.refresh()
+    call b:NERDTree.render()
+endfunction
+
+" FUNCTION: s:closeChildren(node) {{{1
+" closes all childnodes of the current node
+function! s:closeChildren(node) abort
+    call a:node.closeChildren()
+    call b:NERDTree.render()
+    call a:node.putCursorHere(0, 0)
+endfunction
+
+" FUNCTION: s:closeCurrentDir(node) {{{1
+" Close the parent directory of the current node.
+function! s:closeCurrentDir(node) abort
+
+    if a:node.isRoot()
+        call nerdtree#echo('cannot close parent of tree root')
+        return
+    endif
+
+    let l:parent = a:node.parent
+
+    while l:parent.isCascadable()
+        let l:parent = l:parent.parent
+    endwhile
+
+    if l:parent.isRoot()
+        call nerdtree#echo('cannot close tree root')
+        return
+    endif
+
+    call l:parent.close()
+    call b:NERDTree.render()
+    call l:parent.putCursorHere(0, 0)
+endfunction
+
+" FUNCTION: s:closeTreeWindow() {{{1
+" close the tree window
+function! s:closeTreeWindow() abort
+    if b:NERDTree.isWinTree() && b:NERDTree.previousBuf() !=# -1
+        exec 'buffer ' . b:NERDTree.previousBuf()
+    else
+        if winnr('$') > 1
+            call g:NERDTree.Close()
+        else
+            call nerdtree#echo('Cannot close last window')
+        endif
+    endif
+endfunction
+
+" FUNCTION: s:deleteBookmark(bookmark) {{{1
+" Prompt the user to confirm the deletion of the selected bookmark.
+function! s:deleteBookmark(bookmark) abort
+    let l:message = 'Delete the bookmark "' . a:bookmark.name
+                \ . '" from the bookmark list?'
+
+    let l:choices = "&Yes\n&No"
+
+    echo | redraw
+    let l:selection = confirm(l:message, l:choices, 1, 'Warning')
+
+    if l:selection !=# 1
+        call nerdtree#echo('bookmark not deleted')
+        return
+    endif
+
+    try
+        call a:bookmark.delete()
+        silent call b:NERDTree.root.refresh()
+        call b:NERDTree.render()
+        echo | redraw
+    catch /^NERDTree/
+        call nerdtree#echoWarning('could not remove bookmark')
+    endtry
+endfunction
+
+" FUNCTION: s:displayHelp() {{{1
+" toggles the help display
+function! s:displayHelp() abort
+    call b:NERDTree.ui.toggleHelp()
+    call b:NERDTree.render()
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:findAndRevealPath(pathStr) {{{1
+function! s:findAndRevealPath(pathStr) abort
+    let l:pathStr = !empty(a:pathStr) ? a:pathStr : expand('%:p')
+    let l:revealOpts = {}
+
+    if empty(l:pathStr)
+        call nerdtree#echoWarning('no file for the current buffer')
+        return
+    endif
+
+    if !filereadable(l:pathStr)
+        let l:pathStr = fnamemodify(l:pathStr, ':h')
+        let l:revealOpts['open'] = 1
+    endif
+
+    try
+        let l:pathStr = g:NERDTreePath.Resolve(l:pathStr)
+        let l:pathObj = g:NERDTreePath.New(l:pathStr)
+    catch /^NERDTree.InvalidArgumentsError/
+        call nerdtree#echoWarning('invalid path')
+        return
+    endtry
+
+    if !g:NERDTree.ExistsForTab()
+        try
+            let l:cwd = g:NERDTreePath.New(getcwd())
+        catch /^NERDTree.InvalidArgumentsError/
+            call nerdtree#echo('current directory does not exist.')
+            let l:cwd = l:pathObj.getParent()
+        endtry
+
+        if l:pathObj.isUnder(l:cwd)
+            call g:NERDTreeCreator.CreateTabTree(l:cwd.str())
+        else
+            call g:NERDTreeCreator.CreateTabTree(l:pathObj.getParent().str())
+        endif
+    else
+        NERDTreeFocus
+
+        if !l:pathObj.isUnder(b:NERDTree.root.path)
+            call s:chRoot(g:NERDTreeDirNode.New(l:pathObj.getParent(), b:NERDTree))
+        endif
+    endif
+
+    if l:pathObj.isHiddenUnder(b:NERDTree.root.path)
+        call b:NERDTree.ui.setShowHidden(1)
+    endif
+
+    let l:node = b:NERDTree.root.reveal(l:pathObj, l:revealOpts)
+    call b:NERDTree.render()
+    call l:node.putCursorHere(1, 0)
+endfunction
+
+"FUNCTION: s:handleLeftClick() {{{1
+"Checks if the click should open the current node
+function! s:handleLeftClick() abort
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    if currentNode !=# {}
+
+        "the dir arrows are multibyte chars, and vim's string functions only
+        "deal with single bytes - so split the line up with the hack below and
+        "take the line substring manually
+        let line = split(getline(line('.')), '\zs')
+        let startToCur = ''
+        for i in range(0,len(line)-1)
+            let startToCur .= line[i]
+        endfor
+
+        if currentNode.path.isDirectory
+            if startToCur =~# g:NERDTreeUI.MarkupReg() && startToCur =~# '[+~'.g:NERDTreeDirArrowExpandable.g:NERDTreeDirArrowCollapsible.'] \?$'
+                call currentNode.activate()
+                return
+            endif
+        endif
+
+        if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3
+            let char = strpart(startToCur, strlen(startToCur)-1, 1)
+            if char !~# g:NERDTreeUI.MarkupReg()
+                if currentNode.path.isDirectory
+                    call currentNode.activate()
+                else
+                    call currentNode.activate({'reuse': 'all', 'where': 'p', 'keepopen':!nerdtree#closeTreeOnOpen()})
+                endif
+                return
+            endif
+        endif
+    endif
+endfunction
+
+" FUNCTION: s:handleMiddleMouse() {{{1
+function! s:handleMiddleMouse() abort
+
+    " A middle mouse click does not automatically position the cursor as one
+    " would expect. Forcing the execution of a regular left mouse click here
+    " fixes this problem.
+    execute "normal! \<LeftMouse>"
+
+    let l:currentNode = g:NERDTreeFileNode.GetSelected()
+    if empty(l:currentNode)
+        call nerdtree#echoError('use the pointer to select a node')
+        return
+    endif
+
+    if l:currentNode.path.isDirectory
+        call l:currentNode.openExplorer()
+    else
+        call l:currentNode.open({'where': 'h'})
+    endif
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#invokeKeyMap(key) {{{1
+"this is needed since I cant figure out how to invoke dict functions from a
+"key map
+function! nerdtree#ui_glue#invokeKeyMap(key) abort
+    call g:NERDTreeKeyMap.Invoke(a:key)
+endfunction
+
+" FUNCTION: s:jumpToFirstChild(node) {{{1
+function! s:jumpToFirstChild(node) abort
+    call s:jumpToChild(a:node, 0)
+endfunction
+
+" FUNCTION: s:jumpToLastChild(node) {{{1
+function! s:jumpToLastChild(node) abort
+    call s:jumpToChild(a:node, 1)
+endfunction
+
+" FUNCTION: s:jumpToChild(node, last) {{{1
+" Jump to the first or last child node at the same file system level.
+"
+" Args:
+" node: the node on which the cursor currently sits
+" last: 1 (true) if jumping to last child, 0 (false) if jumping to first
+function! s:jumpToChild(node, last) abort
+    let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
+
+    if l:node.isRoot()
+        return
+    endif
+
+    let l:parent = l:node.parent
+    let l:children = l:parent.getVisibleChildren()
+
+    let l:target = a:last ? l:children[len(l:children) - 1] : l:children[0]
+
+    call l:target.putCursorHere(1, 0)
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:jumpToParent(node) {{{1
+" Move the cursor to the parent of the specified node.  For a cascade, move to
+" the parent of the cascade's first node.  At the root node, do nothing.
+function! s:jumpToParent(node) abort
+    let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
+
+    if l:node.isRoot()
+        return
+    endif
+
+    if empty(l:node.parent)
+        call nerdtree#echo('could not jump to parent node')
+        return
+    endif
+
+    call l:node.parent.putCursorHere(1, 0)
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:jumpToRoot() {{{1
+" moves the cursor to the root node
+function! s:jumpToRoot() abort
+    call b:NERDTree.root.putCursorHere(1, 0)
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:jumpToNextSibling(node) {{{1
+function! s:jumpToNextSibling(node) abort
+    call s:jumpToSibling(a:node, 1)
+endfunction
+
+" FUNCTION: s:jumpToPrevSibling(node) {{{1
+function! s:jumpToPrevSibling(node) abort
+    call s:jumpToSibling(a:node, 0)
+endfunction
+
+" FUNCTION: s:jumpToSibling(node, forward) {{{1
+" Move the cursor to the next or previous node at the same file system level.
+"
+" Args:
+" node: the node on which the cursor currently sits
+" forward: 0 to jump to previous sibling, 1 to jump to next sibling
+function! s:jumpToSibling(node, forward) abort
+    let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
+    let l:sibling = l:node.findSibling(a:forward)
+
+    if empty(l:sibling)
+        return
+    endif
+
+    call l:sibling.putCursorHere(1, 0)
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#openBookmark(name) {{{1
+" Open the Bookmark that has the specified name. This function provides the
+" implementation for the :OpenBookmark command.
+function! nerdtree#ui_glue#openBookmark(name) abort
+    try
+        let l:bookmark = g:NERDTreeBookmark.BookmarkFor(a:name)
+    catch /^NERDTree.BookmarkNotFoundError/
+        call nerdtree#echoError('bookmark "' . a:name . '" not found')
+        return
+    endtry
+    if l:bookmark.path.isDirectory
+        call l:bookmark.open(b:NERDTree)
+        return
+    endif
+
+    call l:bookmark.open(b:NERDTree, s:initCustomOpenArgs().file)
+endfunction
+
+" FUNCTION: s:openHSplit(target) {{{1
+function! s:openHSplit(target) abort
+    call a:target.activate({'where': 'h', 'keepopen': !nerdtree#closeTreeOnOpen()})
+endfunction
+
+" FUNCTION: s:openVSplit(target) {{{1
+function! s:openVSplit(target) abort
+    call a:target.activate({'where': 'v', 'keepopen': !nerdtree#closeTreeOnOpen()})
+endfunction
+
+"FUNCTION: s:openHSplitBookmark(bookmark) {{{1
+"handle the user activating a bookmark
+function! s:openHSplitBookmark(bm) abort
+    call a:bm.activate(b:NERDTree, !a:bm.path.isDirectory ? {'where': 'h', 'keepopen': !nerdtree#closeTreeOnOpen()} : {})
+endfunction
+
+"FUNCTION: s:openVSplitBookmark(bookmark) {{{1
+"handle the user activating a bookmark
+function! s:openVSplitBookmark(bm) abort
+    call a:bm.activate(b:NERDTree, !a:bm.path.isDirectory ? {'where': 'v', 'keepopen': !nerdtree#closeTreeOnOpen()} : {})
+endfunction
+
+" FUNCTION: s:previewHSplitBookmark(bookmark) {{{1
+function! s:previewNodeHSplitBookmark(bookmark) abort
+    call a:bookmark.activate(b:NERDTree, !a:bookmark.path.isDirectory ? {'stay': 1, 'where': 'h', 'keepopen': 1} : {})
+endfunction
+
+" FUNCTION: s:previewVSplitBookmark(bookmark) {{{1
+function! s:previewNodeVSplitBookmark(bookmark) abort
+    call a:bookmark.activate(b:NERDTree, !a:bookmark.path.isDirectory ? {'stay': 1, 'where': 'v', 'keepopen': 1} : {})
+endfunction
+
+" FUNCTION: s:openExplorer(node) {{{1
+function! s:openExplorer(node) abort
+    call a:node.openExplorer()
+endfunction
+
+" FUNCTION: s:openInNewTab(target) {{{1
+function! s:openInNewTab(target) abort
+    let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't', 'keepopen': !nerdtree#closeTreeOnOpen()})
+    call l:opener.open(a:target)
+endfunction
+
+" FUNCTION: s:openInNewTabSilent(target) {{{1
+function! s:openInNewTabSilent(target) abort
+    let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't', 'keepopen': !nerdtree#closeTreeOnOpen(), 'stay': 1})
+    call l:opener.open(a:target)
+endfunction
+
+" FUNCTION: s:openNodeRecursively(node) {{{1
+function! s:openNodeRecursively(node) abort
+    call nerdtree#echo('Recursively opening node. Please wait...')
+    call a:node.openRecursively()
+    call b:NERDTree.render()
+    call nerdtree#echo('')
+endfunction
+
+" FUNCTION: s:previewBookmark(bookmark) {{{1
+function! s:previewBookmark(bookmark) abort
+    if a:bookmark.path.isDirectory
+        execute 'NERDTreeFind '.a:bookmark.path.str()
+    else
+        call a:bookmark.activate(b:NERDTree, {'stay': 1, 'where': 'p', 'keepopen': 1})
+    endif
+endfunction
+
+"FUNCTION: s:previewNodeCurrent(node) {{{1
+function! s:previewNodeCurrent(node) abort
+    call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1})
+endfunction
+
+"FUNCTION: s:previewNodeHSplit(node) {{{1
+function! s:previewNodeHSplit(node) abort
+    call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1})
+endfunction
+
+"FUNCTION: s:previewNodeVSplit(node) {{{1
+function! s:previewNodeVSplit(node) abort
+    call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1})
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#revealBookmark(name) {{{1
+" put the cursor on the node associate with the given name
+function! nerdtree#ui_glue#revealBookmark(name) abort
+    try
+        let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0, b:NERDTree)
+        call targetNode.putCursorHere(0, 1)
+    catch /^NERDTree.BookmarkNotFoundError/
+        call nerdtree#echo('Bookmark isn''t cached under the current root')
+    endtry
+endfunction
+
+" FUNCTION: s:refreshRoot() {{{1
+" Reloads the current root. All nodes below this will be lost and the root dir
+" will be reloaded.
+function! s:refreshRoot() abort
+    if !g:NERDTree.IsOpen()
+        return
+    endif
+    call nerdtree#echo('Refreshing the root node. This could take a while...')
+
+    let l:curWin = winnr()
+    call nerdtree#exec(g:NERDTree.GetWinNum() . 'wincmd w', 1)
+    call b:NERDTree.root.refresh()
+    call b:NERDTree.render()
+    redraw
+    call nerdtree#exec(l:curWin . 'wincmd w', 1)
+    call nerdtree#echo('')
+endfunction
+
+" FUNCTION: s:refreshCurrent(node) {{{1
+" refreshes the root for the current node
+function! s:refreshCurrent(node) abort
+    let node = a:node
+    if !node.path.isDirectory
+        let node = node.parent
+    endif
+
+    call nerdtree#echo('Refreshing node. This could take a while...')
+    call node.refresh()
+    call b:NERDTree.render()
+    call nerdtree#echo('')
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#setupCommands() {{{1
+function! nerdtree#ui_glue#setupCommands() abort
+    command! -n=? -complete=dir -bar NERDTree :call g:NERDTreeCreator.CreateTabTree('<args>')
+    command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.ToggleTabTree('<args>')
+    command! -n=0 -bar NERDTreeClose :call g:NERDTree.Close()
+    command! -n=1 -complete=customlist,nerdtree#completeBookmarks -bar NERDTreeFromBookmark call g:NERDTreeCreator.CreateTabTree('<args>')
+    command! -n=0 -bar NERDTreeMirror call g:NERDTreeCreator.CreateMirror()
+    command! -n=? -complete=file -bar NERDTreeFind call s:findAndRevealPath('<args>')
+    command! -n=0 -bar NERDTreeRefreshRoot call s:refreshRoot()
+    command! -n=0 -bar NERDTreeFocus call NERDTreeFocus()
+    command! -n=0 -bar NERDTreeCWD call NERDTreeCWD()
+endfunction
+
+" Function: s:SID()   {{{1
+function! s:SID() abort
+    if !exists('s:sid')
+        let s:sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
+    endif
+    return s:sid
+endfun
+
+" FUNCTION: s:showMenu(node) {{{1
+function! s:showMenu(node) abort
+    let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled())
+    call mc.showMenu()
+endfunction
+
+" FUNCTION: s:toggleIgnoreFilter() {{{1
+function! s:toggleIgnoreFilter() abort
+    call b:NERDTree.ui.toggleIgnoreFilter()
+endfunction
+
+" FUNCTION: s:toggleShowBookmarks() {{{1
+function! s:toggleShowBookmarks() abort
+    call b:NERDTree.ui.toggleShowBookmarks()
+endfunction
+
+" FUNCTION: s:toggleShowFiles() {{{1
+function! s:toggleShowFiles() abort
+    call b:NERDTree.ui.toggleShowFiles()
+endfunction
+
+" FUNCTION: s:toggleShowHidden() {{{1
+" toggles the display of hidden files
+function! s:toggleShowHidden() abort
+    call b:NERDTree.ui.toggleShowHidden()
+endfunction
+
+" FUNCTION: s:toggleZoom() {{{1
+function! s:toggleZoom() abort
+    call b:NERDTree.ui.toggleZoom()
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#upDir(preserveState) {{{1
+" Move the NERDTree up one level.
+"
+" Args:
+" preserveState: if 1, the current root is left open when the new tree is
+" rendered; if 0, the current root node is closed
+function! nerdtree#ui_glue#upDir(preserveState) abort
+
+    try
+        call b:NERDTree.root.cacheParent()
+    catch /^NERDTree.CannotCacheParentError/
+        call nerdtree#echo('already at root directory')
+        return
+    endtry
+
+    let l:oldRoot = b:NERDTree.root
+    let l:newRoot = b:NERDTree.root.parent
+
+    call l:newRoot.open()
+    call l:newRoot.transplantChild(l:oldRoot)
+
+    if !a:preserveState
+        call l:oldRoot.close()
+    endif
+
+    call b:NERDTree.changeRoot(l:newRoot)
+    call l:oldRoot.putCursorHere(0, 0)
+endfunction
+
+" FUNCTION: s:upDirCurrentRootOpen() {{{1
+function! s:upDirCurrentRootOpen() abort
+    call nerdtree#ui_glue#upDir(1)
+endfunction
+
+" FUNCTION: s:upDirCurrentRootClosed() {{{1
+function! s:upDirCurrentRootClosed() abort
+    call nerdtree#ui_glue#upDir(0)
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/doc/NERDTree.txt b/.vim/bundle/vim-nerdtree/doc/NERDTree.txt
new file mode 100644
index 0000000..55c25cd
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/doc/NERDTree.txt
@@ -0,0 +1,1534 @@
+*NERDTree.txt*   A tree explorer plugin to rule the Vim world. Bwahahaha!!
+
+                                    # #### ####                                ~
+                                  ### \/#|### |/####                           ~
+   d8   888                      ##\/#/ \||/##/_/##/_#                         ~
+  d88   888 ee   ,e e,         ###  \/###|/ \/ # ###                           ~
+ d88888 888 88b d88 88b      ##_\_#\_\## | #/###_/_####                        ~
+  888   888 888 888   ,     ## #### # \ #| /  #### ##/##                       ~
+  888   888 888  "YeeP"     __#_--###`. |{,###---###-~                         ~
+                                     \ % @%                                    ~
+  Y88b Y88 888'Y88 888 88e  888 88e   \%@%  88P'888'Y88                        ~
+   Y88b Y8 888 ,'Y 888 888D 888 888b   %o%  P'  888  'Y 888,8,  ,e e,   ,e e,  ~
+  b Y88b Y 888C8   888 88"  888 8888D  %@%      888     888 "  d88 88b d88 88b ~
+  8b Y88b  888 ",d 888 b,   888 888P   %@%      888     888    888   , 888   , ~
+  88b Y88b 888,d88 888 88b, 888 88"    %@%      888     888     "YeeP"  "YeeP" ~
+                                 , -=-%{@%-^- _                                ~
+                                   ejm `}               Reference Manual       ~
+                                        {                                      ~
+==============================================================================
+CONTENTS                                                     *NERDTree-contents*
+
+    1.Intro...................................|NERDTree|
+    2.Functionality provided..................|NERDTreeFunctionality|
+        2.1.Global commands...................|NERDTreeGlobalCommands|
+        2.2.Bookmarks.........................|NERDTreeBookmarks|
+            2.2.1.The bookmark table..........|NERDTreeBookmarkTable|
+            2.2.2.Bookmark commands...........|NERDTreeBookmarkCommands|
+            2.2.3.Invalid bookmarks...........|NERDTreeInvalidBookmarks|
+        2.3.NERDTree mappings.................|NERDTreeMappings|
+        2.4.The NERDTree menu.................|NERDTreeMenu|
+    3.Settings................................|NERDTreeSettings|
+        3.1.Settings summary..................|NERDTreeSettingsSummary|
+        3.2.Settings details..................|NERDTreeSettingsDetails|
+    4.The NERDTree API........................|NERDTreeAPI|
+        4.1.Key map API.......................|NERDTreeKeymapAPI|
+        4.2.Menu API..........................|NERDTreeMenuAPI|
+        4.3.Menu API..........................|NERDTreeAddPathFilter()|
+        4.4.Path Listener API.................|NERDTreePathListenerAPI|
+    5.About...................................|NERDTreeAbout|
+    6.License.................................|NERDTreeLicense|
+
+==============================================================================
+1. Intro                                                              *NERDTree*
+
+What is this "NERDTree"??
+
+The NERDTree allows you to explore your filesystem and to open files and
+directories. It presents the filesystem to you in the form of a tree which you
+manipulate with the keyboard and/or mouse. It also allows you to perform
+simple filesystem operations.
+
+The following features and functionality are provided by the NERDTree:
+    * Files and directories are displayed in a hierarchical tree structure
+    * Different highlighting is provided for the following types of nodes:
+        * files
+        * directories
+        * sym-links
+        * windows .lnk files
+        * read-only files
+        * executable files
+    * Many (customisable) mappings are provided to manipulate the tree:
+        * Mappings to open/close/explore directory nodes
+        * Mappings to open files in new/existing windows/tabs
+        * Mappings to change the current root of the tree
+        * Mappings to navigate around the tree
+        * ...
+    * Directories and files can be bookmarked.
+    * Most NERDTree navigation can also be done with the mouse
+    * Filtering of tree content (can be toggled at runtime)
+        * custom file filters to prevent e.g. vim backup files being displayed
+        * optional displaying of hidden files (. files)
+        * files can be "turned off" so that only directories are displayed
+    * The position and size of the NERDTree window can be customised
+    * The order in which the nodes in the tree are listed can be customised.
+    * A model of your filesystem is created/maintained as you explore it. This
+      has several advantages:
+        * All filesystem information is cached and is only re-read on demand
+        * If you revisit a part of the tree that you left earlier in your
+          session, the directory nodes will be opened/closed as you left them
+    * The script remembers the cursor position and window position in the NERD
+      tree so you can toggle it off (or just close the tree window) and then
+      reopen it (with NERDTreeToggle) the NERDTree window will appear exactly
+      as you left it
+    * You can have a separate NERDTree for each tab, share trees across tabs,
+      or a mix of both.
+    * By default the script overrides the default file browser (netrw), so if
+      you :edit a directory a (slightly modified) NERDTree will appear in the
+      current window
+    * A programmable menu system is provided (simulates right clicking on a
+      node)
+        * one default menu plugin is provided to perform basic filesystem
+          operations (create/delete/move/copy files/directories)
+    * There's an API for adding your own keymappings
+
+
+==============================================================================
+2. Functionality provided                                *NERDTreeFunctionality*
+
+------------------------------------------------------------------------------
+2.1. Global Commands                                    *NERDTreeGlobalCommands*
+
+:NERDTree [<start-directory> | <bookmark>]                           *:NERDTree*
+    Opens a fresh NERDTree. The root of the tree depends on the argument
+    given. There are 3 cases: If no argument is given, the current directory
+    will be used.  If a directory is given, that will be used. If a bookmark
+    name is given, the corresponding directory will be used.  For example: >
+        :NERDTree /home/marty/vim7/src
+        :NERDTree foo   (foo is the name of a bookmark)
+<
+:NERDTreeVCS [<start-directory> | <bookmark>]                     *:NERDTreeVCS*
+    Like |:NERDTree|, but searches up the directory tree to find the top of
+    the version control system repository, and roots the NERDTree there. It
+    works with Git, Subversion, Mercurial, Bazaar, and Darcs repositories. A
+    couple of examples: >
+        :NERDTreeVCS /home/marty/nerdtree/doc  (opens /home/marty/nerdtree)
+        :NERDTreeVCS              (opens root of repository containing CWD)
+<
+:NERDTreeFromBookmark <bookmark>                         *:NERDTreeFromBookmark*
+    Opens a fresh NERDTree with the root initialized to the directory for
+    <bookmark>.  The only reason to use this command over :NERDTree is for
+    the completion (which is for bookmarks rather than directories).
+
+:NERDTreeToggle [<start-directory> | <bookmark>]               *:NERDTreeToggle*
+    If a NERDTree already exists for this tab, it is reopened and rendered
+    again. If <start-directory> or <bookmark> is given, the root of NERDTree
+    is set to that path. If no NERDTree exists for this tab then this command
+    acts the same as the |:NERDTree| command.
+
+:NERDTreeToggleVCS [<start-directory> | <bookmark>]         *:NERDTreeToggleVCS*
+    Like |:NERDTreeToggle|, but searches up the directory tree to find the top of
+    the version control system repository, and roots the NERDTree there. It
+    works with Git, Subversion, Mercurial, Bazaar, and Darcs repositories. A
+    couple of examples: >
+        :NERDTreeToggleVCS /home/marty/nerdtree/doc  (opens /home/marty/nerdtree)
+        :NERDTreeToggleVCS              (opens root of repository containing CWD)
+
+:NERDTreeFocus                                                  *:NERDTreeFocus*
+    Opens (or reopens) the NERDTree if it is not currently visible;
+    otherwise, the cursor is moved to the already-open NERDTree.
+
+:NERDTreeMirror                                                *:NERDTreeMirror*
+    Shares an existing NERDTree, from another tab, in the current tab.
+    Changes made to one tree are reflected in both as they are actually the
+    same buffer.
+
+    If only one other NERDTree exists, that tree is automatically mirrored.
+    If more than one exists, the script will ask which tree to mirror.
+
+:NERDTreeClose                                                  *:NERDTreeClose*
+    Close the NERDTree in this tab.
+
+:NERDTreeFind [<path>]                                           *:NERDTreeFind*
+    Without the optional argument, find and reveal the file for the active
+    buffer in the NERDTree window.  With the <path> argument, find and
+    reveal the specified path.
+
+    Focus will be shifted to the NERDTree window, and the cursor will be
+    placed on the tree node for the determined path.  If a NERDTree for the
+    current tab does not exist, a new one will be initialized.
+
+:NERDTreeCWD                                                      *:NERDTreeCWD*
+    Change the NERDTree root to the current working directory.  If no
+    NERDTree exists for this tab, a new one is opened.
+
+:NERDTreeRefreshRoot                                      *:NERDTreeRefreshRoot*
+    Refreshes the NERDTree root node.
+
+------------------------------------------------------------------------------
+2.2. Bookmarks                                               *NERDTreeBookmarks*
+
+Bookmarks in the NERDTree are a way to tag files or directories of interest.
+For example, you could use bookmarks to tag all of your project directories.
+
+------------------------------------------------------------------------------
+2.2.1. The Bookmark Table                                *NERDTreeBookmarkTable*
+
+If the bookmark table is active (see |NERDTree-B| and
+|NERDTreeShowBookmarks|), it will be rendered above the tree. You can double
+click bookmarks or use the |NERDTree-o| mapping to activate them. See also,
+|NERDTree-t| and |NERDTree-T|
+
+------------------------------------------------------------------------------
+2.2.2. Bookmark commands                              *NERDTreeBookmarkCommands*
+
+Note: The following commands are only available within the NERDTree buffer.
+
+:Bookmark [<name>]
+    Bookmark the current node as <name>. If there is already a <name>
+    bookmark, it is overwritten. <name> must not contain spaces.
+    If <name> is not provided, it defaults to the file or directory name.
+    For directories, a trailing slash is present.
+
+:BookmarkToRoot <bookmark>
+    Make the directory corresponding to <bookmark> the new root. If a treenode
+    corresponding to <bookmark> is already cached somewhere in the tree then
+    the current tree will be used, otherwise a fresh tree will be opened.
+    Note that if <bookmark> points to a file then its parent will be used
+    instead.
+
+:RevealBookmark <bookmark>
+    If the node is cached under the current root then it will be revealed
+    (i.e. directory nodes above it will be opened) and the cursor will be
+    placed on it.
+
+:OpenBookmark <name>
+    The Bookmark named <name> is opened as if |NERDTree-o| was applied to
+    its entry in the Bookmark table. If the Bookmark points to a directory,
+    it is made the new root of the current NERDTree. If the Bookmark points
+    to a file, that file is opened for editing in another window.
+
+:ClearBookmarks [<bookmarks>]
+    Remove all the given bookmarks. If no bookmarks are given then remove all
+    bookmarks on the current node.
+
+:ClearAllBookmarks
+    Remove all bookmarks.
+
+:EditBookmarks
+    Opens the bookmarks file for manual editing, e.g. for removing invalid
+    bookmarks.
+
+:ReadBookmarks
+    Re-read the bookmarks in the |NERDTreeBookmarksFile|.
+
+See also |:NERDTree| and |:NERDTreeFromBookmark|.
+
+------------------------------------------------------------------------------
+2.2.3. Invalid Bookmarks                              *NERDTreeInvalidBookmarks*
+
+If invalid bookmarks are detected, the script will issue an error message and
+the invalid bookmarks will become unavailable for use.
+
+These bookmarks will still be stored in the bookmarks file (see
+|NERDTreeBookmarksFile|), down at the bottom. There will always be a blank line
+after the valid bookmarks but before the invalid ones.
+
+Each line in the bookmarks file represents one bookmark. The proper format is:
+<bookmark name><space><full path to the bookmark location>
+
+You can use the :EditBookmarks command to open the bookmarks file for editing.
+After you have corrected any invalid bookmarks, either restart vim, or run
+:ReadBookmarks from the NERDTree window.
+
+------------------------------------------------------------------------------
+2.3. NERDTree Mappings                                        *NERDTreeMappings*
+
+Default~
+Key      Description                                                  help-tag~
+
+o........Open files, directories and bookmarks......................|NERDTree-o|
+go.......Open selected file, but leave cursor in the NERDTree......|NERDTree-go|
+         Find selected bookmark directory in current NERDTree
+t........Open selected node/bookmark in a new tab...................|NERDTree-t|
+T........Same as 't' but keep the focus on the current tab..........|NERDTree-T|
+i........Open selected file in a split window.......................|NERDTree-i|
+gi.......Same as i, but leave the cursor on the NERDTree...........|NERDTree-gi|
+s........Open selected file in a new vsplit.........................|NERDTree-s|
+gs.......Same as s, but leave the cursor on the NERDTree...........|NERDTree-gs|
+<CR>.....User-definable custom open action.......................|NERDTree-<CR>|
+O........Recursively open the selected directory....................|NERDTree-O|
+x........Close the current nodes parent.............................|NERDTree-x|
+X........Recursively close all children of the current node.........|NERDTree-X|
+e........Edit the current directory.................................|NERDTree-e|
+
+double-click....same as |NERDTree-o|.
+middle-click....same as |NERDTree-i| for files, and |NERDTree-e| for directories.
+
+D........Delete the current bookmark ...............................|NERDTree-D|
+
+P........Jump to the root node......................................|NERDTree-P|
+p........Jump to current nodes parent...............................|NERDTree-p|
+K........Jump up inside directories at the current tree depth.......|NERDTree-K|
+J........Jump down inside directories at the current tree depth.....|NERDTree-J|
+<C-J>....Jump down to next sibling of the current directory.......|NERDTree-C-J|
+<C-K>....Jump up to previous sibling of the current directory.....|NERDTree-C-K|
+
+C........Change the tree root to the selected directory.............|NERDTree-C|
+u........Move the tree root up one directory........................|NERDTree-u|
+U........Same as 'u' except the old root node is left open..........|NERDTree-U|
+r........Recursively refresh the current directory..................|NERDTree-r|
+R........Recursively refresh the current root.......................|NERDTree-R|
+m........Display the NERDTree menu..................................|NERDTree-m|
+cd.......Change the CWD to the directory of the selected node......|NERDTree-cd|
+CD.......Change tree root to the CWD...............................|NERDTree-CD|
+
+I........Toggle whether hidden files displayed......................|NERDTree-I|
+f........Toggle whether the file filters are used...................|NERDTree-f|
+F........Toggle whether files are displayed.........................|NERDTree-F|
+B........Toggle whether the bookmark table is displayed.............|NERDTree-B|
+
+q........Close the NERDTree window..................................|NERDTree-q|
+A........Zoom (maximize/minimize) the NERDTree window...............|NERDTree-A|
+?........Toggle the display of the quick help.......................|NERDTree-?|
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-o*
+Default key: o
+Map setting: NERDTreeMapActivateNode
+Applies to: files and directories.
+
+If a file node is selected, it is opened in the previous window.
+
+If a directory is selected it is opened or closed depending on its current
+state.
+
+If a bookmark that links to a directory is selected then that directory
+becomes the new root.
+
+If a bookmark that links to a file is selected then that file is opened in the
+previous window.
+
+------------------------------------------------------------------------------
+                                                                   *NERDTree-go*
+Default key: go
+Map setting: NERDTreeMapPreview
+Applies to: files.
+
+If a file node or a bookmark that links to a file is selected, it is opened in
+the previous window, but the cursor does not move.
+
+If a bookmark that links to a directory is selected then that directory
+becomes the new root.
+
+The default key combo for this mapping is "g" + NERDTreeMapActivateNode (see
+|NERDTree-o|).
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-t*
+Default key: t
+Map setting: *NERDTreeMapOpenInTab*
+Applies to: files and directories.
+
+Opens the selected file in a new tab. If a directory is selected, a fresh
+NERDTree for that directory is opened in a new tab.
+
+If a bookmark which points to a directory is selected, open a NERDTree for
+that directory in a new tab. If the bookmark points to a file, open that file
+in a new tab.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-T*
+Default key: T
+Map setting: *NERDTreeMapOpenInTabSilent*
+Applies to: files and directories.
+
+The same as |NERDTree-t| except that the focus is kept in the current tab.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-i*
+Default key: i
+Map setting: *NERDTreeMapOpenSplit*
+Applies to: files, and bookmarks pointing to files.
+
+Opens the selected file in a new split window and puts the cursor in the new
+window.
+
+------------------------------------------------------------------------------
+                                                                   *NERDTree-gi*
+Default key: gi
+Map setting: *NERDTreeMapPreviewSplit*
+Applies to: files, and bookmarks pointing to files.
+
+The same as |NERDTree-i| except that the cursor is not moved.
+
+The default key combo for this mapping is "g" + NERDTreeMapOpenSplit (see
+|NERDTree-i|).
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-s*
+Default key: s
+Map setting: *NERDTreeMapOpenVSplit*
+Applies to: files, and bookmarks pointing to files.
+
+Opens the selected file in a new vertically split window and puts the cursor
+in the new window.
+
+------------------------------------------------------------------------------
+                                                                   *NERDTree-gs*
+Default key: gs
+Map setting: *NERDTreeMapPreviewVSplit*
+Applies to: files, and bookmarks pointing to files.
+
+The same as |NERDTree-s| except that the cursor is not moved.
+
+The default key combo for this mapping is "g" + NERDTreeMapOpenVSplit (see
+|NERDTree-s|).
+
+------------------------------------------------------------------------------
+                                                                 *NERDTree-<CR>*
+Default key: <CR>
+Map setting: *NERDTreeMapCustomOpen*
+Applies to: files, directories, and bookmarks
+
+Performs a customized open action on the selected node. This allows the user
+to define an action that behaves differently from any of the standard
+keys. See |NERDTreeCustomOpenArgs| for more details.
+------------------------------------------------------------------------------
+                                                                    *NERDTree-O*
+Default key: O
+Map setting: *NERDTreeMapOpenRecursively*
+Applies to: directories.
+
+Recursively opens the selected directory.
+
+All files and directories are cached, but if a directory would not be
+displayed due to file filters (see |NERDTreeIgnore| |NERDTree-f|) or the
+hidden file filter (see |NERDTreeShowHidden|) then its contents are not
+cached. This is handy, especially if you have .svn directories.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-x*
+Default key: x
+Map setting: *NERDTreeMapCloseDir*
+Applies to: files and directories.
+
+Closes the parent of the selected node.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-X*
+Default key: X
+Map setting: *NERDTreeMapCloseChildren*
+Applies to: directories.
+
+Recursively closes all children of the selected directory.
+
+Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-e*
+Default key: e
+Map setting: *NERDTreeMapOpenExpl*
+Applies to: files and directories.
+
+|:edit|s the selected directory, or the selected file's directory. This could
+result in a NERDTree or a netrw being opened, depending on
+|NERDTreeHijackNetrw|.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-D*
+Default key: D
+Map setting: *NERDTreeMapDeleteBookmark*
+Applies to: lines in the bookmarks table
+
+Deletes the currently selected bookmark.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-P*
+Default key: P
+Map setting: *NERDTreeMapJumpRoot*
+Applies to: no restrictions.
+
+Jump to the tree root.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-p*
+Default key: p
+Map setting: *NERDTreeMapJumpParent*
+Applies to: files and directories.
+
+Jump to the parent node of the selected node.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-K*
+Default key: K
+Map setting: *NERDTreeMapJumpFirstChild*
+Applies to: files and directories.
+
+Jump to the first child of the current nodes parent.
+
+If the cursor is already on the first node then do the following:
+    * loop back thru the siblings of the current nodes parent until we find an
+      open directory with children
+    * go to the first child of that node
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-J*
+Default key: J
+Map setting: *NERDTreeMapJumpLastChild*
+Applies to: files and directories.
+
+Jump to the last child of the current nodes parent.
+
+If the cursor is already on the last node then do the following:
+    * loop forward thru the siblings of the current nodes parent until we find
+      an open directory with children
+    * go to the last child of that node
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-C-J*
+Default key: <C-J>
+Map setting: *NERDTreeMapJumpNextSibling*
+Applies to: files and directories.
+
+Jump to the next sibling of the selected node.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-C-K*
+Default key: <C-K>
+Map setting: *NERDTreeMapJumpPrevSibling*
+Applies to: files and directories.
+
+Jump to the previous sibling of the selected node.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-C*
+Default key: C
+Map setting: *NERDTreeMapChangeRoot*
+Applies to: files and directories.
+
+Make the selected directory node the new tree root. If a file is selected, its
+parent is used.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-u*
+Default key: u
+Map setting: *NERDTreeMapUpdir*
+Applies to: no restrictions.
+
+Move the tree root up a directory (like doing a "cd ..").
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-U*
+Default key: U
+Map setting: *NERDTreeMapUpdirKeepOpen*
+Applies to: no restrictions.
+
+Like |NERDTree-u| except that the old tree root is kept open.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-r*
+Default key: r
+Map setting: *NERDTreeMapRefresh*
+Applies to: files and directories.
+
+If a directory is selected, recursively refresh that directory, i.e. scan the
+filesystem for changes and represent them in the tree.
+
+If a file node is selected then the above is done on it's parent.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-R*
+Default key: R
+Map setting: *NERDTreeMapRefreshRoot*
+Applies to: no restrictions.
+
+Recursively refresh the tree root.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-m*
+Default key: m
+Map setting: *NERDTreeMapMenu*
+Applies to: files and directories.
+
+Display the NERDTree menu. See |NERDTreeMenu| for details.
+
+------------------------------------------------------------------------------
+                                                                   *NERDTree-cd*
+Default key: cd
+Map setting: *NERDTreeMapChdir*
+Applies to: files and directories.
+
+Change Vim's current working directory to that of the selected node.
+
+------------------------------------------------------------------------------
+                                                                   *NERDTree-CD*
+Default key: CD
+Map setting: *NERDTreeMapCWD*
+Applies to: no restrictions.
+
+Change the NERDTree root to Vim's current working directory.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-I*
+Default key: I
+Map setting: *NERDTreeMapToggleHidden*
+Applies to: no restrictions.
+
+Toggles whether hidden files (i.e. "dot files") are displayed.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-f*
+Default key: f
+Map setting: *NERDTreeMapToggleFilters*
+Applies to: no restrictions.
+
+Toggles whether file filters are used. See |NERDTreeIgnore| for details.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-F*
+Default key: F
+Map setting: *NERDTreeMapToggleFiles*
+Applies to: no restrictions.
+
+Toggles whether file nodes are displayed.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-B*
+Default key: B
+Map setting: *NERDTreeMapToggleBookmarks*
+Applies to: no restrictions.
+
+Toggles whether the bookmarks table is displayed.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-q*
+Default key: q
+Map setting: *NERDTreeMapQuit*
+Applies to: no restrictions.
+
+Closes the NERDTree window.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-A*
+Default key: A
+Map setting: *NERDTreeMapToggleZoom*
+Applies to: no restrictions.
+
+Maximize (zoom) and minimize the NERDTree window.
+
+------------------------------------------------------------------------------
+                                                                    *NERDTree-?*
+Default key: ?
+Map setting: *NERDTreeMapHelp*
+Applies to: no restrictions.
+
+Toggles whether the quickhelp is displayed.
+
+------------------------------------------------------------------------------
+ 2.3. The NERDTree menu                                           *NERDTreeMenu*
+
+The NERDTree has a menu that can be programmed via the an API (see
+|NERDTreeMenuAPI|). The idea is to simulate the "right click" menus that most
+file explorers have.
+
+The script comes with two default menu plugins: exec_menuitem.vim and
+fs_menu.vim. fs_menu.vim adds some basic filesystem operations to the menu for
+creating/deleting/moving/copying files and directories. exec_menuitem.vim
+provides a menu item to execute executable files.
+
+Related tags: |NERDTree-m| |NERDTreeApi|
+
+------------------------------------------------------------------------------
+                                                                *NERDTreeMenu-j*
+Default key: j
+Map option: *NERDTreeMenuDown*
+Applies to: The NERDTree menu.
+
+Moves the cursor down.
+
+------------------------------------------------------------------------------
+                                                                *NERDTreeMenu-k*
+Default key: k
+Map option: *NERDTreeMenuUp*
+Applies to: The NERDTree menu.
+
+Moves the cursor up.
+
+==============================================================================
+3. Customisation                                              *NERDTreeSettings*
+
+
+------------------------------------------------------------------------------
+3.1. Customisation summary                             *NERDTreeSettingsSummary*
+
+The plugin provides the following settings that can customise the behaviour
+the NERDTree. These settings should be set in your vimrc, using `:let`.
+
+|loaded_nerd_tree|            Turns off the script.
+
+|NERDTreeAutoCenter|          Controls whether the NERDTree window centers
+                            when the cursor moves within a specified
+                            distance to the top/bottom of the window.
+
+|NERDTreeAutoCenterThreshold| Controls the sensitivity of autocentering.
+
+|NERDTreeCaseSensitiveSort|   Tells the NERDTree whether to be case
+                            sensitive or not when sorting nodes.
+
+|NERDTreeNaturalSort|         Tells the NERDTree whether to use natural sort
+                            order or not when sorting nodes.
+
+|NERDTreeSortHiddenFirst|     Tells the NERDTree whether to take the dot at
+                            the beginning of the hidden file names into
+                            account when sorting nodes.
+
+|NERDTreeChDirMode|           Tells the NERDTree if/when it should change
+                            vim's current working directory.
+
+|NERDTreeHighlightCursorline| Tell the NERDTree whether to highlight the
+                            current cursor line.
+
+|NERDTreeHijackNetrw|         Tell the NERDTree whether to replace the netrw
+                            autocommands for exploring local directories.
+
+|NERDTreeIgnore|              Tells the NERDTree which files to ignore.
+
+|NERDTreeRespectWildIgnore|   Tells the NERDTree to respect `'wildignore'`.
+
+|NERDTreeBookmarksFile|       Where the bookmarks are stored.
+
+|NERDTreeBookmarksSort|       Control how the Bookmark table is sorted.
+
+|NERDTreeMarkBookmarks|       Render bookmarked nodes with markers.
+
+|NERDTreeMouseMode|           Manage the interpretation of mouse clicks.
+
+|NERDTreeQuitOnOpen|          Closes the tree window or bookmark table after
+                            opening a file.
+
+|NERDTreeShowBookmarks|       Tells the NERDTree whether to display the
+                            bookmarks table on startup.
+
+|NERDTreeShowFiles|           Tells the NERDTree whether to display files in
+                            the tree on startup.
+
+|NERDTreeShowHidden|          Tells the NERDTree whether to display hidden
+                            files on startup.
+
+|NERDTreeShowLineNumbers|     Tells the NERDTree whether to display line
+                            numbers in the tree window.
+
+|NERDTreeSortOrder|           Tell the NERDTree how to sort the nodes in the
+                            tree.
+
+|NERDTreeStatusline|          Set a statusline for NERDTree windows.
+
+|NERDTreeWinPos|              Tells the script where to put the NERDTree
+                            window.
+
+|NERDTreeWinSize|             Sets the window size when the NERDTree is
+                            opened.
+
+|NERDTreeWinSizeMax|          Sets the maximum window size when the NERDTree
+                            is zoomed.
+
+|NERDTreeMinimalUI|           Disables display of the 'Bookmarks' label and
+                            'Press ? for help' text.
+
+|NERDTreeMinimalMenu|         Use a compact menu that fits on a single line
+                            for adding, copying, deleting, etc
+
+|NERDTreeCascadeSingleChildDir|
+                            Collapses on the same line directories that have
+                            only one child directory.
+
+|NERDTreeCascadeOpenSingleChildDir|
+                            Cascade open while selected directory has only
+                            one child that also is a directory.
+
+|NERDTreeAutoDeleteBuffer|    Tells the NERDTree to automatically remove a
+                            buffer when a file is being deleted or renamed
+                            via a context menu command.
+
+|NERDTreeCreatePrefix|        Specify a prefix to be used when creating the
+                            NERDTree window.
+
+|NERDTreeRemoveFileCmd|       Specify a custom shell command to be used when
+                            deleting files. Note that it should include one
+                            space character at the end of the command and it
+                            applies only to files.
+
+|NERDTreeRemoveDirCmd|        Specify a custom shell command to be used when
+                            deleting directories. Note that it should
+                            include one space character at the end of the
+                            command and it applies only to directories.
+
+|NERDTreeDirArrowCollapsible| These characters indicate when a directory is
+|NERDTreeDirArrowExpandable|  either collapsible or expandable.
+
+|NERDTreeNodeDelimiter|       A single character that is used to separate the
+                            file or directory name from the rest of the
+                            characters on the line of text.
+
+|NERDTreeCustomOpenArgs|      A dictionary with values that control how a node
+                            is opened with the |NERDTree-<CR>| key.
+
+------------------------------------------------------------------------------
+3.2. Customisation details                             *NERDTreeSettingsDetails*
+
+To enable any of the below settings you should put an appropriate >
+    let <setting>=<value>
+<line in your ~/.vimrc.
+
+                                                              *loaded_nerd_tree*
+If this plugin is making you feel homicidal, it may be a good idea to turn it
+off with this line in your vimrc: >
+    let loaded_nerd_tree=1
+<
+------------------------------------------------------------------------------
+                                                            *NERDTreeAutoCenter*
+Values: 0 or 1.
+Default: 1
+
+If set to 1, the NERDTree window will center around the cursor if it moves to
+within |NERDTreeAutoCenterThreshold| lines of the top/bottom of the window.
+
+This is ONLY done in response to tree navigation mappings,
+i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-C-K| |NERDTree-p|
+|NERDTree-P|
+
+The centering is done with a |zz| operation.
+
+------------------------------------------------------------------------------
+                                                   *NERDTreeAutoCenterThreshold*
+Values: Any natural number.
+Default: 3
+
+This setting controls the "sensitivity" of the NERDTree auto centering. See
+|NERDTreeAutoCenter| for details.
+
+------------------------------------------------------------------------------
+                                                     *NERDTreeCaseSensitiveSort*
+Values: 0 or 1.
+Default: 0.
+
+By default the NERDTree does not sort nodes case sensitively, i.e. nodes
+could appear like this: >
+    bar.c
+    Baz.c
+    blarg.c
+    boner.c
+    Foo.c
+<
+But, if you set this setting to 1 then the case of the nodes will be taken
+into account. The above nodes would then be sorted like this: >
+    Baz.c
+    Foo.c
+    bar.c
+    blarg.c
+    boner.c
+<
+------------------------------------------------------------------------------
+                                                           *NERDTreeNaturalSort*
+Values: 0 or 1.
+Default: 0.
+
+By default the NERDTree does not sort nodes in natural sort order, i.e. nodes
+could appear like this: >
+    z1.txt
+    z10.txt
+    z100.txt
+    z11.txt
+    z110.txt
+    z2.txt
+    z20.txt
+    z3.txt
+<
+But if you set this setting to 1 then the natural sort order will be used. The
+above nodes would then be sorted like this: >
+    z1.txt
+    z2.txt
+    z3.txt
+    z10.txt
+    z11.txt
+    z20.txt
+    z100.txt
+    z110.txt
+<
+------------------------------------------------------------------------------
+                                                                *NERDTreeUseTCD*
+Values: 0 or 1.
+Default: 0.
+
+By default, NERDTree will use the `:cd` command to change the current working
+directory. If this setting is turned on, and the `:tcd` command is available, it
+will be used instead.
+
+------------------------------------------------------------------------------
+                                                             *NERDTreeChDirMode*
+Values: 0, 1, 2, or 3.
+Default: 0.
+
+Use this setting to tell the script when (if at all) to change the current
+working directory (CWD) for vim.
+
+If it is set to 0 then the CWD is never changed by the NERDTree.
+
+If set to 1 then the CWD is changed when the NERDTree is first loaded to the
+directory it is initialized in. For example, if you start the NERDTree with >
+    :NERDTree /home/marty/foobar
+<
+then the CWD will be changed to /home/marty/foobar and will not be changed
+again unless you init another NERDTree with a similar command.
+
+If the setting is set to 2 then it behaves the same as if set to 1 except that
+the CWD is changed whenever the tree root is changed. For example, if the CWD
+is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new
+root then the CWD will become /home/marty/foobar/baz.
+
+If the set to 3, then it behaves the same as if set to 2, and the CWD is
+changed whenever changing tabs to whatever the tree root is on that tab.
+
+------------------------------------------------------------------------------
+                                                   *NERDTreeHighlightCursorline*
+Values: 0 or 1.
+Default: 1.
+
+If set to 1, the current cursor line in the NERDTree buffer will be
+highlighted. This is done using the `'cursorline'` Vim option.
+
+------------------------------------------------------------------------------
+                                                           *NERDTreeHijackNetrw*
+Values: 0 or 1.
+Default: 1.
+
+If set to 1, doing a >
+    :edit <some directory>
+<
+will open up a window level NERDTree instead of a netrw in the target window.
+
+Window level trees behaves slightly different from a regular trees in the
+following respects:
+    1. 'o' will open the selected file in the same window as the tree,
+       replacing it.
+    2. you can have one tree per window - instead of per tab.
+
+------------------------------------------------------------------------------
+                                                                *NERDTreeIgnore*
+Values: a list of regular expressions.
+Default: ['\~$'].
+
+This setting is used to specify which files the NERDTree should ignore.  It
+must be a list of regular expressions. When the NERDTree is rendered, any
+files/directories that match any of the regex's in NERDTreeIgnore won't be
+displayed.
+
+For example if you put the following line in your vimrc: >
+    let NERDTreeIgnore=['\.vim$', '\~$']
+<
+then all files ending in .vim or ~ will be ignored.
+
+There are 3 magic flags that can be appended to the end of each regular
+expression to specify that the regex should match only filenames, only lowest
+level directories, or a full path. These flags are "[[dir]]", "[[file]]", and
+"[[path]]". Example: >
+    let NERDTreeIgnore=['\.d$[[dir]]', '\.o$[[file]]', 'tmp/cache$[[path]]']
+<
+This will cause all directories ending in ".d" to be ignored, all files ending
+in ".o" to be ignored, and the "cache" subdirectory of any "tmp" directory to
+be ignored. All other "cache" directories will be displayed.
+
+When using the "[[path]]" tag on Windows, make sure you use escaped
+backslashes for the separators in the regex, eg. 'Temp\\cache$[[path]]'
+
+Note: to tell the NERDTree not to ignore any files you must use the following
+line: >
+    let NERDTreeIgnore=[]
+<
+The file filters can be turned on and off dynamically with the |NERDTree-f|
+mapping.
+
+------------------------------------------------------------------------------
+                                                     *NERDTreeRespectWildIgnore*
+Values: 0 or 1.
+Default: 0.
+
+If set to 1, the `'wildignore'` setting is respected.
+
+------------------------------------------------------------------------------
+                                                         *NERDTreeBookmarksFile*
+Values: a path
+Default: $HOME/.NERDTreeBookmarks
+
+This is where bookmarks are saved. See |NERDTreeBookmarkCommands|.
+
+------------------------------------------------------------------------------
+                                                         *NERDTreeBookmarksSort*
+Values: 0, 1, or 2
+Default: 1
+
+This setting controls the method by which the list of user bookmarks is
+sorted. When sorted, bookmarks will render in alphabetical order by name.
+
+If set to 0, the bookmarks list is not sorted.
+If set to 1, the bookmarks list is sorted in a case-insensitive manner.
+If set to 2, the bookmarks list is sorted in a case-sensitive manner.
+
+------------------------------------------------------------------------------
+                                                         *NERDTreeMarkBookmarks*
+Values: 0 or 1
+Default: 1
+
+If set to 1, Bookmarks will be specially marked whenever the NERDTree is
+rendered. Users of the |NERDTreeMinimalUI| setting may prefer to disable
+this setting for even less visual clutter.
+
+------------------------------------------------------------------------------
+                                                             *NERDTreeMouseMode*
+Values: 1, 2 or 3.
+Default: 1.
+
+If set to 1 then a double click on a node is required to open it.
+If set to 2 then a single click will open directory nodes, while a double
+click will still be required for file nodes.
+If set to 3 then a single click will open any node.
+
+Note: a double click anywhere on a line that a tree node is on will
+activate it, but all single-click activations must be done on name of the node
+itself. For example, if you have the following node: >
+    | | |-application.rb
+<
+then (to single click activate it) you must click somewhere in
+'application.rb'.
+
+------------------------------------------------------------------------------
+                                                            *NERDTreeQuitOnOpen*
+Values: 0,1,2 or 3.
+Default: 0
+
+This setting governs whether the NERDTree window or the bookmarks table closes
+after opening a file with the |NERDTree-o|, |NERDTree-i|, |NERDTree-t| and
+|NERDTree-T| mappings.
+
+ Value  | NERDTree Window Behavior
+ -------+-------------------------------------------------------
+ 0      | No change
+ 1      | Closes after opening a file
+ 2      | Closes the bookmark table after opening a bookmark
+ 3(1+2) | Same as both 1 and 2
+
+------------------------------------------------------------------------------
+                                                         *NERDTreeShowBookmarks*
+Values: 0 or 1.
+Default: 0.
+
+If this setting is set to 1 then the bookmarks table will be displayed.
+
+This setting can be toggled dynamically, per tree, with the |NERDTree-B|
+mapping.
+
+------------------------------------------------------------------------------
+                                                             *NERDTreeShowFiles*
+Values: 0 or 1.
+Default: 1.
+
+If this setting is set to 1 then files are displayed in the NERDTree. If it
+is set to 0 then only directories are displayed.
+
+This setting can be toggled dynamically, per tree, with the |NERDTree-F|
+mapping and is useful for drastically shrinking the tree when you are
+navigating to a different part of the tree.
+
+------------------------------------------------------------------------------
+                                                            *NERDTreeShowHidden*
+Values: 0 or 1.
+Default: 0.
+
+This setting tells vim whether to display hidden files by default. This
+setting can be dynamically toggled, per tree, with the |NERDTree-I| mapping.
+Use one of the follow lines for this setting: >
+    let NERDTreeShowHidden=0
+    let NERDTreeShowHidden=1
+<
+------------------------------------------------------------------------------
+                                                       *NERDTreeShowLineNumbers*
+Values: 0 or 1.
+Default: 0.
+
+This setting tells vim whether to display line numbers for the NERDTree
+window.  Use one of the follow lines for this setting: >
+    let NERDTreeShowLineNumbers=0
+    let NERDTreeShowLineNumbers=1
+<
+------------------------------------------------------------------------------
+                                                             *NERDTreeSortOrder*
+Values: a list of regular expressions.
+Default: ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
+
+This setting is a list of regular expressions which are used to group or sort
+the nodes under their parent.
+
+For example, if the setting is: >
+    ['\.vim$', '\.c$', '\.h$', '*', 'foobar']
+<
+then all .vim files will be grouped at the top, followed by all .c files then
+all .h files. All files containing the string 'foobar' will be placed at the
+end.  The star is a special flag: it tells the script that every node that
+doesn't match any of the other regexps should be placed here.
+
+If no star is present in NERDTreeSortOrder, then one is automatically
+appended to the end of the list.
+
+The regex '\/$' should be used to match directory nodes.
+
+Files can also be sorted by 1) the modification timestamp, 2) the size, or 3)
+the extension. Directories are always sorted by name. To accomplish this, the
+following special flags are used:
+  [[timestamp]]   [[-timestamp]]   [[size]]   [[-size]]   [[extension]]
+The hyphen specifies a descending sort; extensions are sorted in ascending
+order only. If placed at the beginning of the list, files are sorted according
+to these flags first, and then grouped by the remaining items in the list. If
+the flags are in any other position of the list, this special sorting is done
+secondarily. See examples 4, 5, and 6 below.
+
+After this sorting is done, the files in each group are sorted alphabetically.
+
+Examples: >
+    (1) ['*', '\/$']
+    (2) []
+    (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$',  '\.bak$', '\~$']
+    (4) ['[[-size]]']
+    (5) ['\/$', '*', '[[timestamp]]']
+    (6) ['foo','\/$','[[extension]]']
+<
+1. Directories will appear last, everything else will appear above.
+2. Everything will simply appear in alphabetical order.
+3. Directories will appear first, then ruby and php. Swap files, bak files
+   and vim backup files will appear last with everything else preceding them.
+4. Everything is sorted by size, largest to smallest, with directories
+   considered to have size 0 bytes.
+5. Directories will appear first alphabetically, followed by files, sorted by
+   timestamp, oldest first.
+6. Files and directories matching 'foo' first, followed by other directories,
+   then all other files. Each section of files is sorted by file extension.
+
+------------------------------------------------------------------------------
+                                                            *NERDTreeStatusline*
+Values: Any valid `'statusline'` setting.
+Default: %{exists('b:NERDTree')?b:NERDTree.root.path.str():''}
+
+Defines the value for the `'statusline'` setting in NERDTree windows.
+
+Note: The setting is actually applied using |:let-&|, not |:set|, so
+escaping spaces is not necessary.
+
+Setting this to -1 will deactivate it so that your global `'statusline'`
+setting is used.
+
+------------------------------------------------------------------------------
+                                                                *NERDTreeWinPos*
+Values: "left" or "right"
+Default: "left".
+
+This setting is used to determine where NERDTree window is placed on the
+screen.
+
+This setting makes it possible to use two different explorer plugins
+simultaneously. For example, you could have the taglist plugin on the left of
+the window and the NERDTree on the right.
+
+------------------------------------------------------------------------------
+                                                               *NERDTreeWinSize*
+Values: a positive integer.
+Default: 31.
+
+This setting is used to change the size of the NERDTree when it is loaded.
+
+------------------------------------------------------------------------------
+                                                             *NERDTreeMinimalUI*
+Values: 0 or 1
+Default: 0
+
+This setting disables the 'Bookmarks' label 'Press ? for help' text. Use one
+of the following lines for this setting: >
+    let NERDTreeMinimalUI=0
+    let NERDTreeMinimalUI=1
+<
+------------------------------------------------------------------------------
+                                                           *NERDTreeMinimalMenu*
+Values: 0 or 1
+Default: 0
+
+This setting makes NERDTree use a smaller, more compact menu for adding,
+copying, deleting nodes. This menu fits on a single line so Vim doesn't need to
+scroll down to present it. This setting is recommended for users already
+familiar with the menu items. It will look similar to this:
+
+  Menu: [ (a)dd ,m,d,r,o,q,c,l] (Use j/k/enter or shortcut):
+
+An action can be selected with its shortcut key or with the NERDTreeMenuUp and
+NERDTreeMenuDown keys, then pressing enter.
+
+Use one of the following lines for this setting: >
+    let NERDTreeMinimalMenu=0
+    let NERDTreeMinimalMenu=1
+<
+------------------------------------------------------------------------------
+                                                 *NERDTreeCascadeSingleChildDir*
+Values: 0 or 1
+Default: 1.
+
+When displaying directory nodes, this setting tells NERDTree to collapse
+directories that have only one child. Use one of the following lines for this
+setting: >
+    let NERDTreeCascadeSingleChildDir=0
+    let NERDTreeCascadeSingleChildDir=1
+<
+------------------------------------------------------------------------------
+                                             *NERDTreeCascadeOpenSingleChildDir*
+Values: 0 or 1
+Default: 1.
+
+When opening directory nodes, this setting tells NERDTree to recursively open
+directories that have only one child which is also a directory. NERDTree will
+stop when it finds a directory that contains anything but another single
+directory. This setting also causes the |NERDTree-x| mapping to close
+directories in the same manner. This setting may be useful for Java projects.
+Use one of the following lines for this setting: >
+    let NERDTreeCascadeOpenSingleChildDir=0
+    let NERDTreeCascadeOpenSingleChildDir=1
+<
+------------------------------------------------------------------------------
+                                                      *NERDTreeAutoDeleteBuffer*
+Values: 0 or 1
+Default: 0.
+
+When using a context menu to delete or rename a file you may also want to
+delete the buffer which is no more valid. If the setting is not set you will
+see a confirmation if you really want to delete an old buffer. If you always
+press 'y' then it's worth it to set this setting to 1. Use one of the
+following lines for this setting: >
+    let NERDTreeAutoDeleteBuffer=0
+    let NERDTreeAutoDeleteBuffer=1
+<
+------------------------------------------------------------------------------
+                                                          *NERDTreeCreatePrefix*
+Values: Any valid command prefix.
+Default: "silent".
+
+Internally, NERDTree uses the |:edit| command to create a buffer in which to
+display its tree view. You can augment this behavior by specifying a prefix
+string such as "keepalt" or similar. For example, to have NERDTree create its
+tree window using `silent keepalt keepjumps edit`: >
+    let NERDTreeCreatePrefix='silent keepalt keepjumps'
+<
+------------------------------------------------------------------------------
+                        *NERDTreeDirArrowCollapsible* *NERDTreeDirArrowExpandable*
+Values: Any single character.
+Defaults:   Windows: ~ and +    Others: ▾ and ▸
+
+These characters indicate whether a directory is collapsible or expandable.
+Example: >
+    let NERDTreeDirArrowExpandable=">"
+    let NERDTreeDirArrowCollapsible="v"
+<
+They can be set to "\u00a0" to replace the arrows with a non-breaking space.
+If you do this you may need to change the node delimiter. See
+|NERDTreeNodeDelimiter|. You cannot use the same character for both the arrows
+and the delimiter.
+
+Alternatively, they can be set to '' (an empty string). This removes the
+arrows and the single space that follows them, shifting the entire tree two
+character positions to the left.
+
+------------------------------------------------------------------------------
+                                                         *NERDTreeNodeDelimiter*
+Values: Any single character.
+Default: varies (see below)
+
+This character is used to separate the file or directory name from the rest of
+the characters in the line of text. It allows filenames to contain special
+characters that are otherwise used in the NERDTree, such as square brackets,
+braces, trailing asterisk, and leading space. For more details, see the
+responsible pull request: https://github.com/preservim/nerdtree/pull/868.
+
+The default value of this variable depends on the features compiled into your
+vim and the values of |NERDTreeDirArrowCollapsible| and
+|NERDTreeDirArrowExpandable|.
+  * If your vim is compiled with the +conceal feature, it is the "\x07"
+    (BEL) character, and it is hidden by setting 'conceallevel' to 2. If you
+    use autocommands, make sure none of them change that setting in the
+    NERD_Tree_* buffers.
+  * If your vim does NOT have the +conceal feature and you're using "\u00a0"
+    (non-breaking space) to hide the directory arrows, "\u00b7" (middle dot)
+    is used as the default delimiter.
+  * If neither condition above applies, NERDTree uses "\u00a0" (non-breaking
+    space) as the default delimiter.
+
+In the 2nd and 3rd cases, NERDTree will use the Ignore highlight group to
+"hide" the delimiter. It should appear as an empty space.
+
+Other plugins can interfere with these defaults, so if you need to change the
+delimiter, be sure to choose a character that won't appear in your filenames
+or any of the flags set by your installed NERDTree plugins. The suggestions
+below are but a few of the many possibilities. Remember to use double quotes
+when specifying by hex or Unicode. >
+    let NERDTreeNodeDelimiter="\x07"     "bell
+    let NERDTreeNodeDelimiter="\u00b7"   "middle dot
+    let NERDTreeNodeDelimiter="\u00a0"   "non-breaking space
+    let NERDTreeNodeDelimiter="😀"       "smiley face
+<
+------------------------------------------------------------------------------
+                                                        *NERDTreeCustomOpenArgs*
+Values: A nested dictionary, as described below
+Default: {'file': {'reuse': 'all', 'where': 'p'}, 'dir': {}}
+
+This dictionary contains two keys, 'file' and 'dir', whose values each are
+another dictionary. The inner dictionary is a set of parameters used by
+|NERDTree-<CR>| to open a file or directory. Setting these parameters allows you
+to customize the way the node is opened. The default value matches what
+|NERDTree-o| does. To change that behavior, use these keys and
+values in the inner dictionaries:
+
+'where':    specifies whether the node should be opened in a new split ("h" or
+            "v"), in a new tab ("t") or, in the last window ("p").
+'reuse':    if file is already shown in a window, jump there; takes values
+            "all", "currenttab", or empty
+'keepopen': boolean (0 or 1); if true, the tree window will not be closed
+'stay':     boolean (0 or 1); if true, remain in tree window after opening
+
+For example:
+To open files and directories (creating a new NERDTree) in a new tab, >
+    {'file':{'where': 't'}, 'dir':{'where':'t'}}
+<
+To open a file always in the current tab, and expand directories in place, >
+    {'file': {'reuse':'currenttab', 'where':'p', 'keepopen':1, 'stay':1}}
+<
+==============================================================================
+4. The NERDTree API                                                *NERDTreeAPI*
+
+The NERDTree script allows you to add custom key mappings and menu items via
+a set of API calls. Any scripts that use this API should be placed in
+~/.vim/nerdtree_plugin/ (*nix) or ~/vimfiles/nerdtree_plugin (windows).
+
+The script exposes some prototype objects that can be used to manipulate the
+tree and/or get information from it: >
+    g:NERDTreePath
+    g:NERDTreeDirNode
+    g:NERDTreeFileNode
+    g:NERDTreeBookmark
+<
+See the code/comments in NERD_tree.vim to find how to use these objects. The
+following code conventions are used:
+    * class members start with a capital letter
+    * instance members start with a lower case letter
+    * private members start with an underscore
+
+See this blog post for more details:
+ http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html
+
+A number of API functions take a callback argument to call. The callback can
+be either a string with the name of a function to call, or a |Funcref| object
+which will be called directly.
+
+------------------------------------------------------------------------------
+4.1. Key map API                                             *NERDTreeKeymapAPI*
+
+NERDTreeAddKeyMap({options})                               *NERDTreeAddKeyMap()*
+    Adds a new keymapping for all NERDTree buffers.
+    {options} must be a dictionary, and must contain the following keys:
+    "key" - the trigger key for the new mapping
+    "callback" - the function the new mapping will be bound to
+    "quickhelpText" - the text that will appear in the quickhelp (see
+    |NERDTree-?|)
+    "override" - if 1 then this new mapping will override whatever previous
+    mapping was defined for the key/scope combo. Useful for overriding the
+    default mappings.
+
+    Additionally, a "scope" argument may be supplied. This constrains the
+    mapping so that it is only activated if the cursor is on a certain object.
+    That object is then passed into the handling method. Possible values are:
+
+      "FileNode" .... a file node
+      "DirNode" ..... a directory node
+      "Node" ........ a file node OR a directory node
+      "Bookmark" .... a bookmark
+      "all" ......... global scope; handler receives no arguments (default)
+
+    Example: >
+        call NERDTreeAddKeyMap({
+               \ 'key': 'foo',
+               \ 'callback': 'NERDTreeEchoPathHandler',
+               \ 'quickhelpText': 'echo full path of current node',
+               \ 'scope': 'DirNode' })
+
+        function! NERDTreeEchoPathHandler(dirnode)
+            echo a:dirnode.path.str()
+        endfunction
+<
+    This code should sit in a file like ~/.vim/nerdtree_plugin/mymapping.vim.
+    It adds a (redundant) mapping on 'foo' which changes vim's CWD to that of
+    the current directory node. Note this mapping will only fire when the
+    cursor is on a directory node.
+
+------------------------------------------------------------------------------
+4.2. Menu API                                                  *NERDTreeMenuAPI*
+
+NERDTreeAddSubmenu({options})                             *NERDTreeAddSubmenu()*
+    Creates and returns a new submenu.
+
+    {options} must be a dictionary and must contain the following keys:
+    "text" - the text of the submenu that the user will see
+    "shortcut" - a shortcut key for the submenu (need not be unique)
+
+    The following keys are optional:
+    "isActiveCallback" - a function that will be called to determine whether
+    this submenu item will be displayed or not. The callback function must
+    return 0 or 1.
+    "parent" - the parent submenu of the new submenu (returned from a previous
+    invocation of NERDTreeAddSubmenu()). If this key is left out then the new
+    submenu will sit under the top level menu.
+
+    See below for an example.
+
+NERDTreeAddMenuItem({options})                           *NERDTreeAddMenuItem()*
+    Adds a new menu item to the NERDTree menu (see |NERDTreeMenu|).
+
+    {options} must be a dictionary and must contain the
+    following keys:
+    "text" - the text of the menu item which the user will see
+    "shortcut" - a shortcut key for the menu item (need not be unique)
+    "callback" - the function that will be called when the user activates the
+    menu item.
+
+    The following keys are optional:
+    "isActiveCallback" - a function that will be called to determine whether
+    this menu item will be displayed or not. The callback function must return
+    0 or 1.
+    "parent" - if the menu item belongs under a submenu then this key must be
+    specified. This value for this key will be the object that
+    was returned when the submenu was created with |NERDTreeAddSubmenu()|.
+
+    See below for an example.
+
+NERDTreeAddMenuSeparator([{options}])               *NERDTreeAddMenuSeparator()*
+    Adds a menu separator (a row of dashes).
+
+    {options} is an optional dictionary that may contain the following keys:
+    "isActiveCallback" - see description in |NERDTreeAddMenuItem()|.
+
+Below is an example of the menu API in action. >
+    call NERDTreeAddMenuSeparator()
+
+    call NERDTreeAddMenuItem({
+                \ 'text': 'a (t)op level menu item',
+                \ 'shortcut': 't',
+                \ 'callback': 'SomeFunction' })
+
+    let submenu = NERDTreeAddSubmenu({
+                \ 'text': 'a (s)ub menu',
+                \ 'shortcut': 's' })
+
+    call NERDTreeAddMenuItem({
+                \ 'text': '(n)ested item 1',
+                \ 'shortcut': 'n',
+                \ 'callback': 'SomeFunction',
+                \ 'parent': submenu })
+
+    call NERDTreeAddMenuItem({
+                \ 'text': '(n)ested item 2',
+                \ 'shortcut': 'n',
+                \ 'callback': 'SomeFunction',
+                \ 'parent': submenu })
+<
+This will create the following menu: >
+  --------------------
+  a (t)op level menu item
+  a (s)ub menu
+<
+Where selecting "a (s)ub menu" will lead to a second menu: >
+  (n)ested item 1
+  (n)ested item 2
+<
+When any of the 3 concrete menu items are selected the function "SomeFunction"
+will be called.
+
+------------------------------------------------------------------------------
+4.3 NERDTreeAddPathFilter(callback)                    *NERDTreeAddPathFilter()*
+
+Path filters are essentially a more powerful version of  |NERDTreeIgnore|.
+If the simple regex matching in |NERDTreeIgnore| is not enough then use
+|NERDTreeAddPathFilter()| to add a callback function that paths will be
+checked against when the decision to ignore them is made. Example >
+
+    call NERDTreeAddPathFilter('MyFilter')
+
+    function! MyFilter(params)
+        "params is a dict containing keys: 'nerdtree' and 'path' which are
+        "g:NERDTree and g:NERDTreePath objects
+
+        "return 1 to ignore params['path'] or 0 otherwise
+    endfunction
+<
+------------------------------------------------------------------------------
+4.4 Path Listener API                                  *NERDTreePathListenerAPI*
+
+Use this API if you want to run a callback for events on Path objects. E.G >
+
+    call g:NERDTreePathNotifier.AddListener("init", "MyListener")
+
+    "....
+
+    function! MyListener(event)
+        "This function will be called whenever a Path object is created.
+
+        "a:event is an object that contains a bunch of relevant info -
+        "including the affected path. See lib/nerdtree/event.vim for details.
+    endfunction
+<
+Current events supported:
+  init ~
+  refresh ~
+  refreshFlags ~
+
+------------------------------------------------------------------------------
+NERDTreeRender()                                              *NERDTreeRender()*
+    Re-renders the NERDTree buffer. Useful if you change the state of the
+    tree and you want to it to be reflected in the UI.
+
+==============================================================================
+5. About                                                         *NERDTreeAbout*
+
+The author of the NERDTree is a terrible terrible monster called Martyzilla
+who gobbles up small children with milk and sugar for breakfast.
+
+He can be reached at martin.grenfell at gmail dot com. He would love to hear
+from you, so feel free to send him suggestions and/or comments about this
+plugin.  Don't be shy --- the worst he can do is slaughter you and stuff you
+in the fridge for later ;)
+
+Martyzilla recruited two other unwitting accomplices to become his minions in
+his quest to conquer the Vim plugin world. While he may still love to receive
+your emails, the best way to send suggestions, bug reports, and questions is
+to submit an issue at http://github.com/preservim/nerdtree/issues.
+
+The latest stable and development versions are on Github.
+    Stable: http://github.com/preservim/nerdtree (master branch)
+    Development: http://github.com/preservim/nerdtree/branches
+
+Title Credit:
+  * http://ascii.co.uk/art/tree
+
+  * Patrick Gillespie's Text ASCII Art Generator
+    http://patorjk.com/software/taag
+    http://patorjk.com/software/taag/#p=display&f=Rozzo&t=the%20NERD%20Tree
+
+==============================================================================
+6. License                                                     *NERDTreeLicense*
+
+The NERDTree is released under the wtfpl.
+See http://sam.zoy.org/wtfpl/COPYING.
+
+------------------------------------------------------------------------------
+ vim:tw=78:ts=8:ft=help:noet:nospell
diff --git a/.vim/bundle/vim-nerdtree/doc/tags b/.vim/bundle/vim-nerdtree/doc/tags
new file mode 100644
index 0000000..c1135b2
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/doc/tags
@@ -0,0 +1,143 @@
+:NERDTree	NERDTree.txt	/*:NERDTree*
+:NERDTreeCWD	NERDTree.txt	/*:NERDTreeCWD*
+:NERDTreeClose	NERDTree.txt	/*:NERDTreeClose*
+:NERDTreeFind	NERDTree.txt	/*:NERDTreeFind*
+:NERDTreeFocus	NERDTree.txt	/*:NERDTreeFocus*
+:NERDTreeFromBookmark	NERDTree.txt	/*:NERDTreeFromBookmark*
+:NERDTreeMirror	NERDTree.txt	/*:NERDTreeMirror*
+:NERDTreeRefreshRoot	NERDTree.txt	/*:NERDTreeRefreshRoot*
+:NERDTreeToggle	NERDTree.txt	/*:NERDTreeToggle*
+:NERDTreeToggleVCS	NERDTree.txt	/*:NERDTreeToggleVCS*
+:NERDTreeVCS	NERDTree.txt	/*:NERDTreeVCS*
+NERDTree	NERDTree.txt	/*NERDTree*
+NERDTree-<CR>	NERDTree.txt	/*NERDTree-<CR>*
+NERDTree-?	NERDTree.txt	/*NERDTree-?*
+NERDTree-A	NERDTree.txt	/*NERDTree-A*
+NERDTree-B	NERDTree.txt	/*NERDTree-B*
+NERDTree-C	NERDTree.txt	/*NERDTree-C*
+NERDTree-C-J	NERDTree.txt	/*NERDTree-C-J*
+NERDTree-C-K	NERDTree.txt	/*NERDTree-C-K*
+NERDTree-CD	NERDTree.txt	/*NERDTree-CD*
+NERDTree-D	NERDTree.txt	/*NERDTree-D*
+NERDTree-F	NERDTree.txt	/*NERDTree-F*
+NERDTree-I	NERDTree.txt	/*NERDTree-I*
+NERDTree-J	NERDTree.txt	/*NERDTree-J*
+NERDTree-K	NERDTree.txt	/*NERDTree-K*
+NERDTree-O	NERDTree.txt	/*NERDTree-O*
+NERDTree-P	NERDTree.txt	/*NERDTree-P*
+NERDTree-R	NERDTree.txt	/*NERDTree-R*
+NERDTree-T	NERDTree.txt	/*NERDTree-T*
+NERDTree-U	NERDTree.txt	/*NERDTree-U*
+NERDTree-X	NERDTree.txt	/*NERDTree-X*
+NERDTree-cd	NERDTree.txt	/*NERDTree-cd*
+NERDTree-contents	NERDTree.txt	/*NERDTree-contents*
+NERDTree-e	NERDTree.txt	/*NERDTree-e*
+NERDTree-f	NERDTree.txt	/*NERDTree-f*
+NERDTree-gi	NERDTree.txt	/*NERDTree-gi*
+NERDTree-go	NERDTree.txt	/*NERDTree-go*
+NERDTree-gs	NERDTree.txt	/*NERDTree-gs*
+NERDTree-i	NERDTree.txt	/*NERDTree-i*
+NERDTree-m	NERDTree.txt	/*NERDTree-m*
+NERDTree-o	NERDTree.txt	/*NERDTree-o*
+NERDTree-p	NERDTree.txt	/*NERDTree-p*
+NERDTree-q	NERDTree.txt	/*NERDTree-q*
+NERDTree-r	NERDTree.txt	/*NERDTree-r*
+NERDTree-s	NERDTree.txt	/*NERDTree-s*
+NERDTree-t	NERDTree.txt	/*NERDTree-t*
+NERDTree-u	NERDTree.txt	/*NERDTree-u*
+NERDTree-x	NERDTree.txt	/*NERDTree-x*
+NERDTree.txt	NERDTree.txt	/*NERDTree.txt*
+NERDTreeAPI	NERDTree.txt	/*NERDTreeAPI*
+NERDTreeAbout	NERDTree.txt	/*NERDTreeAbout*
+NERDTreeAddKeyMap()	NERDTree.txt	/*NERDTreeAddKeyMap()*
+NERDTreeAddMenuItem()	NERDTree.txt	/*NERDTreeAddMenuItem()*
+NERDTreeAddMenuSeparator()	NERDTree.txt	/*NERDTreeAddMenuSeparator()*
+NERDTreeAddPathFilter()	NERDTree.txt	/*NERDTreeAddPathFilter()*
+NERDTreeAddSubmenu()	NERDTree.txt	/*NERDTreeAddSubmenu()*
+NERDTreeAutoCenter	NERDTree.txt	/*NERDTreeAutoCenter*
+NERDTreeAutoCenterThreshold	NERDTree.txt	/*NERDTreeAutoCenterThreshold*
+NERDTreeAutoDeleteBuffer	NERDTree.txt	/*NERDTreeAutoDeleteBuffer*
+NERDTreeBookmarkCommands	NERDTree.txt	/*NERDTreeBookmarkCommands*
+NERDTreeBookmarkTable	NERDTree.txt	/*NERDTreeBookmarkTable*
+NERDTreeBookmarks	NERDTree.txt	/*NERDTreeBookmarks*
+NERDTreeBookmarksFile	NERDTree.txt	/*NERDTreeBookmarksFile*
+NERDTreeBookmarksSort	NERDTree.txt	/*NERDTreeBookmarksSort*
+NERDTreeCascadeOpenSingleChildDir	NERDTree.txt	/*NERDTreeCascadeOpenSingleChildDir*
+NERDTreeCascadeSingleChildDir	NERDTree.txt	/*NERDTreeCascadeSingleChildDir*
+NERDTreeCaseSensitiveSort	NERDTree.txt	/*NERDTreeCaseSensitiveSort*
+NERDTreeChDirMode	NERDTree.txt	/*NERDTreeChDirMode*
+NERDTreeCreatePrefix	NERDTree.txt	/*NERDTreeCreatePrefix*
+NERDTreeCustomOpenArgs	NERDTree.txt	/*NERDTreeCustomOpenArgs*
+NERDTreeDirArrowCollapsible	NERDTree.txt	/*NERDTreeDirArrowCollapsible*
+NERDTreeDirArrowExpandable	NERDTree.txt	/*NERDTreeDirArrowExpandable*
+NERDTreeFunctionality	NERDTree.txt	/*NERDTreeFunctionality*
+NERDTreeGlobalCommands	NERDTree.txt	/*NERDTreeGlobalCommands*
+NERDTreeHighlightCursorline	NERDTree.txt	/*NERDTreeHighlightCursorline*
+NERDTreeHijackNetrw	NERDTree.txt	/*NERDTreeHijackNetrw*
+NERDTreeIgnore	NERDTree.txt	/*NERDTreeIgnore*
+NERDTreeInvalidBookmarks	NERDTree.txt	/*NERDTreeInvalidBookmarks*
+NERDTreeKeymapAPI	NERDTree.txt	/*NERDTreeKeymapAPI*
+NERDTreeLicense	NERDTree.txt	/*NERDTreeLicense*
+NERDTreeMapCWD	NERDTree.txt	/*NERDTreeMapCWD*
+NERDTreeMapChangeRoot	NERDTree.txt	/*NERDTreeMapChangeRoot*
+NERDTreeMapChdir	NERDTree.txt	/*NERDTreeMapChdir*
+NERDTreeMapCloseChildren	NERDTree.txt	/*NERDTreeMapCloseChildren*
+NERDTreeMapCloseDir	NERDTree.txt	/*NERDTreeMapCloseDir*
+NERDTreeMapCustomOpen	NERDTree.txt	/*NERDTreeMapCustomOpen*
+NERDTreeMapDeleteBookmark	NERDTree.txt	/*NERDTreeMapDeleteBookmark*
+NERDTreeMapHelp	NERDTree.txt	/*NERDTreeMapHelp*
+NERDTreeMapJumpFirstChild	NERDTree.txt	/*NERDTreeMapJumpFirstChild*
+NERDTreeMapJumpLastChild	NERDTree.txt	/*NERDTreeMapJumpLastChild*
+NERDTreeMapJumpNextSibling	NERDTree.txt	/*NERDTreeMapJumpNextSibling*
+NERDTreeMapJumpParent	NERDTree.txt	/*NERDTreeMapJumpParent*
+NERDTreeMapJumpPrevSibling	NERDTree.txt	/*NERDTreeMapJumpPrevSibling*
+NERDTreeMapJumpRoot	NERDTree.txt	/*NERDTreeMapJumpRoot*
+NERDTreeMapMenu	NERDTree.txt	/*NERDTreeMapMenu*
+NERDTreeMapOpenExpl	NERDTree.txt	/*NERDTreeMapOpenExpl*
+NERDTreeMapOpenInTab	NERDTree.txt	/*NERDTreeMapOpenInTab*
+NERDTreeMapOpenInTabSilent	NERDTree.txt	/*NERDTreeMapOpenInTabSilent*
+NERDTreeMapOpenRecursively	NERDTree.txt	/*NERDTreeMapOpenRecursively*
+NERDTreeMapOpenSplit	NERDTree.txt	/*NERDTreeMapOpenSplit*
+NERDTreeMapOpenVSplit	NERDTree.txt	/*NERDTreeMapOpenVSplit*
+NERDTreeMapPreviewSplit	NERDTree.txt	/*NERDTreeMapPreviewSplit*
+NERDTreeMapPreviewVSplit	NERDTree.txt	/*NERDTreeMapPreviewVSplit*
+NERDTreeMapQuit	NERDTree.txt	/*NERDTreeMapQuit*
+NERDTreeMapRefresh	NERDTree.txt	/*NERDTreeMapRefresh*
+NERDTreeMapRefreshRoot	NERDTree.txt	/*NERDTreeMapRefreshRoot*
+NERDTreeMapToggleBookmarks	NERDTree.txt	/*NERDTreeMapToggleBookmarks*
+NERDTreeMapToggleFiles	NERDTree.txt	/*NERDTreeMapToggleFiles*
+NERDTreeMapToggleFilters	NERDTree.txt	/*NERDTreeMapToggleFilters*
+NERDTreeMapToggleHidden	NERDTree.txt	/*NERDTreeMapToggleHidden*
+NERDTreeMapToggleZoom	NERDTree.txt	/*NERDTreeMapToggleZoom*
+NERDTreeMapUpdir	NERDTree.txt	/*NERDTreeMapUpdir*
+NERDTreeMapUpdirKeepOpen	NERDTree.txt	/*NERDTreeMapUpdirKeepOpen*
+NERDTreeMappings	NERDTree.txt	/*NERDTreeMappings*
+NERDTreeMarkBookmarks	NERDTree.txt	/*NERDTreeMarkBookmarks*
+NERDTreeMenu	NERDTree.txt	/*NERDTreeMenu*
+NERDTreeMenu-j	NERDTree.txt	/*NERDTreeMenu-j*
+NERDTreeMenu-k	NERDTree.txt	/*NERDTreeMenu-k*
+NERDTreeMenuAPI	NERDTree.txt	/*NERDTreeMenuAPI*
+NERDTreeMenuDown	NERDTree.txt	/*NERDTreeMenuDown*
+NERDTreeMenuUp	NERDTree.txt	/*NERDTreeMenuUp*
+NERDTreeMinimalMenu	NERDTree.txt	/*NERDTreeMinimalMenu*
+NERDTreeMinimalUI	NERDTree.txt	/*NERDTreeMinimalUI*
+NERDTreeMouseMode	NERDTree.txt	/*NERDTreeMouseMode*
+NERDTreeNaturalSort	NERDTree.txt	/*NERDTreeNaturalSort*
+NERDTreeNodeDelimiter	NERDTree.txt	/*NERDTreeNodeDelimiter*
+NERDTreePathListenerAPI	NERDTree.txt	/*NERDTreePathListenerAPI*
+NERDTreeQuitOnOpen	NERDTree.txt	/*NERDTreeQuitOnOpen*
+NERDTreeRender()	NERDTree.txt	/*NERDTreeRender()*
+NERDTreeRespectWildIgnore	NERDTree.txt	/*NERDTreeRespectWildIgnore*
+NERDTreeSettings	NERDTree.txt	/*NERDTreeSettings*
+NERDTreeSettingsDetails	NERDTree.txt	/*NERDTreeSettingsDetails*
+NERDTreeSettingsSummary	NERDTree.txt	/*NERDTreeSettingsSummary*
+NERDTreeShowBookmarks	NERDTree.txt	/*NERDTreeShowBookmarks*
+NERDTreeShowFiles	NERDTree.txt	/*NERDTreeShowFiles*
+NERDTreeShowHidden	NERDTree.txt	/*NERDTreeShowHidden*
+NERDTreeShowLineNumbers	NERDTree.txt	/*NERDTreeShowLineNumbers*
+NERDTreeSortOrder	NERDTree.txt	/*NERDTreeSortOrder*
+NERDTreeStatusline	NERDTree.txt	/*NERDTreeStatusline*
+NERDTreeUseTCD	NERDTree.txt	/*NERDTreeUseTCD*
+NERDTreeWinPos	NERDTree.txt	/*NERDTreeWinPos*
+NERDTreeWinSize	NERDTree.txt	/*NERDTreeWinSize*
+loaded_nerd_tree	NERDTree.txt	/*loaded_nerd_tree*
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/bookmark.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/bookmark.vim
new file mode 100644
index 0000000..37be451
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/bookmark.vim
@@ -0,0 +1,365 @@
+" ============================================================================
+" CLASS: Bookmark
+"
+" The Bookmark class serves two purposes:
+"   (1) It is the top-level prototype for new, concrete Bookmark objects.
+"   (2) It provides an interface for client code to query and manipulate the
+"       global list of Bookmark objects within the current Vim session.
+" ============================================================================
+
+
+let s:Bookmark = {}
+let g:NERDTreeBookmark = s:Bookmark
+
+" FUNCTION: Bookmark.activate(nerdtree) {{{1
+function! s:Bookmark.activate(nerdtree, ...)
+    call self.open(a:nerdtree, a:0 ? a:1 : {})
+endfunction
+
+" FUNCTION: Bookmark.AddBookmark(name, path) {{{1
+" Class method to add a new bookmark to the list, if a previous bookmark exists
+" with the same name, just update the path for that bookmark
+function! s:Bookmark.AddBookmark(name, path)
+    for i in s:Bookmark.Bookmarks()
+        if i.name ==# a:name
+            let i.path = a:path
+            return
+        endif
+    endfor
+    call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path))
+endfunction
+
+" FUNCTION: Bookmark.Bookmarks() {{{1
+" Class method to get all bookmarks. Lazily initializes the bookmarks global
+" variable
+function! s:Bookmark.Bookmarks()
+    if !exists('g:NERDTreeBookmarks')
+        let g:NERDTreeBookmarks = []
+    endif
+    return g:NERDTreeBookmarks
+endfunction
+
+" FUNCTION: Bookmark.BookmarkExistsFor(name) {{{1
+" class method that returns 1 if a bookmark with the given name is found, 0
+" otherwise
+function! s:Bookmark.BookmarkExistsFor(name)
+    try
+        call s:Bookmark.BookmarkFor(a:name)
+        return 1
+    catch /^NERDTree.BookmarkNotFoundError/
+        return 0
+    endtry
+endfunction
+
+" FUNCTION: Bookmark.BookmarkFor(name) {{{1
+" Class method that returns the Bookmark object having the specified name.
+" Throws NERDTree.BookmarkNotFoundError if no Bookmark is found.
+function! s:Bookmark.BookmarkFor(name)
+    let l:result = {}
+    for l:bookmark in s:Bookmark.Bookmarks()
+        if l:bookmark.name ==# a:name
+            let l:result = l:bookmark
+            break
+        endif
+    endfor
+    if empty(l:result)
+        throw 'NERDTree.BookmarkNotFoundError: "' . a:name  . '" not found'
+    endif
+    return l:result
+endfunction
+
+" FUNCTION: Bookmark.BookmarkNames() {{{1
+" Class method to return an array of all bookmark names
+function! s:Bookmark.BookmarkNames()
+    let names = []
+    for i in s:Bookmark.Bookmarks()
+        call add(names, i.name)
+    endfor
+    return names
+endfunction
+
+" FUNCTION: Bookmark.CacheBookmarks(silent) {{{1
+" Class method to read all bookmarks from the bookmarks file initialize
+" bookmark objects for each one.
+"
+" Args:
+" silent - dont echo an error msg if invalid bookmarks are found
+function! s:Bookmark.CacheBookmarks(silent)
+    if filereadable(g:NERDTreeBookmarksFile)
+        let g:NERDTreeBookmarks = []
+        let g:NERDTreeInvalidBookmarks = []
+        let bookmarkStrings = readfile(g:NERDTreeBookmarksFile)
+        let invalidBookmarksFound = 0
+        for i in bookmarkStrings
+
+            "ignore blank lines
+            if i !=# ''
+
+                let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
+                let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
+                let path = fnamemodify(path, ':p')
+
+                try
+                    let bookmark = s:Bookmark.New(name, g:NERDTreePath.New(path))
+                    call add(g:NERDTreeBookmarks, bookmark)
+                catch /^NERDTree.InvalidArgumentsError/
+                    call add(g:NERDTreeInvalidBookmarks, i)
+                    let invalidBookmarksFound += 1
+                endtry
+            endif
+        endfor
+        if invalidBookmarksFound
+            call s:Bookmark.Write()
+            if !a:silent
+                call nerdtree#echo(invalidBookmarksFound . ' invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.')
+            endif
+        endif
+    endif
+endfunction
+
+" FUNCTION: Bookmark.CompareBookmarksByName(firstBookmark, secondBookmark) {{{1
+" Class method that indicates the relative position of two bookmarks when
+" placed in alphabetical order by name. Case-sensitivity is determined by an
+" option. Supports the s:Bookmark.SortBookmarksList() method.
+function! s:Bookmark.CompareBookmarksByName(firstBookmark, secondBookmark)
+    let l:result = 0
+    if g:NERDTreeBookmarksSort ==# 1
+        if a:firstBookmark.name <? a:secondBookmark.name
+            let l:result = -1
+        elseif a:firstBookmark.name >? a:secondBookmark.name
+            let l:result = 1
+        endif
+    elseif g:NERDTreeBookmarksSort ==# 2
+        if a:firstBookmark.name <# a:secondBookmark.name
+            let l:result = -1
+        elseif a:firstBookmark.name ># a:secondBookmark.name
+            let l:result = 1
+        endif
+    endif
+    return l:result
+endfunction
+
+" FUNCTION: Bookmark.ClearAll() {{{1
+" Class method to delete all bookmarks.
+function! s:Bookmark.ClearAll()
+    for i in s:Bookmark.Bookmarks()
+        call i.delete()
+    endfor
+    call s:Bookmark.Write()
+endfunction
+
+" FUNCTION: Bookmark.delete() {{{1
+" Delete this bookmark. If the node for this bookmark is under the current
+" root, then recache bookmarks for its Path object
+function! s:Bookmark.delete()
+    call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self))
+    call s:Bookmark.Write()
+endfunction
+
+" FUNCTION: s:Edit() {{{1
+" opens the NERDTreeBookmarks file for manual editing
+function! s:Bookmark.Edit()
+    call nerdtree#exec('wincmd w', 1)
+    call nerdtree#exec('edit '.g:NERDTreeBookmarksFile, 1)
+endfunction
+
+" FUNCTION: Bookmark.getNode(nerdtree, searchFromAbsoluteRoot) {{{1
+" Returns the tree node object associated with this Bookmark.
+" Throws NERDTree.BookmarkedNodeNotFoundError if the node is not found.
+"
+" Args:
+" searchFromAbsoluteRoot: boolean flag, search from the highest cached node
+"   if true and from the current tree root if false
+function! s:Bookmark.getNode(nerdtree, searchFromAbsoluteRoot)
+    if a:searchFromAbsoluteRoot
+        let l:searchRoot = a:nerdtree.root.AbsoluteTreeRoot()
+    else
+        let l:searchRoot = a:nerdtree.root
+    endif
+    let l:targetNode = l:searchRoot.findNode(self.path)
+    if empty(l:targetNode)
+        throw 'NERDTree.BookmarkedNodeNotFoundError: node for bookmark "' . self.name . '" not found'
+    endif
+    return l:targetNode
+endfunction
+
+" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot, nerdtree) {{{1
+" Class method that returns the tree node object for the Bookmark with the
+" given name. Throws NERDTree.BookmarkNotFoundError if a Bookmark with the
+" name does not exist. Throws NERDTree.BookmarkedNodeNotFoundError if a
+" tree node for the named Bookmark could not be found.
+function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot, nerdtree)
+    let l:bookmark = s:Bookmark.BookmarkFor(a:name)
+    return l:bookmark.getNode(a:nerdtree, a:searchFromAbsoluteRoot)
+endfunction
+
+" FUNCTION: Bookmark.GetSelected() {{{1
+" returns the Bookmark the cursor is over, or {}
+function! s:Bookmark.GetSelected()
+    let line = getline('.')
+    let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
+    if name !=# line
+        try
+            return s:Bookmark.BookmarkFor(name)
+        catch /^NERDTree.BookmarkNotFoundError/
+            return {}
+        endtry
+    endif
+    return {}
+endfunction
+
+" FUNCTION: Bookmark.InvalidBookmarks() {{{1
+" Class method to get all invalid bookmark strings read from the bookmarks
+" file
+function! s:Bookmark.InvalidBookmarks()
+    if !exists('g:NERDTreeInvalidBookmarks')
+        let g:NERDTreeInvalidBookmarks = []
+    endif
+    return g:NERDTreeInvalidBookmarks
+endfunction
+
+" FUNCTION: Bookmark.mustExist() {{{1
+function! s:Bookmark.mustExist()
+    if !self.path.exists()
+        call s:Bookmark.CacheBookmarks(1)
+        throw 'NERDTree.BookmarkPointsToInvalidLocationError: the bookmark "'.
+            \ self.name .'" points to a non existing location: "'. self.path.str()
+    endif
+endfunction
+
+" FUNCTION: Bookmark.New(name, path) {{{1
+" Create a new bookmark object with the given name and path object
+function! s:Bookmark.New(name, path)
+    if a:name =~# ' '
+        throw 'NERDTree.IllegalBookmarkNameError: illegal name:' . a:name
+    endif
+
+    let newBookmark = copy(self)
+    let newBookmark.name = a:name
+    let newBookmark.path = a:path
+    return newBookmark
+endfunction
+
+" FUNCTION: Bookmark.open(nerdtree, [options]) {{{1
+"Args:
+"
+"nerdtree: the tree to load open the bookmark in
+"
+"A dictionary containing the following keys (all optional):
+"  'where': Specifies whether the node should be opened in new split/tab or in
+"           the previous window. Can be either 'v' (vertical split), 'h'
+"           (horizontal split), 't' (new tab) or 'p' (previous window).
+"  'reuse': if a window is displaying the file then jump the cursor there
+"  'keepopen': dont close the tree window
+"  'stay': open the file, but keep the cursor in the tree win
+"
+function! s:Bookmark.open(nerdtree, ...)
+    let opts = a:0 ? a:1 : {}
+
+    if nerdtree#closeBookmarksOnOpen()
+        call a:nerdtree.ui.toggleShowBookmarks()
+    endif
+
+    if self.path.isDirectory && !has_key(opts, 'where')
+        call self.toRoot(a:nerdtree)
+    else
+        let opener = g:NERDTreeOpener.New(self.path, opts)
+        call opener.open(self)
+    endif
+endfunction
+
+" FUNCTION: Bookmark.openInNewTab(options) {{{1
+" Create a new bookmark object with the given name and path object
+function! s:Bookmark.openInNewTab(options)
+    call nerdtree#deprecated('Bookmark.openInNewTab', 'is deprecated, use open() instead')
+    call self.open(a:options)
+endfunction
+
+" FUNCTION: Bookmark.setPath(path) {{{1
+" makes this bookmark point to the given path
+function! s:Bookmark.setPath(path)
+    let self.path = a:path
+endfunction
+
+" FUNCTION: Bookmark.SortBookmarksList() {{{1
+" Class method that sorts the global list of bookmarks alphabetically by name.
+" Note that case-sensitivity is determined by a user option.
+function! s:Bookmark.SortBookmarksList()
+    call sort(s:Bookmark.Bookmarks(), s:Bookmark.CompareBookmarksByName, s:Bookmark)
+endfunction
+
+" FUNCTION: Bookmark.str() {{{1
+" Get the string that should be rendered in the view for this bookmark
+function! s:Bookmark.str()
+    let pathStrMaxLen = winwidth(g:NERDTree.GetWinNum()) - 4 - strdisplaywidth(self.name)
+    if &number
+        let pathStrMaxLen = pathStrMaxLen - &numberwidth
+    endif
+
+    let pathStr = self.path.str({'format': 'UI'})
+    if strdisplaywidth(pathStr) > pathStrMaxLen
+        while strdisplaywidth(pathStr) > pathStrMaxLen && strchars(pathStr) > 0
+            let pathStr = substitute(pathStr, '^.', '', '')
+        endwhile
+        let pathStr = '<' . pathStr
+    endif
+    return '>' . self.name . ' ' . pathStr
+endfunction
+
+" FUNCTION: Bookmark.toRoot(nerdtree) {{{1
+" Set the root of the given NERDTree to the node for this Bookmark. If a node
+" for this Bookmark does not exist, a new one is initialized.
+function! s:Bookmark.toRoot(nerdtree)
+    if self.validate()
+        try
+            let l:targetNode = self.getNode(a:nerdtree, 1)
+            call l:targetNode.closeChildren()
+        catch /^NERDTree.BookmarkedNodeNotFoundError/
+            let l:targetNode = g:NERDTreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path, a:nerdtree)
+        endtry
+        call a:nerdtree.changeRoot(l:targetNode)
+    endif
+endfunction
+
+" FUNCTION: Bookmark.ToRoot(name, nerdtree) {{{1
+" Class method that makes the Bookmark with the given name the root of
+" specified NERDTree.
+function! s:Bookmark.ToRoot(name, nerdtree)
+    let l:bookmark = s:Bookmark.BookmarkFor(a:name)
+    call l:bookmark.toRoot(a:nerdtree)
+endfunction
+
+" FUNCTION: Bookmark.validate() {{{1
+function! s:Bookmark.validate()
+    if self.path.exists()
+        return 1
+    else
+        call s:Bookmark.CacheBookmarks(1)
+        call nerdtree#echo(self.name . 'now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.')
+        return 0
+    endif
+endfunction
+
+" FUNCTION: Bookmark.Write() {{{1
+" Class method to write all bookmarks to the bookmarks file
+function! s:Bookmark.Write()
+    let bookmarkStrings = []
+    for i in s:Bookmark.Bookmarks()
+        call add(bookmarkStrings, i.name . ' ' . fnamemodify(i.path.str(), ':~'))
+    endfor
+
+    "add a blank line before the invalid ones
+    call add(bookmarkStrings, '')
+
+    for j in s:Bookmark.InvalidBookmarks()
+        call add(bookmarkStrings, j)
+    endfor
+
+    try
+        call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
+    catch
+        call nerdtree#echoError('Failed to write bookmarks file. Make sure g:NERDTreeBookmarksFile points to a valid location.')
+    endtry
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/creator.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/creator.vim
new file mode 100644
index 0000000..b9d45dc
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/creator.vim
@@ -0,0 +1,402 @@
+" ============================================================================
+" CLASS: Creator
+"
+" This class is responsible for creating NERDTree instances.  The new NERDTree
+" may be a tab tree, a window tree, or a mirrored tree.  In the process of
+" creating a NERDTree, it sets up all of the window and buffer options and key
+" mappings etc.
+" ============================================================================
+
+
+let s:Creator = {}
+let g:NERDTreeCreator = s:Creator
+
+" FUNCTION: s:Creator._bindMappings() {{{1
+function! s:Creator._bindMappings()
+    call g:NERDTreeKeyMap.BindAll()
+
+    command! -buffer -nargs=? Bookmark :call nerdtree#ui_glue#bookmarkNode('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 RevealBookmark :call nerdtree#ui_glue#revealBookmark('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 OpenBookmark call nerdtree#ui_glue#openBookmark('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=* ClearBookmarks call nerdtree#ui_glue#clearBookmarks('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=+ BookmarkToRoot call g:NERDTreeBookmark.ToRoot('<args>', b:NERDTree)
+    command! -buffer -nargs=0 ClearAllBookmarks call g:NERDTreeBookmark.ClearAll() <bar> call b:NERDTree.render()
+    command! -buffer -nargs=0 ReadBookmarks call g:NERDTreeBookmark.CacheBookmarks(0) <bar> call b:NERDTree.render()
+    command! -buffer -nargs=0 WriteBookmarks call g:NERDTreeBookmark.Write()
+    command! -buffer -nargs=0 EditBookmarks call g:NERDTreeBookmark.Edit()
+endfunction
+
+" FUNCTION: s:Creator._broadcastInitEvent() {{{1
+function! s:Creator._broadcastInitEvent()
+    if exists('#User#NERDTreeInit')
+        doautocmd User NERDTreeInit
+    endif
+endfunction
+
+" FUNCTION: s:Creator.BufNamePrefix() {{{1
+function! s:Creator.BufNamePrefix()
+    return 'NERD_tree_'
+endfunction
+
+" FUNCTION: s:Creator.CreateTabTree(a:name) {{{1
+function! s:Creator.CreateTabTree(name)
+    let creator = s:Creator.New()
+    call creator.createTabTree(a:name)
+endfunction
+
+" FUNCTION: s:Creator.createTabTree(a:name) {{{1
+" name: the name of a bookmark or a directory
+function! s:Creator.createTabTree(name)
+    let l:path = self._pathForString(a:name)
+
+    " Abort if an exception was thrown (i.e., if the bookmark or directory
+    " does not exist).
+    if empty(l:path)
+        return
+    endif
+
+    " Obey the user's preferences for changing the working directory.
+    if g:NERDTreeChDirMode != 0
+        call l:path.changeToDir()
+    endif
+
+    if g:NERDTree.ExistsForTab()
+        call g:NERDTree.Close()
+        call self._removeTreeBufForTab()
+    endif
+
+    call self._createTreeWin()
+    call self._createNERDTree(l:path, 'tab')
+    call b:NERDTree.render()
+    call b:NERDTree.root.putCursorHere(0, 0)
+
+    call self._broadcastInitEvent()
+endfunction
+
+" FUNCTION: s:Creator.CreateWindowTree(dir) {{{1
+function! s:Creator.CreateWindowTree(dir)
+    let creator = s:Creator.New()
+    call creator.createWindowTree(a:dir)
+endfunction
+
+" FUNCTION: s:Creator.createWindowTree(dir) {{{1
+function! s:Creator.createWindowTree(dir)
+    try
+        let path = g:NERDTreePath.New(a:dir)
+    catch /^NERDTree.InvalidArgumentsError/
+        call nerdtree#echo('Invalid directory name:' . a:dir)
+        return
+    endtry
+
+    "we want the directory buffer to disappear when we do the :edit below
+    setlocal bufhidden=wipe
+
+    let previousBuf = expand('#')
+
+    "we need a unique name for each window tree buffer to ensure they are
+    "all independent
+    exec g:NERDTreeCreatePrefix . ' edit ' . self._nextBufferName()
+
+    call self._createNERDTree(path, 'window')
+    let b:NERDTree._previousBuf = bufnr(previousBuf)
+    call self._setCommonBufOptions()
+
+    call b:NERDTree.render()
+
+    call self._broadcastInitEvent()
+endfunction
+
+" FUNCTION: s:Creator._createNERDTree(path) {{{1
+function! s:Creator._createNERDTree(path, type)
+    let b:NERDTree = g:NERDTree.New(a:path, a:type)
+
+    " TODO: This assignment is kept for compatibility reasons.  Many other
+    " plugins use b:NERDTreeRoot instead of b:NERDTree.root.  Remove this
+    " assignment in the future.
+    let b:NERDTreeRoot = b:NERDTree.root
+
+    call b:NERDTree.root.open()
+endfunction
+
+" FUNCTION: s:Creator.CreateMirror() {{{1
+function! s:Creator.CreateMirror()
+    let creator = s:Creator.New()
+    call creator.createMirror()
+endfunction
+
+" FUNCTION: s:Creator.createMirror() {{{1
+function! s:Creator.createMirror()
+    "get the names off all the nerd tree buffers
+    let treeBufNames = []
+    for i in range(1, tabpagenr('$'))
+        let nextName = self._tabpagevar(i, 'NERDTreeBufName')
+        if nextName != -1 && (!exists('t:NERDTreeBufName') || nextName != t:NERDTreeBufName)
+            call add(treeBufNames, nextName)
+        endif
+    endfor
+    let treeBufNames = self._uniq(treeBufNames)
+
+    "map the option names (that the user will be prompted with) to the nerd
+    "tree buffer names
+    let options = {}
+    let i = 0
+    while i < len(treeBufNames)
+        let bufName = treeBufNames[i]
+        let treeRoot = getbufvar(bufName, 'NERDTree').root
+        let options[i+1 . '. ' . treeRoot.path.str() . '  (buf name: ' . bufName . ')'] = bufName
+        let i = i + 1
+    endwhile
+
+    "work out which tree to mirror, if there is more than 1 then ask the user
+    let bufferName = ''
+    if len(keys(options)) > 1
+        let choices = ['Choose a tree to mirror']
+        let choices = extend(choices, sort(keys(options)))
+        let choice = inputlist(choices)
+        if choice < 1 || choice > len(options) || choice ==# ''
+            return
+        endif
+
+        let bufferName = options[sort(keys(options))[choice-1]]
+    elseif len(keys(options)) ==# 1
+        let bufferName = values(options)[0]
+    else
+        call nerdtree#echo('No trees to mirror')
+        return
+    endif
+
+    if g:NERDTree.ExistsForTab() && g:NERDTree.IsOpen()
+        call g:NERDTree.Close()
+    endif
+
+    let t:NERDTreeBufName = bufferName
+    call self._createTreeWin()
+    exec 'buffer ' .  bufferName
+    call b:NERDTree.ui.restoreScreenState()
+    if !&hidden
+        call b:NERDTree.render()
+    endif
+endfunction
+
+" FUNCTION: s:Creator._createTreeWin() {{{1
+" Initialize the NERDTree window.  Open the window, size it properly, set all
+" local options, etc.
+function! s:Creator._createTreeWin()
+    let l:splitLocation = g:NERDTreeWinPos ==# 'left' ? 'topleft ' : 'botright '
+    let l:splitSize = g:NERDTreeWinSize
+
+    if !g:NERDTree.ExistsForTab()
+        let t:NERDTreeBufName = self._nextBufferName()
+        silent! execute l:splitLocation . 'vertical ' . l:splitSize . ' new'
+        silent! execute 'edit ' . t:NERDTreeBufName
+        silent! execute 'vertical resize '. l:splitSize
+    else
+        silent! execute l:splitLocation . 'vertical ' . l:splitSize . ' split'
+        silent! execute 'buffer ' . t:NERDTreeBufName
+    endif
+
+    setlocal winfixwidth
+
+    call self._setCommonBufOptions()
+
+    if has('patch-7.4.1925')
+        clearjumps
+    endif
+
+endfunction
+
+" FUNCTION: s:Creator._isBufHidden(nr) {{{1
+function! s:Creator._isBufHidden(nr)
+    redir => bufs
+    silent ls!
+    redir END
+
+    return bufs =~ a:nr . '..h'
+endfunction
+
+" FUNCTION: s:Creator.New() {{{1
+function! s:Creator.New()
+    let newCreator = copy(self)
+    return newCreator
+endfunction
+
+" FUNCTION: s:Creator._nextBufferName() {{{1
+" returns the buffer name for the next nerd tree
+function! s:Creator._nextBufferName()
+    let name = s:Creator.BufNamePrefix() . self._nextBufferNumber()
+    return name
+endfunction
+
+" FUNCTION: s:Creator._nextBufferNumber() {{{1
+" the number to add to the nerd tree buffer name to make the buf name unique
+function! s:Creator._nextBufferNumber()
+    if !exists('s:Creator._NextBufNum')
+        let s:Creator._NextBufNum = 1
+    else
+        let s:Creator._NextBufNum += 1
+    endif
+
+    return s:Creator._NextBufNum
+endfunction
+
+" FUNCTION: s:Creator._pathForString(str) {{{1
+" find a bookmark or adirectory for the given string
+function! s:Creator._pathForString(str)
+    let path = {}
+    if g:NERDTreeBookmark.BookmarkExistsFor(a:str)
+        let path = g:NERDTreeBookmark.BookmarkFor(a:str).path
+    else
+        let dir = a:str ==# '' ? getcwd() : a:str
+
+        "hack to get an absolute path if a relative path is given
+        if dir =~# '^\.'
+            let dir = getcwd() . nerdtree#slash() . dir
+        endif
+
+        "hack to prevent removing slash if dir is the root of the file system.
+        if dir !=# '/'
+            let dir = g:NERDTreePath.Resolve(dir)
+        endif
+
+        try
+            let path = g:NERDTreePath.New(dir)
+        catch /^NERDTree.InvalidArgumentsError/
+            call nerdtree#echo('No bookmark or directory found for: ' . a:str)
+            return {}
+        endtry
+    endif
+    if !path.isDirectory
+        let path = path.getParent()
+    endif
+
+    return path
+endfunction
+
+" Function: s:Creator._removeTreeBufForTab()   {{{1
+function! s:Creator._removeTreeBufForTab()
+    let buf = bufnr(t:NERDTreeBufName)
+
+    "if &hidden is not set then it will already be gone
+    if buf != -1
+
+        "nerdtree buf may be mirrored/displayed elsewhere
+        if self._isBufHidden(buf)
+            exec 'bwipeout ' . buf
+        endif
+
+    endif
+
+    unlet t:NERDTreeBufName
+endfunction
+
+" FUNCTION: s:Creator._setCommonBufOptions() {{{1
+function! s:Creator._setCommonBufOptions()
+
+    " Options for a non-file/control buffer.
+    setlocal bufhidden=hide
+    setlocal buftype=nofile
+    setlocal noswapfile
+
+    " Options for controlling buffer/window appearance.
+    setlocal foldcolumn=0
+    setlocal foldmethod=manual
+    setlocal nobuflisted
+    setlocal nofoldenable
+    setlocal nolist
+    setlocal nospell
+    setlocal nowrap
+
+    if g:NERDTreeShowLineNumbers
+        setlocal number
+    else
+        setlocal nonumber
+        if v:version >= 703
+            setlocal norelativenumber
+        endif
+    endif
+
+    iabc <buffer>
+
+    if g:NERDTreeHighlightCursorline
+        setlocal cursorline
+    endif
+
+    call self._setupStatusline()
+    call self._bindMappings()
+
+    setlocal filetype=nerdtree
+endfunction
+
+" FUNCTION: s:Creator._setupStatusline() {{{1
+function! s:Creator._setupStatusline()
+    if g:NERDTreeStatusline != -1
+        let &l:statusline = g:NERDTreeStatusline
+    endif
+endfunction
+
+" FUNCTION: s:Creator._tabpagevar(tabnr, var) {{{1
+function! s:Creator._tabpagevar(tabnr, var)
+    let currentTab = tabpagenr()
+    let old_ei = &eventignore
+    set eventignore=all
+
+    try
+        exec 'tabnext ' . a:tabnr
+        let v = -1
+        if exists('t:' . a:var)
+            exec 'let v = t:' . a:var
+        endif
+        exec 'tabnext ' . currentTab
+
+    finally
+        let &eventignore = old_ei
+    endtry
+
+    return v
+endfunction
+
+" FUNCTION: s:Creator.ToggleTabTree(dir) {{{1
+function! s:Creator.ToggleTabTree(dir)
+    let creator = s:Creator.New()
+    call creator.toggleTabTree(a:dir)
+endfunction
+
+" FUNCTION: s:Creator.toggleTabTree(dir) {{{1
+" Toggles the NERD tree. I.e if the NERD tree is open, it is closed. If it is
+" closed, it is restored or initialized. If dir is not empty, it will be set
+" as the new root.
+"
+" Args:
+" dir: the full path for the root node (is used if the NERD tree is being
+" initialized, or to change the root to a new dir.)
+function! s:Creator.toggleTabTree(dir)
+    if g:NERDTree.ExistsForTab()
+        if !g:NERDTree.IsOpen()
+            call self._createTreeWin()
+            if !empty(a:dir) && a:dir !=# b:NERDTree.root.path.str()
+                call self.createTabTree(a:dir)
+            elseif !&hidden
+                call b:NERDTree.render()
+            endif
+            call b:NERDTree.ui.restoreScreenState()
+        else
+            call g:NERDTree.Close()
+        endif
+    else
+        call self.createTabTree(a:dir)
+    endif
+endfunction
+
+" Function: s:Creator._uniq(list)   {{{1
+" returns a:list without duplicates
+function! s:Creator._uniq(list)
+  let uniqlist = []
+  for elem in a:list
+    if index(uniqlist, elem) ==# -1
+      let uniqlist += [elem]
+    endif
+  endfor
+  return uniqlist
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/event.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/event.vim
new file mode 100644
index 0000000..964e8ff
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/event.vim
@@ -0,0 +1,13 @@
+"CLASS: Event
+"============================================================
+let s:Event = {}
+let g:NERDTreeEvent = s:Event
+
+function! s:Event.New(nerdtree, subject, action, params) abort
+    let newObj = copy(self)
+    let newObj.nerdtree = a:nerdtree
+    let newObj.subject = a:subject
+    let newObj.action = a:action
+    let newObj.params = a:params
+    return newObj
+endfunction
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/flag_set.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/flag_set.vim
new file mode 100644
index 0000000..7552867
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/flag_set.vim
@@ -0,0 +1,58 @@
+"CLASS: FlagSet
+"============================================================
+let s:FlagSet = {}
+let g:NERDTreeFlagSet = s:FlagSet
+
+"FUNCTION: FlagSet.addFlag(scope, flag) {{{1
+function! s:FlagSet.addFlag(scope, flag)
+    let flags = self._flagsForScope(a:scope)
+    if index(flags, a:flag) == -1
+        call add(flags, a:flag)
+    end
+endfunction
+
+"FUNCTION: FlagSet.clearFlags(scope) {{{1
+function! s:FlagSet.clearFlags(scope)
+    let self._flags[a:scope] = []
+endfunction
+
+"FUNCTION: FlagSet._flagsForScope(scope) {{{1
+function! s:FlagSet._flagsForScope(scope)
+    if !has_key(self._flags, a:scope)
+        let self._flags[a:scope] = []
+    endif
+    return self._flags[a:scope]
+endfunction
+
+"FUNCTION: FlagSet.New() {{{1
+function! s:FlagSet.New()
+    let newObj = copy(self)
+    let newObj._flags = {}
+    return newObj
+endfunction
+
+"FUNCTION: FlagSet.removeFlag(scope, flag) {{{1
+function! s:FlagSet.removeFlag(scope, flag)
+    let flags = self._flagsForScope(a:scope)
+
+    let i = index(flags, a:flag)
+    if i >= 0
+        call remove(flags, i)
+    endif
+endfunction
+
+"FUNCTION: FlagSet.renderToString() {{{1
+function! s:FlagSet.renderToString()
+    let flagstring = ''
+    for i in values(self._flags)
+        let flagstring .= join(i)
+    endfor
+
+    if len(flagstring) == 0
+        return ''
+    endif
+
+    return '[' . flagstring . ']'
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/key_map.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/key_map.vim
new file mode 100644
index 0000000..ed79167
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/key_map.vim
@@ -0,0 +1,164 @@
+"CLASS: KeyMap
+"============================================================
+let s:KeyMap = {}
+let g:NERDTreeKeyMap = s:KeyMap
+let s:keyMaps = {}
+
+"FUNCTION: KeyMap.All() {{{1
+function! s:KeyMap.All()
+    let sortedKeyMaps = values(s:keyMaps)
+    call sort(sortedKeyMaps, s:KeyMap.Compare, s:KeyMap)
+
+    return sortedKeyMaps
+endfunction
+
+"FUNCTION: KeyMap.Compare(keyMap1, keyMap2) {{{1
+function! s:KeyMap.Compare(keyMap1, keyMap2)
+
+    if a:keyMap1.key >? a:keyMap2.key
+        return 1
+    endif
+
+    if a:keyMap1.key <? a:keyMap2.key
+        return -1
+    endif
+
+    return 0
+endfunction
+
+"FUNCTION: KeyMap.FindFor(key, scope) {{{1
+function! s:KeyMap.FindFor(key, scope)
+    return get(s:keyMaps, a:key . a:scope, {})
+endfunction
+
+"FUNCTION: KeyMap.BindAll() {{{1
+function! s:KeyMap.BindAll()
+    for i in values(s:keyMaps)
+        call i.bind()
+    endfor
+endfunction
+
+"FUNCTION: KeyMap.bind() {{{1
+function! s:KeyMap.bind()
+    " If the key sequence we're trying to map contains any '<>' notation, we
+    " must replace each of the '<' characters with '<lt>' to ensure the string
+    " is not translated into its corresponding keycode during the later part
+    " of the map command below
+    " :he <>
+    let specialNotationRegex = '\m<\([[:alnum:]_-]\+>\)'
+    if self.key =~# specialNotationRegex
+        let keymapInvokeString = substitute(self.key, specialNotationRegex, '<lt>\1', 'g')
+    else
+        let keymapInvokeString = self.key
+    endif
+    let keymapInvokeString = escape(keymapInvokeString, '\"')
+
+    let premap = self.key ==# '<LeftRelease>' ? ' <LeftRelease>' : ' '
+
+    exec 'nnoremap <buffer> <silent> '. self.key . premap . ':call nerdtree#ui_glue#invokeKeyMap("'. keymapInvokeString .'")<cr>'
+endfunction
+
+"FUNCTION: KeyMap.Remove(key, scope) {{{1
+function! s:KeyMap.Remove(key, scope)
+    return remove(s:keyMaps, a:key . a:scope)
+endfunction
+
+"FUNCTION: KeyMap.invoke() {{{1
+"Call the KeyMaps callback function
+function! s:KeyMap.invoke(...)
+    let l:Callback = type(self.callback) ==# type(function('tr')) ? self.callback : function(self.callback)
+    if a:0
+        call l:Callback(a:1)
+    else
+        call l:Callback()
+    endif
+endfunction
+
+"FUNCTION: KeyMap.Invoke() {{{1
+"Find a keymapping for a:key and the current scope invoke it.
+"
+"Scope is determined as follows:
+"   * if the cursor is on a dir node then DirNode
+"   * if the cursor is on a file node then FileNode
+"   * if the cursor is on a bookmark then Bookmark
+"
+"If a keymap has the scope of 'all' then it will be called if no other keymap
+"is found for a:key and the scope.
+function! s:KeyMap.Invoke(key)
+
+    "required because clicking the command window below another window still
+    "invokes the <LeftRelease> mapping - but changes the window cursor
+    "is in first
+    "
+    "TODO: remove this check when the vim bug is fixed
+    if !g:NERDTree.ExistsForBuf()
+        return {}
+    endif
+
+    let node = g:NERDTreeFileNode.GetSelected()
+    if !empty(node)
+
+        "try file node
+        if !node.path.isDirectory
+            let km = s:KeyMap.FindFor(a:key, 'FileNode')
+            if !empty(km)
+                return km.invoke(node)
+            endif
+        endif
+
+        "try dir node
+        if node.path.isDirectory
+            let km = s:KeyMap.FindFor(a:key, 'DirNode')
+            if !empty(km)
+                return km.invoke(node)
+            endif
+        endif
+
+        "try generic node
+        let km = s:KeyMap.FindFor(a:key, 'Node')
+        if !empty(km)
+            return km.invoke(node)
+        endif
+
+    endif
+
+    "try bookmark
+    let bm = g:NERDTreeBookmark.GetSelected()
+    if !empty(bm)
+        let km = s:KeyMap.FindFor(a:key, 'Bookmark')
+        if !empty(km)
+            return km.invoke(bm)
+        endif
+    endif
+
+    "try all
+    let km = s:KeyMap.FindFor(a:key, 'all')
+    if !empty(km)
+        return km.invoke()
+    endif
+endfunction
+
+"FUNCTION: KeyMap.Create(options) {{{1
+function! s:KeyMap.Create(options)
+    let opts = extend({'scope': 'all', 'quickhelpText': ''}, copy(a:options))
+
+    "dont override other mappings unless the 'override' option is given
+    if get(opts, 'override', 0) ==# 0 && !empty(s:KeyMap.FindFor(opts['key'], opts['scope']))
+        return
+    end
+
+    let newKeyMap = copy(self)
+    let newKeyMap.key = opts['key']
+    let newKeyMap.quickhelpText = opts['quickhelpText']
+    let newKeyMap.callback = opts['callback']
+    let newKeyMap.scope = opts['scope']
+
+    call s:KeyMap.Add(newKeyMap)
+endfunction
+
+"FUNCTION: KeyMap.Add(keymap) {{{1
+function! s:KeyMap.Add(keymap)
+    let s:keyMaps[a:keymap.key . a:keymap.scope] = a:keymap
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/menu_controller.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/menu_controller.vim
new file mode 100644
index 0000000..952c67b
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/menu_controller.vim
@@ -0,0 +1,211 @@
+"CLASS: MenuController
+"============================================================
+let s:MenuController = {}
+let g:NERDTreeMenuController = s:MenuController
+
+"FUNCTION: MenuController.New(menuItems) {{{1
+"create a new menu controller that operates on the given menu items
+function! s:MenuController.New(menuItems)
+    let newMenuController =  copy(self)
+    if a:menuItems[0].isSeparator()
+        let newMenuController.menuItems = a:menuItems[1:-1]
+    else
+        let newMenuController.menuItems = a:menuItems
+    endif
+    return newMenuController
+endfunction
+
+" FUNCTION: s:MenuController.isMinimal() {{{1
+function! s:MenuController.isMinimal()
+    return g:NERDTreeMinimalMenu
+endfunction
+
+" FUNCTION: MenuController.showMenu() {{{1
+" Enter the main loop of the NERDTree menu, prompting the user to select
+" a menu item.
+function! s:MenuController.showMenu()
+    call self._saveOptions()
+
+    try
+        let self.selection = 0
+        let l:done = 0
+
+        while !l:done
+            if has('nvim')
+                mode
+            else
+                redraw!
+            endif
+            call self._echoPrompt()
+
+            let l:key = nr2char(getchar())
+            let l:done = self._handleKeypress(l:key)
+        endwhile
+    finally
+        call self._restoreOptions()
+
+        " Redraw when Ctrl-C or Esc is received.
+        if !l:done || self.selection ==# -1
+            redraw!
+        endif
+    endtry
+
+    if self.selection !=# -1
+        let l:m = self._current()
+        call l:m.execute()
+    endif
+endfunction
+
+"FUNCTION: MenuController._echoPrompt() {{{1
+function! s:MenuController._echoPrompt()
+    let navHelp = 'Use ' . g:NERDTreeMenuDown . '/' . g:NERDTreeMenuUp . '/enter'
+
+    if self.isMinimal()
+        let selection = self.menuItems[self.selection].text
+        let keyword = matchstr(selection, '[^ ]*([^ ]*')
+
+        let shortcuts = map(copy(self.menuItems), "v:val['shortcut']")
+        let shortcuts[self.selection] = ' ' . keyword . ' '
+
+        echo 'Menu: [' . join(shortcuts, ',') . '] (' . navHelp . ' or shortcut): '
+    else
+        echo 'NERDTree Menu. ' . navHelp . ', or the shortcuts indicated'
+        echo '========================================================='
+
+        for i in range(0, len(self.menuItems)-1)
+            if self.selection ==# i
+                echo '> ' . self.menuItems[i].text
+            else
+                echo '  ' . self.menuItems[i].text
+            endif
+        endfor
+    endif
+endfunction
+
+"FUNCTION: MenuController._current(key) {{{1
+"get the MenuItem that is currently selected
+function! s:MenuController._current()
+    return self.menuItems[self.selection]
+endfunction
+
+"FUNCTION: MenuController._handleKeypress(key) {{{1
+"change the selection (if appropriate) and return 1 if the user has made
+"their choice, 0 otherwise
+function! s:MenuController._handleKeypress(key)
+    if a:key ==# g:NERDTreeMenuDown
+        call self._cursorDown()
+    elseif a:key ==# g:NERDTreeMenuUp
+        call self._cursorUp()
+    elseif a:key ==# nr2char(27) "escape
+        let self.selection = -1
+        return 1
+    elseif a:key ==# "\r" || a:key ==# "\n" "enter and ctrl-j
+        return 1
+    else
+        let index = self._nextIndexFor(a:key)
+        if index !=# -1
+            let self.selection = index
+            if len(self._allIndexesFor(a:key)) ==# 1
+                return 1
+            endif
+        endif
+    endif
+
+    return 0
+endfunction
+
+"FUNCTION: MenuController._allIndexesFor(shortcut) {{{1
+"get indexes to all menu items with the given shortcut
+function! s:MenuController._allIndexesFor(shortcut)
+    let toReturn = []
+
+    for i in range(0, len(self.menuItems)-1)
+        if self.menuItems[i].shortcut ==# a:shortcut
+            call add(toReturn, i)
+        endif
+    endfor
+
+    return toReturn
+endfunction
+
+"FUNCTION: MenuController._nextIndexFor(shortcut) {{{1
+"get the index to the next menu item with the given shortcut, starts from the
+"current cursor location and wraps around to the top again if need be
+function! s:MenuController._nextIndexFor(shortcut)
+    for i in range(self.selection+1, len(self.menuItems)-1)
+        if self.menuItems[i].shortcut ==# a:shortcut
+            return i
+        endif
+    endfor
+
+    for i in range(0, self.selection)
+        if self.menuItems[i].shortcut ==# a:shortcut
+            return i
+        endif
+    endfor
+
+    return -1
+endfunction
+
+"FUNCTION: MenuController._setCmdheight() {{{1
+"sets &cmdheight to whatever is needed to display the menu
+function! s:MenuController._setCmdheight()
+    if self.isMinimal()
+        let &cmdheight = 1
+    else
+        let &cmdheight = len(self.menuItems) + 3
+    endif
+endfunction
+
+"FUNCTION: MenuController._saveOptions() {{{1
+"set any vim options that are required to make the menu work (saving their old
+"values)
+function! s:MenuController._saveOptions()
+    let self._oldLazyredraw = &lazyredraw
+    let self._oldCmdheight = &cmdheight
+    set nolazyredraw
+    call self._setCmdheight()
+endfunction
+
+"FUNCTION: MenuController._restoreOptions() {{{1
+"restore the options we saved in _saveOptions()
+function! s:MenuController._restoreOptions()
+    let &cmdheight = self._oldCmdheight
+    let &lazyredraw = self._oldLazyredraw
+endfunction
+
+"FUNCTION: MenuController._cursorDown() {{{1
+"move the cursor to the next menu item, skipping separators
+function! s:MenuController._cursorDown()
+    let done = 0
+    while !done
+        if self.selection < len(self.menuItems)-1
+            let self.selection += 1
+        else
+            let self.selection = 0
+        endif
+
+        if !self._current().isSeparator()
+            let done = 1
+        endif
+    endwhile
+endfunction
+
+"FUNCTION: MenuController._cursorUp() {{{1
+"move the cursor to the previous menu item, skipping separators
+function! s:MenuController._cursorUp()
+    let done = 0
+    while !done
+        if self.selection > 0
+            let self.selection -= 1
+        else
+            let self.selection = len(self.menuItems)-1
+        endif
+
+        if !self._current().isSeparator()
+            let done = 1
+        endif
+    endwhile
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/menu_item.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/menu_item.vim
new file mode 100644
index 0000000..7f25917
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/menu_item.vim
@@ -0,0 +1,118 @@
+"CLASS: MenuItem
+"============================================================
+let s:MenuItem = {}
+let g:NERDTreeMenuItem = s:MenuItem
+
+"FUNCTION: MenuItem.All() {{{1
+"get all top level menu items
+function! s:MenuItem.All()
+    if !exists('s:menuItems')
+        let s:menuItems = []
+    endif
+    return s:menuItems
+endfunction
+
+"FUNCTION: MenuItem.AllEnabled() {{{1
+"get all top level menu items that are currently enabled
+function! s:MenuItem.AllEnabled()
+    let toReturn = []
+    for i in s:MenuItem.All()
+        if i.enabled()
+            call add(toReturn, i)
+        endif
+    endfor
+    return toReturn
+endfunction
+
+"FUNCTION: MenuItem.Create(options) {{{1
+"make a new menu item and add it to the global list
+function! s:MenuItem.Create(options)
+    let newMenuItem = copy(self)
+
+    let newMenuItem.text = a:options['text']
+    let newMenuItem.shortcut = a:options['shortcut']
+    let newMenuItem.children = []
+
+    let newMenuItem.isActiveCallback = -1
+    if has_key(a:options, 'isActiveCallback')
+        let newMenuItem.isActiveCallback = a:options['isActiveCallback']
+    endif
+
+    let newMenuItem.callback = -1
+    if has_key(a:options, 'callback')
+        let newMenuItem.callback = a:options['callback']
+    endif
+
+    if has_key(a:options, 'parent')
+        call add(a:options['parent'].children, newMenuItem)
+    else
+        call add(s:MenuItem.All(), newMenuItem)
+    endif
+
+    return newMenuItem
+endfunction
+
+"FUNCTION: MenuItem.CreateSeparator(options) {{{1
+"make a new separator menu item and add it to the global list
+function! s:MenuItem.CreateSeparator(options)
+    let standard_options = { 'text': '--------------------',
+                \ 'shortcut': -1,
+                \ 'callback': -1 }
+    let options = extend(a:options, standard_options, 'force')
+
+    return s:MenuItem.Create(options)
+endfunction
+
+"FUNCTION: MenuItem.CreateSubmenu(options) {{{1
+"make a new submenu and add it to global list
+function! s:MenuItem.CreateSubmenu(options)
+    let standard_options = { 'callback': -1 }
+    let options = extend(a:options, standard_options, 'force')
+
+    return s:MenuItem.Create(options)
+endfunction
+
+"FUNCTION: MenuItem.enabled() {{{1
+"return 1 if this menu item should be displayed
+"
+"delegates off to the isActiveCallback, and defaults to 1 if no callback was
+"specified
+function! s:MenuItem.enabled()
+    if self.isActiveCallback != -1
+        return type(self.isActiveCallback) == type(function('tr')) ? self.isActiveCallback() : {self.isActiveCallback}()
+    endif
+    return 1
+endfunction
+
+"FUNCTION: MenuItem.execute() {{{1
+"perform the action behind this menu item, if this menuitem has children then
+"display a new menu for them, otherwise deletegate off to the menuitem's
+"callback
+function! s:MenuItem.execute()
+    if len(self.children)
+        let mc = g:NERDTreeMenuController.New(self.children)
+        call mc.showMenu()
+    else
+        if self.callback != -1
+            if type(self.callback) == type(function('tr'))
+                call self.callback()
+            else
+                call {self.callback}()
+            endif
+        endif
+    endif
+endfunction
+
+"FUNCTION: MenuItem.isSeparator() {{{1
+"return 1 if this menuitem is a separator
+function! s:MenuItem.isSeparator()
+    return self.callback == -1 && self.children == []
+endfunction
+
+"FUNCTION: MenuItem.isSubmenu() {{{1
+"return 1 if this menuitem is a submenu
+function! s:MenuItem.isSubmenu()
+    return self.callback == -1 && !empty(self.children)
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/nerdtree.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/nerdtree.vim
new file mode 100644
index 0000000..61a11a9
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/nerdtree.vim
@@ -0,0 +1,209 @@
+"CLASS: NERDTree
+"============================================================
+let s:NERDTree = {}
+let g:NERDTree = s:NERDTree
+
+"FUNCTION: s:NERDTree.AddPathFilter() {{{1
+function! s:NERDTree.AddPathFilter(callback)
+    call add(s:NERDTree.PathFilters(), a:callback)
+endfunction
+
+"FUNCTION: s:NERDTree.changeRoot(node) {{{1
+function! s:NERDTree.changeRoot(node)
+    if a:node.path.isDirectory
+        let self.root = a:node
+    else
+        call a:node.cacheParent()
+        let self.root = a:node.parent
+    endif
+
+    call self.root.open()
+
+    "change dir to the dir of the new root if instructed to
+    if g:NERDTreeChDirMode >= 2
+        call self.root.path.changeToDir()
+    endif
+
+    call self.render()
+    call self.root.putCursorHere(0, 0)
+
+    if exists('#User#NERDTreeNewRoot')
+        doautocmd User NERDTreeNewRoot
+    endif
+endfunction
+
+"FUNCTION: s:NERDTree.Close() {{{1
+"Closes the tab tree window for this tab
+function! s:NERDTree.Close()
+    if !s:NERDTree.IsOpen()
+        return
+    endif
+
+    if winnr('$') !=# 1
+        " Use the window ID to identify the currently active window or fall
+        " back on the buffer ID if win_getid/win_gotoid are not available, in
+        " which case we'll focus an arbitrary window showing the buffer.
+        let l:useWinId = exists('*win_getid') && exists('*win_gotoid')
+
+        if winnr() ==# s:NERDTree.GetWinNum()
+            call nerdtree#exec('wincmd p', 1)
+            let l:activeBufOrWin = l:useWinId ? win_getid() : bufnr('')
+            call nerdtree#exec('wincmd p', 1)
+        else
+            let l:activeBufOrWin = l:useWinId ? win_getid() : bufnr('')
+        endif
+
+        call nerdtree#exec(s:NERDTree.GetWinNum() . ' wincmd w', 1)
+        call nerdtree#exec('close', 0)
+        if l:useWinId
+            call nerdtree#exec('call win_gotoid(' . l:activeBufOrWin . ')', 0)
+        else
+            call nerdtree#exec(bufwinnr(l:activeBufOrWin) . ' wincmd w', 0)
+        endif
+    else
+        close
+    endif
+endfunction
+
+"FUNCTION: s:NERDTree.CursorToBookmarkTable(){{{1
+"Places the cursor at the top of the bookmarks table
+function! s:NERDTree.CursorToBookmarkTable()
+    if !b:NERDTree.ui.getShowBookmarks()
+        throw 'NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active'
+    endif
+
+    if g:NERDTreeMinimalUI
+        return cursor(1, 2)
+    endif
+
+    let rootNodeLine = b:NERDTree.ui.getRootLineNum()
+
+    let line = 1
+    while getline(line) !~# '^>-\+Bookmarks-\+$'
+        let line = line + 1
+        if line >= rootNodeLine
+            throw 'NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table'
+        endif
+    endwhile
+    call cursor(line, 2)
+endfunction
+
+"FUNCTION: s:NERDTree.CursorToTreeWin(){{{1
+"Places the cursor in the nerd tree window
+function! s:NERDTree.CursorToTreeWin(...)
+    call g:NERDTree.MustBeOpen()
+    call nerdtree#exec(g:NERDTree.GetWinNum() . 'wincmd w', a:0 >0 ? a:1 : 1)
+endfunction
+
+" Function: s:NERDTree.ExistsForBuffer()   {{{1
+" Returns 1 if a nerd tree root exists in the current buffer
+function! s:NERDTree.ExistsForBuf()
+    return exists('b:NERDTree')
+endfunction
+
+" Function: s:NERDTree.ExistsForTab()   {{{1
+" Returns 1 if a nerd tree root exists in the current tab
+function! s:NERDTree.ExistsForTab()
+    if !exists('t:NERDTreeBufName')
+        return
+    end
+
+    "check b:NERDTree is still there and hasn't been e.g. :bdeleted
+    return !empty(getbufvar(bufnr(t:NERDTreeBufName), 'NERDTree'))
+endfunction
+
+function! s:NERDTree.ForCurrentBuf()
+    if s:NERDTree.ExistsForBuf()
+        return b:NERDTree
+    else
+        return {}
+    endif
+endfunction
+
+"FUNCTION: s:NERDTree.ForCurrentTab() {{{1
+function! s:NERDTree.ForCurrentTab()
+    if !s:NERDTree.ExistsForTab()
+        return
+    endif
+
+    let bufnr = bufnr(t:NERDTreeBufName)
+    return getbufvar(bufnr, 'NERDTree')
+endfunction
+
+"FUNCTION: s:NERDTree.getRoot() {{{1
+function! s:NERDTree.getRoot()
+    return self.root
+endfunction
+
+"FUNCTION: s:NERDTree.GetWinNum() {{{1
+"gets the nerd tree window number for this tab
+function! s:NERDTree.GetWinNum()
+    if exists('t:NERDTreeBufName')
+        return bufwinnr(t:NERDTreeBufName)
+    endif
+
+    " If WindowTree, there is no t:NERDTreeBufName variable. Search all windows.
+    for w in range(1,winnr('$'))
+        if bufname(winbufnr(w)) =~# '^' . g:NERDTreeCreator.BufNamePrefix() . '\d\+$'
+            return w
+        endif
+    endfor
+
+    return -1
+endfunction
+
+"FUNCTION: s:NERDTree.IsOpen() {{{1
+function! s:NERDTree.IsOpen()
+    return s:NERDTree.GetWinNum() !=# -1
+endfunction
+
+"FUNCTION: s:NERDTree.isTabTree() {{{1
+function! s:NERDTree.isTabTree()
+    return self._type ==# 'tab'
+endfunction
+
+"FUNCTION: s:NERDTree.isWinTree() {{{1
+function! s:NERDTree.isWinTree()
+    return self._type ==# 'window'
+endfunction
+
+"FUNCTION: s:NERDTree.MustBeOpen() {{{1
+function! s:NERDTree.MustBeOpen()
+    if !s:NERDTree.IsOpen()
+        throw 'NERDTree.TreeNotOpen'
+    endif
+endfunction
+
+"FUNCTION: s:NERDTree.New() {{{1
+function! s:NERDTree.New(path, type)
+    let newObj = copy(self)
+    let newObj.ui = g:NERDTreeUI.New(newObj)
+    let newObj.root = g:NERDTreeDirNode.New(a:path, newObj)
+    let newObj._type = a:type
+    return newObj
+endfunction
+
+"FUNCTION: s:NERDTree.PathFilters() {{{1
+function! s:NERDTree.PathFilters()
+    if !exists('s:NERDTree._PathFilters')
+        let s:NERDTree._PathFilters = []
+    endif
+    return s:NERDTree._PathFilters
+endfunction
+
+"FUNCTION: s:NERDTree.previousBuf() {{{1
+function! s:NERDTree.previousBuf()
+    return self._previousBuf
+endfunction
+
+function! s:NERDTree.setPreviousBuf(bnum)
+    let self._previousBuf = a:bnum
+endfunction
+
+"FUNCTION: s:NERDTree.render() {{{1
+"A convenience function - since this is called often
+function! s:NERDTree.render()
+    call self.ui.render()
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/notifier.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/notifier.vim
new file mode 100644
index 0000000..ffa2853
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/notifier.vim
@@ -0,0 +1,35 @@
+"CLASS: Notifier
+"============================================================
+let s:Notifier = {}
+
+function! s:Notifier.AddListener(event, funcname)
+    let listeners = s:Notifier.GetListenersForEvent(a:event)
+    if listeners == []
+        let listenersMap = s:Notifier.GetListenersMap()
+        let listenersMap[a:event] = listeners
+    endif
+    call add(listeners, a:funcname)
+endfunction
+
+function! s:Notifier.NotifyListeners(event, path, nerdtree, params)
+    let event = g:NERDTreeEvent.New(a:nerdtree, a:path, a:event, a:params)
+
+    for Listener in s:Notifier.GetListenersForEvent(a:event)
+        let l:Callback = type(Listener) == type(function('tr')) ? Listener : function(Listener)
+        call l:Callback(event)
+    endfor
+endfunction
+
+function! s:Notifier.GetListenersMap()
+    if !exists('s:refreshListenersMap')
+        let s:refreshListenersMap = {}
+    endif
+    return s:refreshListenersMap
+endfunction
+
+function! s:Notifier.GetListenersForEvent(name)
+    let listenersMap = s:Notifier.GetListenersMap()
+    return get(listenersMap, a:name, [])
+endfunction
+
+let g:NERDTreePathNotifier = deepcopy(s:Notifier)
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/opener.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/opener.vim
new file mode 100644
index 0000000..27993ac
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/opener.vim
@@ -0,0 +1,326 @@
+" ============================================================================
+" CLASS: Opener
+"
+" The Opener class defines an API for 'opening' operations.
+" ============================================================================
+
+
+let s:Opener = {}
+let g:NERDTreeOpener = s:Opener
+
+" FUNCTION: s:Opener._bufInWindows(bnum) {{{1
+" [[STOLEN FROM VTREEEXPLORER.VIM]]
+" Determine the number of windows open to this buffer number.
+" Care of Yegappan Lakshman.  Thanks!
+"
+" Args:
+" bnum: the subject buffers buffer number
+function! s:Opener._bufInWindows(bnum)
+    let cnt = 0
+    let winnum = 1
+    while 1
+        let bufnum = winbufnr(winnum)
+        if bufnum < 0
+            break
+        endif
+        if bufnum ==# a:bnum
+            let cnt = cnt + 1
+        endif
+        let winnum = winnum + 1
+    endwhile
+
+    return cnt
+endfunction
+
+" FUNCTION: Opener._checkToCloseTree(newtab) {{{1
+" Check the class options to see if the tree should be closed now.
+"
+" Args:
+" a:newtab - boolean. If set, only close the tree now if we are opening the
+" target in a new tab. This is needed because we have to close tree before we
+" leave the tab
+function! s:Opener._checkToCloseTree(newtab)
+    if self._keepopen
+        return
+    endif
+
+    if (a:newtab && self._where ==# 't') || !a:newtab
+        call g:NERDTree.Close()
+    endif
+endfunction
+
+" FUNCTION: s:Opener._firstUsableWindow() {{{1
+" find the window number of the first normal window
+function! s:Opener._firstUsableWindow()
+    let i = 1
+    while i <= winnr('$')
+        let bnum = winbufnr(i)
+        if bnum !=# -1 && getbufvar(bnum, '&buftype') ==# ''
+                    \ && !getwinvar(i, '&previewwindow')
+                    \ && (!getbufvar(bnum, '&modified') || &hidden)
+            return i
+        endif
+
+        let i += 1
+    endwhile
+    return -1
+endfunction
+
+" FUNCTION: Opener._gotoTargetWin() {{{1
+function! s:Opener._gotoTargetWin()
+    if b:NERDTree.isWinTree()
+        if self._where ==# 'v'
+            call self._newVSplit()
+        elseif self._where ==# 'h'
+            call self._newSplit()
+        elseif self._where ==# 't'
+            tabnew
+        endif
+    else
+        call self._checkToCloseTree(1)
+
+        if self._where ==# 'v'
+            call self._newVSplit()
+        elseif self._where ==# 'h'
+            call self._newSplit()
+        elseif self._where ==# 't'
+            tabnew
+        elseif self._where ==# 'p'
+            call self._previousWindow()
+        endif
+
+        call self._checkToCloseTree(0)
+    endif
+endfunction
+
+" FUNCTION: s:Opener._isWindowUsable(winnumber) {{{1
+" Returns 0 if opening a file from the tree in the given window requires it to
+" be split, 1 otherwise
+"
+" Args:
+" winnumber: the number of the window in question
+function! s:Opener._isWindowUsable(winnumber)
+    "gotta split if theres only one window (i.e. the NERD tree)
+    if winnr('$') ==# 1
+        return 0
+    endif
+
+    let oldwinnr = winnr()
+    call nerdtree#exec(a:winnumber . 'wincmd p', 1)
+    let specialWindow = getbufvar('%', '&buftype') !=# '' || getwinvar('%', '&previewwindow')
+    let modified = &modified
+    call nerdtree#exec(oldwinnr . 'wincmd p', 1)
+
+    "if its a special window e.g. quickfix or another explorer plugin then we
+    "have to split
+    if specialWindow
+        return 0
+    endif
+
+    if &hidden
+        return 1
+    endif
+
+    return !modified || self._bufInWindows(winbufnr(a:winnumber)) >= 2
+endfunction
+
+" FUNCTION: Opener.New(path, opts) {{{1
+" Instantiate a new NERDTreeOpener object.
+" Args:
+" a:path: the path object that is to be opened
+" a:opts: a dictionary containing the following optional keys...
+"   'where': specifies whether the node should be opened in new split, in
+"            a new tab or, in the last window; takes values 'v', 'h', or 't'
+"   'reuse': if file is already shown in a window, jump there; takes values
+"            'all', 'currenttab', or empty
+"   'keepopen': boolean (0 or 1); if true, the tree window will not be closed
+"   'stay': boolean (0 or 1); if true, remain in tree window after opening
+function! s:Opener.New(path, opts)
+    let l:newOpener = copy(self)
+
+    let l:newOpener._keepopen = nerdtree#has_opt(a:opts, 'keepopen')
+    let l:newOpener._nerdtree = b:NERDTree
+    let l:newOpener._path = a:path
+    let l:newOpener._reuse = has_key(a:opts, 'reuse') ? a:opts['reuse'] : ''
+    let l:newOpener._stay = nerdtree#has_opt(a:opts, 'stay')
+    let l:newOpener._where = has_key(a:opts, 'where') ? a:opts['where'] : ''
+
+    call l:newOpener._saveCursorPos()
+
+    return l:newOpener
+endfunction
+
+" FUNCTION: Opener._newSplit() {{{1
+function! s:Opener._newSplit()
+    let onlyOneWin = (winnr('$') ==# 1)
+    let savesplitright = &splitright
+    if onlyOneWin
+        let &splitright = (g:NERDTreeWinPos ==# 'left')
+    endif
+    " If only one window (ie. NERDTree), split vertically instead.
+    let splitMode = onlyOneWin ? 'vertical' : ''
+
+    " Open the new window
+    try
+        call nerdtree#exec('wincmd p', 1)
+        call nerdtree#exec(splitMode . ' split',1)
+    catch /^Vim\%((\a\+)\)\=:E37/
+        call g:NERDTree.CursorToTreeWin()
+        throw 'NERDTree.FileAlreadyOpenAndModifiedError: '. self._path.str() .' is already open and modified.'
+    catch /^Vim\%((\a\+)\)\=:/
+        "do nothing
+    endtry
+
+    "resize the tree window if no other window was open before
+    if onlyOneWin
+        call nerdtree#exec('wincmd p', 1)
+        call nerdtree#exec('silent '. splitMode .' resize '. g:NERDTreeWinSize, 1)
+        call nerdtree#exec('wincmd p', 0)
+    endif
+
+    let &splitright=savesplitright
+endfunction
+
+" FUNCTION: Opener._newVSplit() {{{1
+function! s:Opener._newVSplit()
+    let l:winwidth = winwidth('.')
+
+    let onlyOneWin = (winnr('$') ==# 1)
+    let savesplitright = &splitright
+    if onlyOneWin
+        let &splitright = (g:NERDTreeWinPos ==# 'left')
+        let l:winwidth = g:NERDTreeWinSize
+    endif
+
+    call nerdtree#exec('wincmd p', 1)
+    call nerdtree#exec('vsplit', 1)
+
+    let l:currentWindowNumber = winnr()
+
+    " Restore the NERDTree to its original width.
+    call g:NERDTree.CursorToTreeWin()
+    execute 'silent vertical resize ' . l:winwidth
+
+    call nerdtree#exec(l:currentWindowNumber . 'wincmd w', 0)
+    let &splitright=savesplitright
+endfunction
+
+" FUNCTION: Opener.open(target) {{{1
+function! s:Opener.open(target)
+    if self._path.isDirectory
+        call self._openDirectory(a:target)
+        return
+    endif
+
+    call self._openFile()
+endfunction
+
+" FUNCTION: Opener._openFile() {{{1
+function! s:Opener._openFile()
+    if !self._stay && self._keepopen && get(b:, 'NERDTreeZoomed', 0)
+        call b:NERDTree.ui.toggleZoom()
+    endif
+
+    if self._reuseWindow()
+        return
+    endif
+
+    call self._gotoTargetWin()
+
+    if self._stay
+        silent call self._path.edit()
+        call self._restoreCursorPos()
+        return
+    endif
+
+    call self._path.edit()
+endfunction
+
+" FUNCTION: Opener._openDirectory(node) {{{1
+function! s:Opener._openDirectory(node)
+    call self._gotoTargetWin()
+
+    if self._nerdtree.isWinTree()
+        call g:NERDTreeCreator.CreateWindowTree(a:node.path.str())
+    else
+        if empty(self._where)
+            call b:NERDTree.changeRoot(a:node)
+        elseif self._where ==# 't'
+            call g:NERDTreeCreator.CreateTabTree(a:node.path.str())
+        else
+            call g:NERDTreeCreator.CreateWindowTree(a:node.path.str())
+        endif
+    endif
+
+    if self._stay
+        call self._restoreCursorPos()
+    endif
+endfunction
+
+" FUNCTION: Opener._previousWindow() {{{1
+function! s:Opener._previousWindow()
+    if !self._isWindowUsable(winnr('#')) && self._firstUsableWindow() ==# -1
+        call self._newSplit()
+    else
+        try
+            if !self._isWindowUsable(winnr('#'))
+                call nerdtree#exec(self._firstUsableWindow() . 'wincmd w', 1)
+            else
+                call nerdtree#exec('wincmd p', 1)
+            endif
+        catch /^Vim\%((\a\+)\)\=:E37/
+            call g:NERDTree.CursorToTreeWin()
+            throw 'NERDTree.FileAlreadyOpenAndModifiedError: '. self._path.str() .' is already open and modified.'
+        catch /^Vim\%((\a\+)\)\=:/
+            echo v:exception
+        endtry
+    endif
+endfunction
+
+" FUNCTION: Opener._restoreCursorPos() {{{1
+function! s:Opener._restoreCursorPos()
+    call nerdtree#exec(self._tabnr . 'tabnext', 1)
+    call nerdtree#exec(bufwinnr(self._bufnr) . 'wincmd w', 1)
+endfunction
+
+" FUNCTION: Opener._reuseWindow() {{{1
+" put the cursor in the first window we find for this file
+"
+" return 1 if we were successful
+function! s:Opener._reuseWindow()
+    if empty(self._reuse)
+        return 0
+    endif
+
+    "check the current tab for the window
+    let winnr = bufwinnr('^' . self._path.str() . '$')
+    if winnr !=# -1
+        call nerdtree#exec(winnr . 'wincmd w', 0)
+        call self._checkToCloseTree(0)
+        return 1
+    endif
+
+    if self._reuse ==# 'currenttab'
+        return 0
+    endif
+
+    "check other tabs
+    let tabnr = self._path.tabnr()
+    if tabnr
+        call self._checkToCloseTree(1)
+        call nerdtree#exec(tabnr . 'tabnext', 1)
+        let winnr = bufwinnr('^' . self._path.str() . '$')
+        call nerdtree#exec(winnr . 'wincmd w', 0)
+        return 1
+    endif
+
+    return 0
+endfunction
+
+" FUNCTION: Opener._saveCursorPos() {{{1
+function! s:Opener._saveCursorPos()
+    let self._bufnr = bufnr('')
+    let self._tabnr = tabpagenr()
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/path.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/path.vim
new file mode 100644
index 0000000..997abf3
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/path.vim
@@ -0,0 +1,852 @@
+" ============================================================================
+" CLASS: Path
+"
+" The Path class provides an abstracted representation of a file system
+" pathname.  Various operations on pathnames are provided and a number of
+" representations of a given path name can be accessed here.
+" ============================================================================
+
+
+let s:Path = {}
+let g:NERDTreePath = s:Path
+
+" FUNCTION: Path.AbsolutePathFor(pathStr) {{{1
+function! s:Path.AbsolutePathFor(pathStr)
+    let l:prependWorkingDir = 0
+
+    if nerdtree#runningWindows()
+        let l:prependWorkingDir = a:pathStr !~# '^.:\(\\\|\/\)\?' && a:pathStr !~# '^\(\\\\\|\/\/\)'
+    else
+        let l:prependWorkingDir = a:pathStr !~# '^/'
+    endif
+
+    let l:result = a:pathStr
+
+    if l:prependWorkingDir
+        let l:result = getcwd()
+
+        if l:result[-1:] == nerdtree#slash()
+            let l:result = l:result . a:pathStr
+        else
+            let l:result = l:result . nerdtree#slash() . a:pathStr
+        endif
+    endif
+
+    return l:result
+endfunction
+
+" FUNCTION: Path.bookmarkNames() {{{1
+function! s:Path.bookmarkNames()
+    if !exists('self._bookmarkNames')
+        call self.cacheDisplayString()
+    endif
+    return self._bookmarkNames
+endfunction
+
+" FUNCTION: Path.cacheDisplayString() {{{1
+function! s:Path.cacheDisplayString() abort
+    let self.cachedDisplayString = g:NERDTreeNodeDelimiter . self.getLastPathComponent(1)
+
+    if self.isExecutable
+        let self.cachedDisplayString = self.addDelimiter(self.cachedDisplayString) . '*'
+    endif
+
+    let self._bookmarkNames = []
+    for i in g:NERDTreeBookmark.Bookmarks()
+        if i.path.equals(self)
+            call add(self._bookmarkNames, i.name)
+        endif
+    endfor
+    if !empty(self._bookmarkNames) && g:NERDTreeMarkBookmarks ==# 1
+        let self.cachedDisplayString = self.addDelimiter(self.cachedDisplayString) . ' {' . join(self._bookmarkNames) . '}'
+    endif
+
+    if self.isSymLink
+        let self.cachedDisplayString = self.addDelimiter(self.cachedDisplayString) . ' -> ' . self.symLinkDest
+    endif
+
+    if self.isReadOnly
+        let self.cachedDisplayString = self.addDelimiter(self.cachedDisplayString) . ' ['.g:NERDTreeGlyphReadOnly.']'
+    endif
+endfunction
+
+" FUNCTION: Path.addDelimiter() {{{1
+function! s:Path.addDelimiter(line)
+    if a:line =~# '\(.*' . g:NERDTreeNodeDelimiter . '\)\{2}'
+        return a:line
+    else
+        return a:line . g:NERDTreeNodeDelimiter
+    endif
+endfunction
+
+" FUNCTION: Path.changeToDir() {{{1
+function! s:Path.changeToDir()
+    let dir = self.str({'format': 'Cd'})
+    if self.isDirectory ==# 0
+        let dir = self.getParent().str({'format': 'Cd'})
+    endif
+
+    try
+        if g:NERDTreeUseTCD && exists(':tcd') ==# 2
+            execute 'tcd ' . dir
+            call nerdtree#echo("Tab's CWD is now: " . getcwd())
+        else
+            execute 'cd ' . dir
+            call nerdtree#echo('CWD is now: ' . getcwd())
+        endif
+    catch
+        throw 'NERDTree.PathChangeError: cannot change CWD to ' . dir
+    endtry
+endfunction
+
+" FUNCTION: Path.Create(fullpath) {{{1
+"
+" Factory method.
+"
+" Creates a path object with the given path. The path is also created on the
+" filesystem. If the path already exists, a NERDTree.Path.Exists exception is
+" thrown. If any other errors occur, a NERDTree.Path exception is thrown.
+"
+" Args:
+" fullpath: the full filesystem path to the file/dir to create
+function! s:Path.Create(fullpath)
+    "bail if the a:fullpath already exists
+    if isdirectory(a:fullpath) || filereadable(a:fullpath)
+        throw "NERDTree.CreatePathError: Directory Exists: '" . a:fullpath . "'"
+    endif
+
+    try
+
+        "if it ends with a slash, assume its a dir create it
+        if a:fullpath =~# '\(\\\|\/\)$'
+            "whack the trailing slash off the end if it exists
+            let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '')
+
+            call mkdir(fullpath, 'p')
+
+        "assume its a file and create
+        else
+            call s:Path.createParentDirectories(a:fullpath)
+            call writefile([], a:fullpath)
+        endif
+    catch
+        throw "NERDTree.CreatePathError: Could not create path: '" . a:fullpath . "'"
+    endtry
+
+    return s:Path.New(a:fullpath)
+endfunction
+
+" FUNCTION: Path.copy(dest) {{{1
+"
+" Copies the file/dir represented by this Path to the given location
+"
+" Args:
+" dest: the location to copy this dir/file to
+function! s:Path.copy(dest)
+    if !s:Path.CopyingSupported()
+        throw 'NERDTree.CopyingNotSupportedError: Copying is not supported on this OS'
+    endif
+
+    call s:Path.createParentDirectories(a:dest)
+
+    if exists('g:NERDTreeCopyCmd')
+        let cmd_prefix = g:NERDTreeCopyCmd
+    else
+        let cmd_prefix = (self.isDirectory ? g:NERDTreeCopyDirCmd : g:NERDTreeCopyFileCmd)
+    endif
+
+    let cmd = cmd_prefix . ' ' . shellescape(self.str()) . ' ' . shellescape(a:dest)
+    let success = system(cmd)
+    if v:shell_error !=# 0
+        throw "NERDTree.CopyError: Could not copy '". self.str() ."' to: '" . a:dest . "'"
+    endif
+endfunction
+
+" FUNCTION: Path.CopyingSupported() {{{1
+"
+" returns 1 if copying is supported for this OS
+function! s:Path.CopyingSupported()
+    return exists('g:NERDTreeCopyCmd') || (exists('g:NERDTreeCopyDirCmd') && exists('g:NERDTreeCopyFileCmd'))
+endfunction
+
+" FUNCTION: Path.copyingWillOverwrite(dest) {{{1
+"
+" returns 1 if copy this path to the given location will cause files to
+" overwritten
+"
+" Args:
+" dest: the location this path will be copied to
+function! s:Path.copyingWillOverwrite(dest)
+    if filereadable(a:dest)
+        return 1
+    endif
+
+    if isdirectory(a:dest)
+        let path = s:Path.JoinPathStrings(a:dest, self.getLastPathComponent(0))
+        if filereadable(path)
+            return 1
+        endif
+    endif
+endfunction
+
+" FUNCTION: Path.createParentDirectories(path) {{{1
+"
+" create parent directories for this path if needed
+" without throwing any errors if those directories already exist
+"
+" Args:
+" path: full path of the node whose parent directories may need to be created
+function! s:Path.createParentDirectories(path)
+    let dir_path = fnamemodify(a:path, ':h')
+    if !isdirectory(dir_path)
+        call mkdir(dir_path, 'p')
+    endif
+endfunction
+
+" FUNCTION: Path.delete() {{{1
+"
+" Deletes the file or directory represented by this path.
+"
+" Throws NERDTree.Path.Deletion exceptions
+function! s:Path.delete()
+    if self.isDirectory
+
+        let cmd = g:NERDTreeRemoveDirCmd . self.str({'escape': 1})
+        let success = system(cmd)
+
+        if v:shell_error !=# 0
+            throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.str() . "'"
+        endif
+    else
+        if exists('g:NERDTreeRemoveFileCmd')
+            let cmd = g:NERDTreeRemoveFileCmd . self.str({'escape': 1})
+            let success = system(cmd)
+        else
+            let success = delete(self.str())
+        endif
+
+        if success !=# 0
+            throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str() . "'"
+        endif
+    endif
+
+    "delete all bookmarks for this path
+    for i in self.bookmarkNames()
+        let bookmark = g:NERDTreeBookmark.BookmarkFor(i)
+        call bookmark.delete()
+    endfor
+endfunction
+
+" FUNCTION: Path.displayString() {{{1
+"
+" Returns a string that specifies how the path should be represented as a
+" string
+function! s:Path.displayString()
+    if self.cachedDisplayString ==# ''
+        call self.cacheDisplayString()
+    endif
+
+    return self.cachedDisplayString
+endfunction
+
+" FUNCTION: Path.edit() {{{1
+function! s:Path.edit()
+    let l:bufname = self.str({'format': 'Edit'})
+    if bufname('%') !=# l:bufname
+        exec 'edit ' . l:bufname
+    endif
+endfunction
+
+" FUNCTION: Path.extractDriveLetter(fullpath) {{{1
+"
+" If running windows, cache the drive letter for this path
+function! s:Path.extractDriveLetter(fullpath)
+    if nerdtree#runningWindows()
+        if a:fullpath =~# '^\(\\\\\|\/\/\)'
+            "For network shares, the 'drive' consists of the first two parts of the path, i.e. \\boxname\share
+            let self.drive = substitute(a:fullpath, '^\(\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\).*', '\1', '')
+            let self.drive = substitute(self.drive, '/', '\', 'g')
+        else
+            let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
+        endif
+    else
+        let self.drive = ''
+    endif
+
+endfunction
+
+" FUNCTION: Path.exists() {{{1
+" return 1 if this path points to a location that is readable or is a directory
+function! s:Path.exists()
+    let p = self.str()
+    return filereadable(p) || isdirectory(p)
+endfunction
+
+" FUNCTION: Path._escChars() {{{1
+function! s:Path._escChars()
+    if nerdtree#runningWindows()
+        return " `\|\"#%&,?()\*^<>$"
+    endif
+
+    return " \\`\|\"#%&,?()\*^<>[]{}$"
+endfunction
+
+" FUNCTION: Path.getDir() {{{1
+"
+" Returns this path if it is a directory, else this paths parent.
+"
+" Return:
+" a Path object
+function! s:Path.getDir()
+    if self.isDirectory
+        return self
+    else
+        return self.getParent()
+    endif
+endfunction
+
+" FUNCTION: Path.getParent() {{{1
+"
+" Returns a new path object for this paths parent
+"
+" Return:
+" a new Path object
+function! s:Path.getParent()
+    if nerdtree#runningWindows()
+        let path = self.drive . '\' . join(self.pathSegments[0:-2], '\')
+    else
+        let path = '/'. join(self.pathSegments[0:-2], '/')
+    endif
+
+    return s:Path.New(path)
+endfunction
+
+" FUNCTION: Path.getLastPathComponent(dirSlash) {{{1
+"
+" Gets the last part of this path.
+"
+" Args:
+" dirSlash: if 1 then a trailing slash will be added to the returned value for
+" directory nodes.
+function! s:Path.getLastPathComponent(dirSlash)
+    if empty(self.pathSegments)
+        return ''
+    endif
+    let toReturn = self.pathSegments[-1]
+    if a:dirSlash && self.isDirectory
+        let toReturn = toReturn . '/'
+    endif
+    return toReturn
+endfunction
+
+" FUNCTION: Path.getSortOrderIndex() {{{1
+" returns the index of the pattern in g:NERDTreeSortOrder that this path matches
+function! s:Path.getSortOrderIndex()
+    let i = 0
+    while i < len(g:NERDTreeSortOrder)
+        if g:NERDTreeSortOrder[i] !~? '\[\[-\?\(timestamp\|size\|extension\)\]\]' &&
+        \ self.getLastPathComponent(1) =~# g:NERDTreeSortOrder[i]
+            return i
+        endif
+        let i = i + 1
+    endwhile
+
+    return index(g:NERDTreeSortOrder, '*')
+endfunction
+
+" FUNCTION: Path._splitChunks(path) {{{1
+" returns a list of path chunks
+function! s:Path._splitChunks(path)
+    let chunks = split(a:path, '\(\D\+\|\d\+\)\zs')
+    let i = 0
+    while i < len(chunks)
+        "convert number literals to numbers
+        if match(chunks[i], '^\d\+$') ==# 0
+            let chunks[i] = str2nr(chunks[i])
+        endif
+        let i = i + 1
+    endwhile
+    return chunks
+endfunction
+
+" FUNCTION: Path.getSortKey() {{{1
+" returns a key used in compare function for sorting
+function! s:Path.getSortKey()
+    if !exists('self._sortKey') || g:NERDTreeSortOrder !=# g:NERDTreeOldSortOrder
+        " Look for file metadata tags: [[timestamp]], [[extension]], [[size]]
+        let metadata = []
+        for tag in g:NERDTreeSortOrder
+            if tag =~? '\[\[-\?timestamp\]\]'
+                let metadata += [self.isDirectory ? 0 : getftime(self.str()) * (tag =~# '-' ? -1 : 1)]
+            elseif tag =~? '\[\[-\?size\]\]'
+                let metadata += [self.isDirectory ? 0 : getfsize(self.str()) * (tag =~# '-' ? -1 : 1)]
+            elseif tag =~? '\[\[extension\]\]'
+                let extension = matchstr(self.getLastPathComponent(0), '[^.]\+\.\zs[^.]\+$')
+                let metadata += [self.isDirectory ? '' : (extension ==# '' ? nr2char(str2nr('0x10ffff',16)) : extension)]
+            endif
+        endfor
+
+        if g:NERDTreeSortOrder[0] =~# '\[\[.*\]\]'
+            " Apply tags' sorting first if specified first.
+            let self._sortKey = metadata + [self.getSortOrderIndex()]
+        else
+            " Otherwise, do regex grouping first.
+            let self._sortKey = [self.getSortOrderIndex()] + metadata
+        endif
+
+        let path = self.getLastPathComponent(0)
+        if !g:NERDTreeSortHiddenFirst
+            let path = substitute(path, '^[._]', '', '')
+        endif
+        if !g:NERDTreeCaseSensitiveSort
+            let path = tolower(path)
+        endif
+
+        call extend(self._sortKey, (g:NERDTreeNaturalSort ? self._splitChunks(path) : [path]))
+    endif
+    return self._sortKey
+endfunction
+
+" FUNCTION: Path.isHiddenUnder(path) {{{1
+function! s:Path.isHiddenUnder(path)
+
+    if !self.isUnder(a:path)
+        return 0
+    endif
+
+    let l:startIndex = len(a:path.pathSegments)
+    let l:segments = self.pathSegments[l:startIndex : ]
+
+    for l:segment in l:segments
+
+        if l:segment =~# '^\.'
+            return 1
+        endif
+    endfor
+
+    return 0
+endfunction
+
+" FUNCTION: Path.isUnixHiddenFile() {{{1
+" check for unix hidden files
+function! s:Path.isUnixHiddenFile()
+    return self.getLastPathComponent(0) =~# '^\.'
+endfunction
+
+" FUNCTION: Path.isUnixHiddenPath() {{{1
+" check for unix path with hidden components
+function! s:Path.isUnixHiddenPath()
+    if self.getLastPathComponent(0) =~# '^\.'
+        return 1
+    else
+        for segment in self.pathSegments
+            if segment =~# '^\.'
+                return 1
+            endif
+        endfor
+        return 0
+    endif
+endfunction
+
+" FUNCTION: Path.ignore(nerdtree) {{{1
+" returns true if this path should be ignored
+function! s:Path.ignore(nerdtree)
+    "filter out the user specified paths to ignore
+    if a:nerdtree.ui.isIgnoreFilterEnabled()
+        for i in g:NERDTreeIgnore
+            if self._ignorePatternMatches(i)
+                return 1
+            endif
+        endfor
+
+        for l:Callback in g:NERDTree.PathFilters()
+            let l:Callback = type(l:Callback) ==# type(function('tr')) ? l:Callback : function(l:Callback)
+            if l:Callback({'path': self, 'nerdtree': a:nerdtree})
+               return 1
+            endif
+        endfor
+    endif
+
+    "dont show hidden files unless instructed to
+    if !a:nerdtree.ui.getShowHidden() && self.isUnixHiddenFile()
+        return 1
+    endif
+
+    if a:nerdtree.ui.getShowFiles() ==# 0 && self.isDirectory ==# 0
+        return 1
+    endif
+
+    return 0
+endfunction
+
+" FUNCTION: Path._ignorePatternMatches(pattern) {{{1
+" returns true if this path matches the given ignore pattern
+function! s:Path._ignorePatternMatches(pattern)
+    let pat = a:pattern
+    if strpart(pat,len(pat)-8) ==# '[[path]]'
+        let pat = strpart(pat,0, len(pat)-8)
+        return self.str() =~# pat
+    elseif strpart(pat,len(pat)-7) ==# '[[dir]]'
+        if !self.isDirectory
+            return 0
+        endif
+        let pat = strpart(pat,0, len(pat)-7)
+    elseif strpart(pat,len(pat)-8) ==# '[[file]]'
+        if self.isDirectory
+            return 0
+        endif
+        let pat = strpart(pat,0, len(pat)-8)
+    endif
+
+    return self.getLastPathComponent(0) =~# pat
+endfunction
+
+" FUNCTION: Path.isAncestor(path) {{{1
+" return 1 if this path is somewhere above the given path in the filesystem.
+"
+" a:path should be a dir
+function! s:Path.isAncestor(child)
+    return a:child.isUnder(self)
+endfunction
+
+" FUNCTION: Path.isUnder(path) {{{1
+" return 1 if this path is somewhere under the given path in the filesystem.
+function! s:Path.isUnder(parent)
+    if a:parent.isDirectory ==# 0
+        return 0
+    endif
+    if nerdtree#runningWindows() && a:parent.drive !=# self.drive
+        return 0
+    endif
+    let l:this_count = len(self.pathSegments)
+    if l:this_count ==# 0
+        return 0
+    endif
+    let l:that_count = len(a:parent.pathSegments)
+    if l:that_count ==# 0
+        return 1
+    endif
+    if l:that_count >= l:this_count
+        return 0
+    endif
+    for i in range(0, l:that_count-1)
+        if self.pathSegments[i] !=# a:parent.pathSegments[i]
+            return 0
+        endif
+    endfor
+    return 1
+endfunction
+
+" FUNCTION: Path.JoinPathStrings(...) {{{1
+function! s:Path.JoinPathStrings(...)
+    let components = []
+    for i in a:000
+        let components = extend(components, split(i, '/'))
+    endfor
+    return '/' . join(components, '/')
+endfunction
+
+" FUNCTION: Path.equals() {{{1
+"
+" Determines whether 2 path objects are "equal".
+" They are equal if the paths they represent are the same
+"
+" Args:
+" path: the other path obj to compare this with
+function! s:Path.equals(path)
+    if nerdtree#runningWindows()
+        return self.str() ==? a:path.str()
+    else
+        return self.str() ==# a:path.str()
+    endif
+endfunction
+
+" FUNCTION: Path.New(pathStr) {{{1
+function! s:Path.New(pathStr)
+    let l:newPath = copy(self)
+
+    call l:newPath.readInfoFromDisk(s:Path.AbsolutePathFor(a:pathStr))
+
+    let l:newPath.cachedDisplayString = ''
+    let l:newPath.flagSet = g:NERDTreeFlagSet.New()
+
+    return l:newPath
+endfunction
+
+" FUNCTION: Path.Resolve() {{{1
+" Invoke the vim resolve() function and return the result
+" This is necessary because in some versions of vim resolve() removes trailing
+" slashes while in other versions it doesn't.  This always removes the trailing
+" slash
+function! s:Path.Resolve(path)
+    let tmp = resolve(a:path)
+    return tmp =~# '.\+/$' ? substitute(tmp, '/$', '', '') : tmp
+endfunction
+
+" FUNCTION: Path.readInfoFromDisk(fullpath) {{{1
+"
+"
+" Throws NERDTree.Path.InvalidArguments exception.
+function! s:Path.readInfoFromDisk(fullpath)
+    call self.extractDriveLetter(a:fullpath)
+
+    let fullpath = s:Path.WinToUnixPath(a:fullpath)
+
+    if getftype(fullpath) ==# 'fifo'
+        throw 'NERDTree.InvalidFiletypeError: Cant handle FIFO files: ' . a:fullpath
+    endif
+
+    let self.pathSegments = filter(split(fullpath, '/'), '!empty(v:val)')
+
+    let self.isReadOnly = 0
+    if isdirectory(a:fullpath)
+        let self.isDirectory = 1
+    elseif filereadable(a:fullpath)
+        let self.isDirectory = 0
+        let self.isReadOnly = filewritable(a:fullpath) ==# 0
+    else
+        throw 'NERDTree.InvalidArgumentsError: Invalid path = ' . a:fullpath
+    endif
+
+    let self.isExecutable = 0
+    if !self.isDirectory
+        let self.isExecutable = getfperm(a:fullpath) =~# 'x'
+    endif
+
+    "grab the last part of the path (minus the trailing slash)
+    let lastPathComponent = self.getLastPathComponent(0)
+
+    "get the path to the new node with the parent dir fully resolved
+    let hardPath = s:Path.Resolve(self.strTrunk()) . '/' . lastPathComponent
+
+    "if  the last part of the path is a symlink then flag it as such
+    let self.isSymLink = (s:Path.Resolve(hardPath) !=# hardPath)
+    if self.isSymLink
+        let self.symLinkDest = s:Path.Resolve(fullpath)
+
+        "if the link is a dir then slap a / on the end of its dest
+        if isdirectory(self.symLinkDest)
+
+            "we always wanna treat MS windows shortcuts as files for
+            "simplicity
+            if hardPath !~# '\.lnk$'
+
+                let self.symLinkDest = self.symLinkDest . '/'
+            endif
+        endif
+    endif
+endfunction
+
+" FUNCTION: Path.refresh(nerdtree) {{{1
+function! s:Path.refresh(nerdtree)
+    call self.readInfoFromDisk(self.str())
+    call g:NERDTreePathNotifier.NotifyListeners('refresh', self, a:nerdtree, {})
+    call self.cacheDisplayString()
+endfunction
+
+" FUNCTION: Path.refreshFlags(nerdtree) {{{1
+function! s:Path.refreshFlags(nerdtree)
+    call g:NERDTreePathNotifier.NotifyListeners('refreshFlags', self, a:nerdtree, {})
+    call self.cacheDisplayString()
+endfunction
+
+" FUNCTION: Path.rename() {{{1
+"
+" Renames this node on the filesystem
+function! s:Path.rename(newPath)
+    if a:newPath ==# ''
+        throw 'NERDTree.InvalidArgumentsError: Invalid newPath for renaming = '. a:newPath
+    endif
+
+    call s:Path.createParentDirectories(a:newPath)
+
+    let success =  rename(self.str(), a:newPath)
+    if success !=# 0
+        throw "NERDTree.PathRenameError: Could not rename: '" . self.str() . "'" . 'to:' . a:newPath
+    endif
+    call self.readInfoFromDisk(a:newPath)
+
+    for i in self.bookmarkNames()
+        let b = g:NERDTreeBookmark.BookmarkFor(i)
+        call b.setPath(copy(self))
+    endfor
+    call g:NERDTreeBookmark.Write()
+endfunction
+
+" FUNCTION: Path.str() {{{1
+" Return a string representation of this Path object.
+"
+" Args:
+" This function takes a single dictionary (optional) with keys and values that
+" specify how the returned pathname should be formatted.
+"
+" The dictionary may have the following keys:
+"  'format'
+"  'escape'
+"  'truncateTo'
+"
+" The 'format' key may have a value of:
+"  'Cd' - a string to be used with ":cd" and similar commands
+"  'Edit' - a string to be used with ":edit" and similar commands
+"  'UI' - a string to be displayed in the NERDTree user interface
+"
+" The 'escape' key, if specified, will cause the output to be escaped with
+" Vim's internal "shellescape()" function.
+"
+" The 'truncateTo' key shortens the length of the path to that given by the
+" value associated with 'truncateTo'. A '<' is prepended.
+function! s:Path.str(...)
+    let options = a:0 ? a:1 : {}
+    let toReturn = ''
+
+    if has_key(options, 'format')
+        let format = options['format']
+        if has_key(self, '_strFor' . format)
+            exec 'let toReturn = self._strFor' . format . '()'
+        else
+            throw 'NERDTree.UnknownFormatError: unknown format "'. format .'"'
+        endif
+    else
+        let toReturn = self._str()
+    endif
+
+    if nerdtree#has_opt(options, 'escape')
+        let toReturn = shellescape(toReturn)
+    endif
+
+    if has_key(options, 'truncateTo')
+        let limit = options['truncateTo']
+        if strdisplaywidth(toReturn) > limit-1
+            while strdisplaywidth(toReturn) > limit-1 && strchars(toReturn) > 0
+                let toReturn = substitute(toReturn, '^.', '', '')
+            endwhile
+            if len(split(toReturn, '/')) > 1
+                let toReturn = '</' . join(split(toReturn, '/')[1:], '/') . '/'
+            else
+                let toReturn = '<' . toReturn
+            endif
+        endif
+    endif
+
+    return toReturn
+endfunction
+
+" FUNCTION: Path._strForUI() {{{1
+function! s:Path._strForUI()
+    let toReturn = '/' . join(self.pathSegments, '/')
+    if self.isDirectory && toReturn !=# '/'
+        let toReturn  = toReturn . '/'
+    endif
+    return toReturn
+endfunction
+
+" FUNCTION: Path._strForCd() {{{1
+" Return a string representation of this Path that is suitable for use as an
+" argument to Vim's internal ":cd" command.
+function! s:Path._strForCd()
+    return fnameescape(self.str())
+endfunction
+
+" FUNCTION: Path._strForEdit() {{{1
+" Return a string representation of this Path that is suitable for use as an
+" argument to Vim's internal ":edit" command.
+function! s:Path._strForEdit()
+
+    " Make the path relative to the current working directory, if possible.
+    let l:result = fnamemodify(self.str(), ':.')
+
+    " On Windows, the drive letter may be removed by "fnamemodify()".  Add it
+    " back, if necessary.
+    if nerdtree#runningWindows() && l:result[0] == nerdtree#slash()
+        let l:result = self.drive . l:result
+    endif
+
+    let l:result = fnameescape(l:result)
+
+    if empty(l:result)
+        let l:result = '.'
+    endif
+
+    return l:result
+endfunction
+
+" FUNCTION: Path._strForGlob() {{{1
+function! s:Path._strForGlob()
+    let lead = nerdtree#slash()
+
+    "if we are running windows then slap a drive letter on the front
+    if nerdtree#runningWindows()
+        let lead = self.drive . '\'
+    endif
+
+    let toReturn = lead . join(self.pathSegments, nerdtree#slash())
+
+    if !nerdtree#runningWindows()
+        let toReturn = escape(toReturn, self._escChars())
+    endif
+    return toReturn
+endfunction
+
+" FUNCTION: Path._str() {{{1
+" Return the absolute pathname associated with this Path object.  The pathname
+" returned is appropriate for the underlying file system.
+function! s:Path._str()
+    let l:separator = nerdtree#slash()
+    let l:leader = l:separator
+
+    if nerdtree#runningWindows()
+        let l:leader = self.drive . l:separator
+    endif
+
+    return l:leader . join(self.pathSegments, l:separator)
+endfunction
+
+" FUNCTION: Path.strTrunk() {{{1
+" Gets the path without the last segment on the end.
+function! s:Path.strTrunk()
+    return self.drive . '/' . join(self.pathSegments[0:-2], '/')
+endfunction
+
+" FUNCTION: Path.tabnr() {{{1
+" return the number of the first tab that is displaying this file
+"
+" return 0 if no tab was found
+function! s:Path.tabnr()
+    let str = self.str()
+    for t in range(tabpagenr('$'))
+        for b in tabpagebuflist(t+1)
+            if str ==# expand('#' . b . ':p')
+                return t+1
+            endif
+        endfor
+    endfor
+    return 0
+endfunction
+
+" FUNCTION: Path.WinToUnixPath(pathstr){{{1
+" Takes in a windows path and returns the unix equiv
+"
+" A class level method
+"
+" Args:
+" pathstr: the windows path to convert
+function! s:Path.WinToUnixPath(pathstr)
+    if !nerdtree#runningWindows()
+        return a:pathstr
+    endif
+
+    let toReturn = a:pathstr
+
+    "remove the x:\ of the front
+    let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', '')
+
+    "remove the \\ network share from the front
+    let toReturn = substitute(toReturn, '^\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\(\\\|\/\)\?', '/', '')
+
+    "convert all \ chars to /
+    let toReturn = substitute(toReturn, '\', '/', 'g')
+
+    return toReturn
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/tree_dir_node.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/tree_dir_node.vim
new file mode 100644
index 0000000..f5f7682
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/tree_dir_node.vim
@@ -0,0 +1,706 @@
+" ============================================================================
+" CLASS: TreeDirNode
+"
+" A subclass of NERDTreeFileNode.
+"
+" The 'composite' part of the file/dir composite.
+" ============================================================================
+
+
+let s:TreeDirNode = copy(g:NERDTreeFileNode)
+let g:NERDTreeDirNode = s:TreeDirNode
+
+" FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{1
+" Class method that returns the highest cached ancestor of the current root.
+function! s:TreeDirNode.AbsoluteTreeRoot()
+    let currentNode = b:NERDTree.root
+    while currentNode.parent !=# {}
+        let currentNode = currentNode.parent
+    endwhile
+    return currentNode
+endfunction
+
+" FUNCTION: TreeDirNode.activate([options]) {{{1
+function! s:TreeDirNode.activate(...)
+    let l:options = (a:0 > 0) ? a:1 : {}
+
+    call self.toggleOpen(l:options)
+
+    " Note that we only re-render the NERDTree for this node if we did NOT
+    " create a new node and render it in a new window or tab.  In the latter
+    " case, rendering the NERDTree for this node could overwrite the text of
+    " the new NERDTree!
+    if !has_key(l:options, 'where') || empty(l:options['where'])
+        call self.getNerdtree().render()
+        call self.putCursorHere(0, 0)
+    endif
+endfunction
+
+" FUNCTION: TreeDirNode.addChild(treenode, inOrder) {{{1
+" Adds the given treenode to the list of children for this node
+"
+" Args:
+" -treenode: the node to add
+" -inOrder: 1 if the new node should be inserted in sorted order
+function! s:TreeDirNode.addChild(treenode, inOrder)
+    call add(self.children, a:treenode)
+    let a:treenode.parent = self
+
+    if a:inOrder
+        call self.sortChildren()
+    endif
+endfunction
+
+" FUNCTION: TreeDirNode.close() {{{1
+" Mark this TreeDirNode as closed.
+function! s:TreeDirNode.close()
+
+    " Close all directories in this directory node's cascade. This is
+    " necessary to ensure consistency when cascades are rendered.
+    for l:dirNode in self.getCascade()
+        let l:dirNode.isOpen = 0
+    endfor
+endfunction
+
+" FUNCTION: TreeDirNode.closeChildren() {{{1
+" Recursively close any directory nodes that are descendants of this node.
+function! s:TreeDirNode.closeChildren()
+    for l:child in self.children
+        if l:child.path.isDirectory
+            call l:child.close()
+            call l:child.closeChildren()
+        endif
+    endfor
+endfunction
+
+" FUNCTION: TreeDirNode.createChild(path, inOrder) {{{1
+" Instantiates a new child node for this node with the given path. The new
+" nodes parent is set to this node.
+"
+" Args:
+" path: a Path object that this node will represent/contain
+" inOrder: 1 if the new node should be inserted in sorted order
+"
+" Returns:
+" the newly created node
+function! s:TreeDirNode.createChild(path, inOrder)
+    let newTreeNode = g:NERDTreeFileNode.New(a:path, self.getNerdtree())
+    call self.addChild(newTreeNode, a:inOrder)
+    return newTreeNode
+endfunction
+
+" FUNCTION: TreeDirNode.displayString() {{{1
+" Assemble and return a string that can represent this TreeDirNode object in
+" the NERDTree window.
+function! s:TreeDirNode.displayString()
+    let l:result = ''
+
+    " Build a label that identifies this TreeDirNode.
+    let l:label = ''
+    let l:cascade = self.getCascade()
+    for l:dirNode in l:cascade
+        let l:next = l:dirNode.path.displayString()
+        let l:label .= l:label ==# '' ? l:next : substitute(l:next,'^.','','')
+    endfor
+
+    " Select the appropriate open/closed status indicator symbol.
+    let l:symbol = (l:cascade[-1].isOpen ? g:NERDTreeDirArrowCollapsible : g:NERDTreeDirArrowExpandable )
+    let l:symbol .= (g:NERDTreeDirArrowExpandable ==# '' ? '' : ' ')
+    let l:flags = l:cascade[-1].path.flagSet.renderToString()
+
+    return l:symbol . l:flags . l:label
+endfunction
+
+" FUNCTION: TreeDirNode.findNode(path) {{{1
+" Will find one of the children (recursively) that has the given path
+"
+" Args:
+" path: a path object
+unlet s:TreeDirNode.findNode
+function! s:TreeDirNode.findNode(path)
+    if a:path.equals(self.path)
+        return self
+    endif
+    if stridx(a:path.str(), self.path.str(), 0) ==# -1
+        return {}
+    endif
+
+    if self.path.isDirectory
+        for i in self.children
+            let retVal = i.findNode(a:path)
+            if retVal !=# {}
+                return retVal
+            endif
+        endfor
+    endif
+    return {}
+endfunction
+
+" FUNCTION: TreeDirNode.getCascade() {{{1
+" Return an array of dir nodes (starting from self) that can be cascade opened.
+function! s:TreeDirNode.getCascade()
+    if !self.isCascadable()
+        return [self]
+    endif
+
+    let vc = self.getVisibleChildren()
+    let visChild = vc[0]
+
+    return [self] + visChild.getCascade()
+endfunction
+
+" FUNCTION: TreeDirNode.getCascadeRoot() {{{1
+" Return the first directory node in the cascade in which this directory node
+" is rendered.
+function! s:TreeDirNode.getCascadeRoot()
+
+    " Don't search above the current NERDTree root node.
+    if self.isRoot()
+        return self
+    endif
+
+    let l:cascadeRoot = self
+    let l:parent = self.parent
+
+    while !empty(l:parent) && !l:parent.isRoot()
+
+        if index(l:parent.getCascade(), self) ==# -1
+            break
+        endif
+
+        let l:cascadeRoot = l:parent
+        let l:parent = l:parent.parent
+    endwhile
+
+    return l:cascadeRoot
+endfunction
+
+" FUNCTION: TreeDirNode.getChildCount() {{{1
+" Returns the number of children this node has
+function! s:TreeDirNode.getChildCount()
+    return len(self.children)
+endfunction
+
+" FUNCTION: TreeDirNode.getChild(path) {{{1
+" Returns child node of this node that has the given path or {} if no such node
+" exists.
+"
+" This function doesnt not recurse into child dir nodes
+"
+" Args:
+" path: a path object
+function! s:TreeDirNode.getChild(path)
+    if stridx(a:path.str(), self.path.str(), 0) ==# -1
+        return {}
+    endif
+
+    let index = self.getChildIndex(a:path)
+    if index ==# -1
+        return {}
+    else
+        return self.children[index]
+    endif
+
+endfunction
+
+" FUNCTION: TreeDirNode.getChildByIndex(indx, visible) {{{1
+" returns the child at the given index
+"
+" Args:
+" indx: the index to get the child from
+" visible: 1 if only the visible children array should be used, 0 if all the
+" children should be searched.
+function! s:TreeDirNode.getChildByIndex(indx, visible)
+    let array_to_search = a:visible? self.getVisibleChildren() : self.children
+    if a:indx > len(array_to_search)
+        throw 'NERDTree.InvalidArgumentsError: Index is out of bounds.'
+    endif
+    return array_to_search[a:indx]
+endfunction
+
+" FUNCTION: TreeDirNode.getChildIndex(path) {{{1
+" Returns the index of the child node of this node that has the given path or
+" -1 if no such node exists.
+"
+" This function doesnt not recurse into child dir nodes
+"
+" Args:
+" path: a path object
+function! s:TreeDirNode.getChildIndex(path)
+    if stridx(a:path.str(), self.path.str(), 0) ==# -1
+        return -1
+    endif
+
+    "do a binary search for the child
+    let a = 0
+    let z = self.getChildCount()
+    while a < z
+        let mid = (a+z)/2
+        let diff = nerdtree#compareNodePaths(a:path, self.children[mid].path)
+
+        if diff ==# -1
+            let z = mid
+        elseif diff ==# 1
+            let a = mid+1
+        else
+            return mid
+        endif
+    endwhile
+    return -1
+endfunction
+
+" FUNCTION: TreeDirNode.getDirChildren() {{{1
+" Return a list of all child nodes from 'self.children' that are of type
+" TreeDirNode. This function supports http://github.com/scrooloose/nerdtree-project-plugin.git.
+function! s:TreeDirNode.getDirChildren()
+    return filter(copy(self.children), 'v:val.path.isDirectory ==# 1')
+endfunction
+
+" FUNCTION: TreeDirNode._glob(pattern, all) {{{1
+" Return a list of strings naming the descendants of the directory in this
+" TreeDirNode object that match the specified glob pattern.
+"
+" Args:
+" pattern: (string) the glob pattern to apply
+" all: (0 or 1) if 1, include '.' and '..' if they match 'pattern'; if 0,
+"      always exclude them
+"
+" Note: If the pathnames in the result list are below the working directory,
+" they are returned as pathnames relative to that directory. This is because
+" this function, internally, attempts to obey 'wildignore' rules that use
+" relative paths.
+function! s:TreeDirNode._glob(pattern, all)
+
+    " Construct a path specification such that globpath() will return
+    " relative pathnames, if possible.
+    if self.path.str() ==# getcwd()
+        let l:pathSpec = ','
+    else
+        let l:pathSpec = escape(fnamemodify(self.path.str({'format': 'Glob'}), ':.'), ',')
+
+        " On Windows, the drive letter may be removed by "fnamemodify()".
+        if nerdtree#runningWindows() && l:pathSpec[0] == nerdtree#slash()
+            let l:pathSpec = self.path.drive . l:pathSpec
+        endif
+    endif
+
+    let l:globList = []
+
+    " See ':h version7.txt' and ':h version8.txt' for details on the
+    " development of the glob() and globpath() functions.
+    if v:version > 704 || (v:version ==# 704 && has('patch654'))
+        let l:globList = globpath(l:pathSpec, a:pattern, !g:NERDTreeRespectWildIgnore, 1, 0)
+    elseif v:version ==# 704 && has('patch279')
+        let l:globList = globpath(l:pathSpec, a:pattern, !g:NERDTreeRespectWildIgnore, 1)
+    elseif v:version > 702 || (v:version ==# 702 && has('patch051'))
+        let l:globString = globpath(l:pathSpec, a:pattern, !g:NERDTreeRespectWildIgnore)
+        let l:globList = split(l:globString, "\n")
+    else
+        let l:globString = globpath(l:pathSpec, a:pattern)
+        let l:globList = split(l:globString, "\n")
+    endif
+
+    " If a:all is false, filter '.' and '..' from the output.
+    if !a:all
+        let l:toRemove = []
+
+        for l:file in l:globList
+            let l:tail = fnamemodify(l:file, ':t')
+
+            " If l:file has a trailing slash, then its :tail will be ''. Use
+            " :h to drop the slash and the empty string after it; then use :t
+            " to get the directory name.
+            if l:tail ==# ''
+                let l:tail = fnamemodify(l:file, ':h:t')
+            endif
+
+            if l:tail ==# '.' || l:tail ==# '..'
+                call add(l:toRemove, l:file)
+                if len(l:toRemove) ==# 2
+                    break
+                endif
+            endif
+        endfor
+
+        for l:file in l:toRemove
+            call remove(l:globList, index(l:globList, l:file))
+        endfor
+    endif
+
+    return l:globList
+endfunction
+
+" FUNCTION: TreeDirNode.GetSelected() {{{1
+" Returns the current node if it is a dir node, or else returns the current
+" nodes parent
+unlet s:TreeDirNode.GetSelected
+function! s:TreeDirNode.GetSelected()
+    let currentDir = g:NERDTreeFileNode.GetSelected()
+    if currentDir !=# {} && !currentDir.isRoot()
+        if currentDir.path.isDirectory ==# 0
+            let currentDir = currentDir.parent
+        endif
+    endif
+    return currentDir
+endfunction
+
+" FUNCTION: TreeDirNode.getVisibleChildCount() {{{1
+" Returns the number of visible children this node has
+function! s:TreeDirNode.getVisibleChildCount()
+    return len(self.getVisibleChildren())
+endfunction
+
+" FUNCTION: TreeDirNode.getVisibleChildren() {{{1
+" Returns a list of children to display for this node, in the correct order
+"
+" Return:
+" an array of treenodes
+function! s:TreeDirNode.getVisibleChildren()
+    let toReturn = []
+    for i in self.children
+        if i.path.ignore(self.getNerdtree()) ==# 0
+            call add(toReturn, i)
+        endif
+    endfor
+    return toReturn
+endfunction
+
+" FUNCTION: TreeDirNode.hasVisibleChildren() {{{1
+" returns 1 if this node has any childre, 0 otherwise..
+function! s:TreeDirNode.hasVisibleChildren()
+    return self.getVisibleChildCount() !=# 0
+endfunction
+
+" FUNCTION: TreeDirNode.isCascadable() {{{1
+" true if this dir has only one visible child that is also a dir
+" false if this dir is bookmarked or symlinked. Why? Two reasons:
+"  1. If cascaded, we don't know which dir is bookmarked or is a symlink.
+"  2. If the parent is a symlink or is bookmarked, you end up with unparsable
+"     text, and NERDTree cannot get the path of any child node.
+" Also, return false if this directory is the tree root, which should never be
+" part of a cascade.
+function! s:TreeDirNode.isCascadable()
+    if g:NERDTreeCascadeSingleChildDir ==# 0
+        return 0
+    endif
+
+    if self.isRoot()
+        return 0
+    endif
+
+    if self.path.isSymLink
+        return 0
+    endif
+
+    for i in g:NERDTreeBookmark.Bookmarks()
+        if i.path.equals(self.path)
+            return 0
+        endif
+    endfor
+
+    let c = self.getVisibleChildren()
+    return len(c) ==# 1 && c[0].path.isDirectory
+endfunction
+
+" FUNCTION: TreeDirNode._initChildren() {{{1
+" Removes all childen from this node and re-reads them
+"
+" Args:
+" silent: 1 if the function should not echo any 'please wait' messages for
+" large directories
+"
+" Return: the number of child nodes read
+function! s:TreeDirNode._initChildren(silent)
+    "remove all the current child nodes
+    let self.children = []
+
+    let files = self._glob('*', 1) + self._glob('.*', 0)
+
+    if !a:silent && len(files) > g:NERDTreeNotificationThreshold
+        call nerdtree#echo('Please wait, caching a large dir ...')
+    endif
+
+    let invalidFilesFound = 0
+    for i in files
+        try
+            let path = g:NERDTreePath.New(i)
+            call self.createChild(path, 0)
+            call g:NERDTreePathNotifier.NotifyListeners('init', path, self.getNerdtree(), {})
+        catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/
+            let invalidFilesFound += 1
+        endtry
+    endfor
+
+    let g:NERDTreeOldSortOrder = g:NERDTreeSortOrder
+    call self.sortChildren()
+
+    call nerdtree#echo('')
+
+    if invalidFilesFound
+        call nerdtree#echoWarning(invalidFilesFound . ' file(s) could not be loaded into the NERD tree')
+    endif
+    return self.getChildCount()
+endfunction
+
+" FUNCTION: TreeDirNode.New(path, nerdtree) {{{1
+" Return a new TreeDirNode object with the given path and parent.
+"
+" Args:
+" path: dir that the node represents
+" nerdtree: the tree the node belongs to
+function! s:TreeDirNode.New(path, nerdtree)
+    if a:path.isDirectory !=# 1
+        throw 'NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object.'
+    endif
+
+    let newTreeNode = copy(self)
+    let newTreeNode.path = a:path
+
+    let newTreeNode.isOpen = 0
+    let newTreeNode.children = []
+
+    let newTreeNode.parent = {}
+    let newTreeNode._nerdtree = a:nerdtree
+
+    return newTreeNode
+endfunction
+
+" FUNCTION: TreeDirNode.open([options]) {{{1
+" Open this directory node in the current tree or elsewhere if special options
+" are provided. Return 0 if options were processed. Otherwise, return the
+" number of new cached nodes.
+function! s:TreeDirNode.open(...)
+    let l:options = a:0 ? a:1 : {}
+
+    " If special options were specified, process them and return.
+    if has_key(l:options, 'where') && !empty(l:options['where'])
+        let l:opener = g:NERDTreeOpener.New(self.path, l:options)
+        call l:opener.open(self)
+        return 0
+    endif
+
+    " Open any ancestors of this node that render within the same cascade.
+    let l:parent = self.parent
+    while !empty(l:parent) && !l:parent.isRoot()
+        if index(l:parent.getCascade(), self) >= 0
+            let l:parent.isOpen = 1
+            let l:parent = l:parent.parent
+        else
+            break
+        endif
+    endwhile
+
+    let self.isOpen = 1
+
+    let l:numChildrenCached = 0
+    if empty(self.children)
+        let l:numChildrenCached = self._initChildren(0)
+    endif
+
+    return l:numChildrenCached
+endfunction
+
+" FUNCTION: TreeDirNode.openAlong([opts]) {{{1
+" recursive open the dir if it has only one directory child.
+"
+" return the level of opened directories.
+function! s:TreeDirNode.openAlong(...)
+    let opts = a:0 ? a:1 : {}
+    let level = 0
+
+    let node = self
+    while node.path.isDirectory
+        call node.open(opts)
+        let level += 1
+        if node.getVisibleChildCount() ==# 1
+            let node = node.getChildByIndex(0, 1)
+        else
+            break
+        endif
+    endwhile
+    return level
+endfunction
+
+" FUNCTION: TreeDirNode.openExplorer() {{{1
+" Open an explorer window for this node in the previous window. The explorer
+" can be a NERDTree window or a netrw window.
+function! s:TreeDirNode.openExplorer()
+    execute 'wincmd p'
+    execute 'edit '.self.path.str({'format':'Edit'})
+endfunction
+
+" FUNCTION: TreeDirNode.openInNewTab(options) {{{1
+unlet s:TreeDirNode.openInNewTab
+function! s:TreeDirNode.openInNewTab(options)
+    call nerdtree#deprecated('TreeDirNode.openInNewTab', 'is deprecated, use open() instead')
+    call self.open({'where': 't'})
+endfunction
+
+" FUNCTION: TreeDirNode._openInNewTab() {{{1
+function! s:TreeDirNode._openInNewTab()
+    tabnew
+    call g:NERDTreeCreator.CreateTabTree(self.path.str())
+endfunction
+
+" FUNCTION: TreeDirNode.openRecursively() {{{1
+" Open this directory node and any descendant directory nodes whose pathnames
+" are not ignored.
+function! s:TreeDirNode.openRecursively()
+    silent call self.open()
+
+    for l:child in self.children
+        if l:child.path.isDirectory && !l:child.path.ignore(l:child.getNerdtree())
+            call l:child.openRecursively()
+        endif
+    endfor
+endfunction
+
+" FUNCTION: TreeDirNode.refresh() {{{1
+function! s:TreeDirNode.refresh()
+    call self.path.refresh(self.getNerdtree())
+
+    "if this node was ever opened, refresh its children
+    if self.isOpen || !empty(self.children)
+        let files = self._glob('*', 1) + self._glob('.*', 0)
+        let newChildNodes = []
+        let invalidFilesFound = 0
+        for i in files
+            try
+                "create a new path and see if it exists in this nodes children
+                let path = g:NERDTreePath.New(i)
+                let newNode = self.getChild(path)
+                if newNode !=# {}
+                    call newNode.refresh()
+                    call add(newChildNodes, newNode)
+
+                "the node doesnt exist so create it
+                else
+                    let newNode = g:NERDTreeFileNode.New(path, self.getNerdtree())
+                    let newNode.parent = self
+                    call add(newChildNodes, newNode)
+                endif
+            catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/
+                let invalidFilesFound = 1
+            endtry
+        endfor
+
+        "swap this nodes children out for the children we just read/refreshed
+        let self.children = newChildNodes
+        call self.sortChildren()
+
+        if invalidFilesFound
+            call nerdtree#echoWarning('some files could not be loaded into the NERD tree')
+        endif
+    endif
+endfunction
+
+" FUNCTION: TreeDirNode.refreshFlags() {{{1
+unlet s:TreeDirNode.refreshFlags
+function! s:TreeDirNode.refreshFlags()
+    call self.path.refreshFlags(self.getNerdtree())
+    for i in self.children
+        call i.refreshFlags()
+    endfor
+endfunction
+
+" FUNCTION: TreeDirNode.refreshDirFlags() {{{1
+function! s:TreeDirNode.refreshDirFlags()
+    call self.path.refreshFlags(self.getNerdtree())
+endfunction
+
+" FUNCTION: TreeDirNode.reveal(path) {{{1
+" reveal the given path, i.e. cache and open all treenodes needed to display it
+" in the UI
+" Returns the revealed node
+function! s:TreeDirNode.reveal(path, ...)
+    let opts = a:0 ? a:1 : {}
+
+    if !a:path.isUnder(self.path)
+        throw 'NERDTree.InvalidArgumentsError: ' . a:path.str() . ' should be under ' . self.path.str()
+    endif
+
+    call self.open()
+
+    if self.path.equals(a:path.getParent())
+        let n = self.findNode(a:path)
+        " We may be looking for a newly-saved file that isn't in the tree yet.
+        if n ==# {}
+            call self.refresh()
+            let n = self.findNode(a:path)
+        endif
+        if has_key(opts, 'open')
+            call n.open()
+        endif
+        return n
+    endif
+
+    let p = a:path
+    while !p.getParent().equals(self.path)
+        let p = p.getParent()
+    endwhile
+
+    let n = self.findNode(p)
+    return n.reveal(a:path, opts)
+endfunction
+
+" FUNCTION: TreeDirNode.removeChild(treenode) {{{1
+" Remove the given treenode from self.children.
+" Throws NERDTree.ChildNotFoundError if the node is not found.
+"
+" Args:
+" treenode: the node object to remove
+function! s:TreeDirNode.removeChild(treenode)
+    for i in range(0, self.getChildCount()-1)
+        if self.children[i].equals(a:treenode)
+            call remove(self.children, i)
+            return
+        endif
+    endfor
+
+    throw 'NERDTree.ChildNotFoundError: child node was not found'
+endfunction
+
+" FUNCTION: TreeDirNode.sortChildren() {{{1
+" Sort self.children by alphabetical order and directory priority.
+function! s:TreeDirNode.sortChildren()
+    if count(g:NERDTreeSortOrder, '*') < 1
+        call add(g:NERDTreeSortOrder, '*')
+    endif
+    let CompareFunc = function('nerdtree#compareNodes')
+    call sort(self.children, CompareFunc)
+    let g:NERDTreeOldSortOrder = g:NERDTreeSortOrder
+endfunction
+
+" FUNCTION: TreeDirNode.toggleOpen([options]) {{{1
+" Opens this directory if it is closed and vice versa
+function! s:TreeDirNode.toggleOpen(...)
+    let opts = a:0 ? a:1 : {}
+    if self.isOpen ==# 1
+        call self.close()
+    else
+        if g:NERDTreeCascadeOpenSingleChildDir ==# 0
+            call self.open(opts)
+        else
+            call self.openAlong(opts)
+        endif
+    endif
+endfunction
+
+" FUNCTION: TreeDirNode.transplantChild(newNode) {{{1
+" Replaces the child of this with the given node (where the child node's full
+" path matches a:newNode's fullpath). The search for the matching node is
+" non-recursive
+"
+" Arg:
+" newNode: the node to graft into the tree
+function! s:TreeDirNode.transplantChild(newNode)
+    for i in range(0, self.getChildCount()-1)
+        if self.children[i].equals(a:newNode)
+            let self.children[i] = a:newNode
+            let a:newNode.parent = self
+            break
+        endif
+    endfor
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/tree_file_node.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/tree_file_node.vim
new file mode 100644
index 0000000..957b98a
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/tree_file_node.vim
@@ -0,0 +1,349 @@
+" ============================================================================
+" CLASS: TreeFileNode
+"
+" This class is the parent of the TreeDirNode class and is the 'Component'
+" part of the composite design pattern between the NERDTree node classes.
+" ============================================================================
+
+
+let s:TreeFileNode = {}
+let g:NERDTreeFileNode = s:TreeFileNode
+
+" FUNCTION: TreeFileNode.activate(...) {{{1
+function! s:TreeFileNode.activate(...)
+    call self.open(a:0 ? a:1 : {})
+endfunction
+
+" FUNCTION: TreeFileNode.bookmark(name) {{{1
+" bookmark this node with a:name
+function! s:TreeFileNode.bookmark(name)
+
+    " if a bookmark exists with the same name and the node is cached then save
+    " it so we can update its display string
+    let oldMarkedNode = {}
+    try
+        let oldMarkedNode = g:NERDTreeBookmark.GetNodeForName(a:name, 1, self.getNerdtree())
+    catch /^NERDTree.BookmarkNotFoundError/
+    catch /^NERDTree.BookmarkedNodeNotFoundError/
+    endtry
+
+    call g:NERDTreeBookmark.AddBookmark(a:name, self.path)
+    call self.path.cacheDisplayString()
+    call g:NERDTreeBookmark.Write()
+
+    if !empty(oldMarkedNode)
+        call oldMarkedNode.path.cacheDisplayString()
+    endif
+endfunction
+
+" FUNCTION: TreeFileNode.cacheParent() {{{1
+" initializes self.parent if it isnt already
+function! s:TreeFileNode.cacheParent()
+    if empty(self.parent)
+        let parentPath = self.path.getParent()
+        if parentPath.equals(self.path)
+            throw 'NERDTree.CannotCacheParentError: already at root'
+        endif
+        let self.parent = s:TreeFileNode.New(parentPath, self.getNerdtree())
+    endif
+endfunction
+
+" FUNCTION: TreeFileNode.clearBookmarks() {{{1
+function! s:TreeFileNode.clearBookmarks()
+    for i in g:NERDTreeBookmark.Bookmarks()
+        if i.path.equals(self.path)
+            call i.delete()
+        end
+    endfor
+    call self.path.cacheDisplayString()
+endfunction
+
+" FUNCTION: TreeFileNode.copy(dest) {{{1
+function! s:TreeFileNode.copy(dest)
+    call self.path.copy(a:dest)
+    let newPath = g:NERDTreePath.New(a:dest)
+    let parent = self.getNerdtree().root.findNode(newPath.getParent())
+    if !empty(parent)
+        call parent.refresh()
+        return parent.findNode(newPath)
+    else
+        return {}
+    endif
+endfunction
+
+" FUNCTION: TreeFileNode.delete {{{1
+" Removes this node from the tree and calls the Delete method for its path obj
+function! s:TreeFileNode.delete()
+    call self.path.delete()
+    call self.parent.removeChild(self)
+endfunction
+
+" FUNCTION: TreeFileNode.displayString() {{{1
+"
+" Returns a string that specifies how the node should be represented as a
+" string
+"
+" Return:
+" a string that can be used in the view to represent this node
+function! s:TreeFileNode.displayString()
+    return self.path.flagSet.renderToString() . self.path.displayString()
+endfunction
+
+" FUNCTION: TreeFileNode.equals(treenode) {{{1
+"
+" Compares this treenode to the input treenode and returns 1 if they are the
+" same node.
+"
+" Use this method instead of ==  because sometimes when the treenodes contain
+" many children, vim seg faults when doing ==
+"
+" Args:
+" treenode: the other treenode to compare to
+function! s:TreeFileNode.equals(treenode)
+    return self.path.str() ==# a:treenode.path.str()
+endfunction
+
+" FUNCTION: TreeFileNode.findNode(path) {{{1
+" Returns self if this node.path.Equals the given path.
+" Returns {} if not equal.
+"
+" Args:
+" path: the path object to compare against
+function! s:TreeFileNode.findNode(path)
+    if a:path.equals(self.path)
+        return self
+    endif
+    return {}
+endfunction
+
+" FUNCTION: TreeFileNode.findSibling(direction) {{{1
+" Find the next or previous sibling of this node.
+"
+" Args:
+" direction: 0 for previous, 1 for next
+"
+" Return:
+" The next/previous TreeFileNode object or an empty dictionary if not found.
+function! s:TreeFileNode.findSibling(direction)
+
+    " There can be no siblings if there is no parent.
+    if empty(self.parent)
+        return {}
+    endif
+
+    let l:nodeIndex = self.parent.getChildIndex(self.path)
+
+    if l:nodeIndex == -1
+        return {}
+    endif
+
+    " Get the next index to begin the search.
+    let l:nodeIndex += a:direction ? 1 : -1
+
+    while 0 <= l:nodeIndex && l:nodeIndex < self.parent.getChildCount()
+
+        " Return the next node if it is not ignored.
+        if !self.parent.children[l:nodeIndex].path.ignore(self.getNerdtree())
+            return self.parent.children[l:nodeIndex]
+        endif
+
+        let l:nodeIndex += a:direction ? 1 : -1
+    endwhile
+
+    return {}
+endfunction
+
+" FUNCTION: TreeFileNode.getNerdtree(){{{1
+function! s:TreeFileNode.getNerdtree()
+    return self._nerdtree
+endfunction
+
+" FUNCTION: TreeFileNode.GetRootForTab(){{{1
+" get the root node for this tab
+function! s:TreeFileNode.GetRootForTab()
+    if g:NERDTree.ExistsForTab()
+        return getbufvar(t:NERDTreeBufName, 'NERDTree').root
+    end
+    return {}
+endfunction
+
+" FUNCTION: TreeFileNode.GetSelected() {{{1
+" If the cursor is currently positioned on a tree node, return the node.
+" Otherwise, return the empty dictionary.
+function! s:TreeFileNode.GetSelected()
+
+    try
+        let l:path = b:NERDTree.ui.getPath(line('.'))
+
+        if empty(l:path)
+            return {}
+        endif
+
+        return b:NERDTree.root.findNode(l:path)
+    catch
+        return {}
+    endtry
+endfunction
+
+" FUNCTION: TreeFileNode.isVisible() {{{1
+" returns 1 if this node should be visible according to the tree filters and
+" hidden file filters (and their on/off status)
+function! s:TreeFileNode.isVisible()
+    return !self.path.ignore(self.getNerdtree())
+endfunction
+
+" FUNCTION: TreeFileNode.isRoot() {{{1
+function! s:TreeFileNode.isRoot()
+    if !g:NERDTree.ExistsForBuf()
+        throw 'NERDTree.NoTreeError: No tree exists for the current buffer'
+    endif
+
+    return self.equals(self.getNerdtree().root)
+endfunction
+
+" FUNCTION: TreeFileNode.New(path, nerdtree) {{{1
+" Returns a new TreeNode object with the given path and parent
+"
+" Args:
+" path: file/dir that the node represents
+" nerdtree: the tree the node belongs to
+function! s:TreeFileNode.New(path, nerdtree)
+    if a:path.isDirectory
+        return g:NERDTreeDirNode.New(a:path, a:nerdtree)
+    else
+        let newTreeNode = copy(self)
+        let newTreeNode.path = a:path
+        let newTreeNode.parent = {}
+        let newTreeNode._nerdtree = a:nerdtree
+        return newTreeNode
+    endif
+endfunction
+
+" FUNCTION: TreeFileNode.open() {{{1
+function! s:TreeFileNode.open(...)
+    let opts = a:0 ? a:1 : {}
+    let opener = g:NERDTreeOpener.New(self.path, opts)
+    call opener.open(self)
+endfunction
+
+" FUNCTION: TreeFileNode.openSplit() {{{1
+" Open this node in a new window
+function! s:TreeFileNode.openSplit()
+    call nerdtree#deprecated('TreeFileNode.openSplit', 'is deprecated, use .open() instead.')
+    call self.open({'where': 'h'})
+endfunction
+
+" FUNCTION: TreeFileNode.openVSplit() {{{1
+" Open this node in a new vertical window
+function! s:TreeFileNode.openVSplit()
+    call nerdtree#deprecated('TreeFileNode.openVSplit', 'is deprecated, use .open() instead.')
+    call self.open({'where': 'v'})
+endfunction
+
+" FUNCTION: TreeFileNode.openInNewTab(options) {{{1
+function! s:TreeFileNode.openInNewTab(options)
+    call nerdtree#deprecated('TreeFileNode.openinNewTab', 'is deprecated, use .open() instead.')
+    call self.open(extend({'where': 't'}, a:options))
+endfunction
+
+" FUNCTION: TreeFileNode.openExplorer()
+function! s:TreeFileNode.openExplorer()
+    execute 'wincmd p'
+    execute 'edit '.self.path.getParent().str({'format':'Edit'})
+endfunction
+
+" FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{1
+" Places the cursor on the line number this node is rendered on
+"
+" Args:
+" isJump: 1 if this cursor movement should be counted as a jump by vim
+" recurseUpward: try to put the cursor on the parent if the this node isnt
+" visible
+function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
+    let ln = self.getNerdtree().ui.getLineNum(self)
+    if ln != -1
+        if a:isJump
+            mark '
+        endif
+        call cursor(ln, col('.'))
+    else
+        if a:recurseUpward
+            let node = self
+            while node != {} && self.getNerdtree().ui.getLineNum(node) ==# -1
+                let node = node.parent
+                call node.open()
+            endwhile
+            call self._nerdtree.render()
+            call node.putCursorHere(a:isJump, 0)
+        endif
+    endif
+endfunction
+
+" FUNCTION: TreeFileNode.refresh() {{{1
+function! s:TreeFileNode.refresh()
+    call self.path.refresh(self.getNerdtree())
+endfunction
+
+" FUNCTION: TreeFileNode.refreshFlags() {{{1
+function! s:TreeFileNode.refreshFlags()
+    call self.path.refreshFlags(self.getNerdtree())
+endfunction
+
+" FUNCTION: TreeFileNode.rename() {{{1
+" Calls the rename method for this nodes path obj
+function! s:TreeFileNode.rename(newName)
+    let newName = substitute(a:newName, '\(\\\|\/\)$', '', '')
+    call self.path.rename(newName)
+    call self.parent.removeChild(self)
+
+    let parentPath = self.path.getParent()
+    let newParent = self.getNerdtree().root.findNode(parentPath)
+
+    if newParent != {}
+        call newParent.createChild(self.path, 1)
+        call newParent.refresh()
+    endif
+endfunction
+
+" FUNCTION: TreeFileNode.renderToString {{{1
+" returns a string representation for this tree to be rendered in the view
+function! s:TreeFileNode.renderToString()
+    return self._renderToString(0, 0)
+endfunction
+
+" Args:
+" depth: the current depth in the tree for this call
+" drawText: 1 if we should actually draw the line for this node (if 0 then the
+" child nodes are rendered only)
+" for each depth in the tree
+function! s:TreeFileNode._renderToString(depth, drawText)
+    let output = ''
+    if a:drawText ==# 1
+
+        let treeParts = repeat('  ', a:depth - 1)
+        let treeParts .= (self.path.isDirectory || g:NERDTreeDirArrowExpandable ==# '' ? '' : '  ')
+
+        let line = treeParts . self.displayString()
+        let output = output . line . "\n"
+    endif
+
+    " if the node is an open dir, draw its children
+    if self.path.isDirectory ==# 1 && self.isOpen ==# 1
+
+        let childNodesToDraw = self.getVisibleChildren()
+
+        if self.isCascadable() && a:depth > 0
+
+            let output = output . childNodesToDraw[0]._renderToString(a:depth, 0)
+
+        elseif len(childNodesToDraw) > 0
+            for i in childNodesToDraw
+                let output = output . i._renderToString(a:depth + 1, 1)
+            endfor
+        endif
+    endif
+
+    return output
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/lib/nerdtree/ui.vim b/.vim/bundle/vim-nerdtree/lib/nerdtree/ui.vim
new file mode 100644
index 0000000..a481ba4
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/lib/nerdtree/ui.vim
@@ -0,0 +1,532 @@
+" ============================================================================
+" CLASS: UI
+" ============================================================================
+
+
+let s:UI = {}
+let g:NERDTreeUI = s:UI
+
+" FUNCTION: s:UI.centerView() {{{1
+" centers the nerd tree window around the cursor (provided the nerd tree
+" options permit)
+function! s:UI.centerView()
+    if g:NERDTreeAutoCenter
+        let current_line = winline()
+        let lines_to_top = current_line
+        let lines_to_bottom = winheight(g:NERDTree.GetWinNum()) - current_line
+        if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
+            normal! zz
+        endif
+    endif
+endfunction
+
+" FUNCTION: s:UI._dumpHelp  {{{1
+" prints out the quick help
+function! s:UI._dumpHelp()
+    if self.getShowHelp()
+        let help  = "\" NERDTree (" . nerdtree#version() . ") quickhelp~\n"
+        let help .= "\" ============================\n"
+        let help .= "\" File node mappings~\n"
+        let help .= '" '. (g:NERDTreeMouseMode ==# 3 ? 'single' : 'double') ."-click,\n"
+        if self.nerdtree.isTabTree()
+            let help .= '" '. g:NERDTreeMapActivateNode .": open in prev window\n"
+        else
+            let help .= '" '. g:NERDTreeMapActivateNode .": open in current window\n"
+        endif
+        if self.nerdtree.isTabTree()
+            let help .= '" '. g:NERDTreeMapPreview .": preview\n"
+        endif
+        let help .= '" '. g:NERDTreeMapOpenInTab.": open in new tab\n"
+        let help .= '" '. g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
+        let help .= "\" middle-click,\n"
+        let help .= '" '. g:NERDTreeMapOpenSplit .": open split\n"
+        let help .= '" '. g:NERDTreeMapPreviewSplit .": preview split\n"
+        let help .= '" '. g:NERDTreeMapOpenVSplit .": open vsplit\n"
+        let help .= '" '. g:NERDTreeMapPreviewVSplit .": preview vsplit\n"
+        let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
+
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Directory node mappings~\n"
+        let help .= '" '. (g:NERDTreeMouseMode ==# 1 ? 'double' : 'single') ."-click,\n"
+        let help .= '" '. g:NERDTreeMapActivateNode .": open & close node\n"
+        let help .= '" '. g:NERDTreeMapOpenRecursively .": recursively open node\n"
+        let help .= '" '. g:NERDTreeMapOpenInTab.": open in new tab\n"
+        let help .= '" '. g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
+        let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
+        let help .= '" '. g:NERDTreeMapCloseDir .": close parent of node\n"
+        let help .= '" '. g:NERDTreeMapCloseChildren .": close all child nodes of\n"
+        let help .= "\"    current node recursively\n"
+        let help .= "\" middle-click,\n"
+        let help .= '" '. g:NERDTreeMapOpenExpl.": explore selected dir\n"
+
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Bookmark table mappings~\n"
+        let help .= "\" double-click,\n"
+        let help .= '" '. g:NERDTreeMapActivateNode .": open bookmark\n"
+        let help .= '" '. g:NERDTreeMapPreview .": preview file\n"
+        let help .= '" '. g:NERDTreeMapPreview .": find dir in tree\n"
+        let help .= '" '. g:NERDTreeMapOpenInTab.": open in new tab\n"
+        let help .= '" '. g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
+        let help .= '" '. g:NERDTreeMapOpenSplit .": open split\n"
+        let help .= '" '. g:NERDTreeMapPreviewSplit .": preview split\n"
+        let help .= '" '. g:NERDTreeMapOpenVSplit .": open vsplit\n"
+        let help .= '" '. g:NERDTreeMapPreviewVSplit .": preview vsplit\n"
+        let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
+        let help .= '" '. g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
+
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Tree navigation mappings~\n"
+        let help .= '" '. g:NERDTreeMapJumpRoot .": go to root\n"
+        let help .= '" '. g:NERDTreeMapJumpParent .": go to parent\n"
+        let help .= '" '. g:NERDTreeMapJumpFirstChild  .": go to first child\n"
+        let help .= '" '. g:NERDTreeMapJumpLastChild   .": go to last child\n"
+        let help .= '" '. g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
+        let help .= '" '. g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
+
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Filesystem mappings~\n"
+        let help .= '" '. g:NERDTreeMapChangeRoot .": change tree root to the\n"
+        let help .= "\"    selected dir\n"
+        let help .= '" '. g:NERDTreeMapUpdir .": move tree root up a dir\n"
+        let help .= '" '. g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
+        let help .= "\"    but leave old root open\n"
+        let help .= '" '. g:NERDTreeMapRefresh .": refresh cursor dir\n"
+        let help .= '" '. g:NERDTreeMapRefreshRoot .": refresh current root\n"
+        let help .= '" '. g:NERDTreeMapMenu .": Show menu\n"
+        let help .= '" '. g:NERDTreeMapChdir .":change the CWD to the\n"
+        let help .= "\"    selected dir\n"
+        let help .= '" '. g:NERDTreeMapCWD .":change tree root to CWD\n"
+
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Tree filtering mappings~\n"
+        let help .= '" '. g:NERDTreeMapToggleHidden .': hidden files (' . (self.getShowHidden() ? 'on' : 'off') . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleFilters .': file filters (' . (self.isIgnoreFilterEnabled() ? 'on' : 'off') . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleFiles .': files (' . (self.getShowFiles() ? 'on' : 'off') . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleBookmarks .': bookmarks (' . (self.getShowBookmarks() ? 'on' : 'off') . ")\n"
+
+        " add quickhelp entries for each custom key map
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Custom mappings~\n"
+        for i in g:NERDTreeKeyMap.All()
+            if !empty(i.quickhelpText)
+                let help .= '" '. i.key .': '. i.quickhelpText ."\n"
+            endif
+        endfor
+
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Other mappings~\n"
+        let help .= '" '. g:NERDTreeMapQuit .": Close the NERDTree window\n"
+        let help .= '" '. g:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n"
+        let help .= "\"    the NERDTree window\n"
+        let help .= '" '. g:NERDTreeMapHelp .": toggle help\n"
+        let help .= "\"\n\" ----------------------------\n"
+        let help .= "\" Bookmark commands~\n"
+        let help .= "\" :Bookmark [<name>]\n"
+        let help .= "\" :BookmarkToRoot <name>\n"
+        let help .= "\" :RevealBookmark <name>\n"
+        let help .= "\" :OpenBookmark <name>\n"
+        let help .= "\" :ClearBookmarks [<names>]\n"
+        let help .= "\" :ClearAllBookmarks\n"
+        let help .= "\" :ReadBookmarks\n"
+        let help .= "\" :WriteBookmarks\n"
+        let help .= "\" :EditBookmarks\n"
+        silent! put =help
+    elseif !self.isMinimal()
+        let help ='" Press '. g:NERDTreeMapHelp ." for help\n"
+        silent! put =help
+    endif
+endfunction
+
+
+" FUNCTION: s:UI.new(nerdtree) {{{1
+function! s:UI.New(nerdtree)
+    let newObj = copy(self)
+    let newObj.nerdtree = a:nerdtree
+    let newObj._showHelp = 0
+    let newObj._ignoreEnabled = 1
+    let newObj._showFiles = g:NERDTreeShowFiles
+    let newObj._showHidden = g:NERDTreeShowHidden
+    let newObj._showBookmarks = g:NERDTreeShowBookmarks
+
+    return newObj
+endfunction
+
+" FUNCTION: s:UI.getPath(ln) {{{1
+" Return the Path object for the node that is rendered on the given line
+" number.  If the 'up a dir' line is selected, return the Path object for
+" the parent of the root.  Return the empty dictionary if the given line
+" does not reference a tree node.
+function! s:UI.getPath(ln)
+    let line = getline(a:ln)
+
+    let rootLine = self.getRootLineNum()
+
+    if a:ln ==# rootLine
+        return self.nerdtree.root.path
+    endif
+
+    if line ==# s:UI.UpDirLine()
+        return self.nerdtree.root.path.getParent()
+    endif
+
+    if a:ln < rootLine
+        return {}
+    endif
+
+    let indent = self._indentLevelFor(line)
+
+    " remove the tree parts and the leading space
+    let curFile = self._stripMarkup(line)
+
+    let dir = ''
+    let lnum = a:ln
+    while lnum > 0
+        let lnum = lnum - 1
+        let curLine = getline(lnum)
+        let curLineStripped = self._stripMarkup(curLine)
+
+        " have we reached the top of the tree?
+        if lnum ==# rootLine
+            let dir = self.nerdtree.root.path.str({'format': 'UI'}) . dir
+            break
+        endif
+        if curLineStripped =~# '/$'
+            let lpindent = self._indentLevelFor(curLine)
+            if lpindent < indent
+                let indent = indent - 1
+
+                let dir = substitute (curLineStripped,'^\\', '', '') . dir
+                continue
+            endif
+        endif
+    endwhile
+    let curFile = self.nerdtree.root.path.drive . dir . curFile
+    let toReturn = g:NERDTreePath.New(curFile)
+    return toReturn
+endfunction
+
+" FUNCTION: s:UI.getLineNum(node) {{{1
+" Return the line number where the given node is rendered.  Return -1 if the
+" given node is not visible.
+function! s:UI.getLineNum(node)
+
+    if a:node.isRoot()
+        return self.getRootLineNum()
+    endif
+
+    let l:pathComponents = [substitute(self.nerdtree.root.path.str({'format': 'UI'}), '/\s*$', '', '')]
+    let l:currentPathComponent = 1
+
+    let l:fullPath = a:node.path.str({'format': 'UI'})
+
+    for l:lineNumber in range(self.getRootLineNum() + 1, line('$'))
+        let l:currentLine = getline(l:lineNumber)
+        let l:indentLevel = self._indentLevelFor(l:currentLine)
+
+        if l:indentLevel !=# l:currentPathComponent
+            continue
+        endif
+
+        let l:currentLine = self._stripMarkup(l:currentLine)
+        let l:currentPath =  join(l:pathComponents, '/') . '/' . l:currentLine
+
+        " Directories: If the current path 'starts with' the full path, then
+        " either the paths are equal or the line is a cascade containing the
+        " full path.
+        if l:fullPath[-1:] ==# '/' && stridx(l:currentPath, l:fullPath) ==# 0
+            return l:lineNumber
+        endif
+
+        " Files: The paths must exactly match.
+        if l:fullPath ==# l:currentPath
+            return l:lineNumber
+        endif
+
+        " Otherwise: If the full path starts with the current path and the
+        " current path is a directory, we add a new path component.
+        if stridx(l:fullPath, l:currentPath) ==# 0 && l:currentPath[-1:] ==# '/'
+            let l:currentLine = substitute(l:currentLine, '/\s*$', '', '')
+            call add(l:pathComponents, l:currentLine)
+            let l:currentPathComponent += 1
+        endif
+    endfor
+
+    return -1
+endfunction
+
+" FUNCTION: s:UI.getRootLineNum(){{{1
+" gets the line number of the root node
+function! s:UI.getRootLineNum()
+    let rootLine = 1
+    while rootLine <= line('$') && getline(rootLine) !~# '^\(/\|<\)'
+        let rootLine = rootLine + 1
+    endwhile
+    return rootLine
+endfunction
+
+" FUNCTION: s:UI.getShowBookmarks() {{{1
+function! s:UI.getShowBookmarks()
+    return self._showBookmarks
+endfunction
+
+" FUNCTION: s:UI.getShowFiles() {{{1
+function! s:UI.getShowFiles()
+    return self._showFiles
+endfunction
+
+" FUNCTION: s:UI.getShowHelp() {{{1
+function! s:UI.getShowHelp()
+    return self._showHelp
+endfunction
+
+" FUNCTION: s:UI.getShowHidden() {{{1
+function! s:UI.getShowHidden()
+    return self._showHidden
+endfunction
+
+" FUNCTION: s:UI._indentLevelFor(line) {{{1
+function! s:UI._indentLevelFor(line)
+    " Replace multi-character DirArrows with a single space so the
+    " indentation calculation doesn't get messed up.
+    if g:NERDTreeDirArrowExpandable ==# ''
+        let l:line = '  '.a:line
+    else
+        let l:line = substitute(substitute(a:line, '\V'.g:NERDTreeDirArrowExpandable, ' ', ''), '\V'.g:NERDTreeDirArrowCollapsible, ' ', '')
+    endif
+    let leadChars = match(l:line, '\M\[^ ]')
+    return leadChars / s:UI.IndentWid()
+endfunction
+
+" FUNCTION: s:UI.IndentWid() {{{1
+function! s:UI.IndentWid()
+    return 2
+endfunction
+
+" FUNCTION: s:UI.isIgnoreFilterEnabled() {{{1
+function! s:UI.isIgnoreFilterEnabled()
+    return self._ignoreEnabled ==# 1
+endfunction
+
+" FUNCTION: s:UI.isMinimal() {{{1
+function! s:UI.isMinimal()
+    return g:NERDTreeMinimalUI
+endfunction
+
+" FUNCTION: s:UI.MarkupReg() {{{1
+function! s:UI.MarkupReg()
+    return '^ *['.g:NERDTreeDirArrowExpandable.g:NERDTreeDirArrowCollapsible.']\? '
+endfunction
+
+" FUNCTION: s:UI._renderBookmarks {{{1
+function! s:UI._renderBookmarks()
+
+    if !self.isMinimal()
+        call setline(line('.')+1, '>----------Bookmarks----------')
+        call cursor(line('.')+1, col('.'))
+    endif
+
+    if g:NERDTreeBookmarksSort ==# 1 || g:NERDTreeBookmarksSort ==# 2
+        call g:NERDTreeBookmark.SortBookmarksList()
+    endif
+
+    for i in g:NERDTreeBookmark.Bookmarks()
+        call setline(line('.')+1, i.str())
+        call cursor(line('.')+1, col('.'))
+    endfor
+
+    call setline(line('.')+1, '')
+    call cursor(line('.')+1, col('.'))
+endfunction
+
+" FUNCTION: s:UI.restoreScreenState() {{{1
+"
+" Sets the screen state back to what it was when nerdtree#saveScreenState was last
+" called.
+"
+" Assumes the cursor is in the NERDTree window
+function! s:UI.restoreScreenState()
+    if !has_key(self, '_screenState')
+        return
+    endif
+    call nerdtree#exec('silent vertical resize ' . self._screenState['oldWindowSize'], 1)
+
+    let old_scrolloff=&scrolloff
+    let &scrolloff=0
+    call cursor(self._screenState['oldTopLine'], 0)
+    normal! zt
+    call setpos('.', self._screenState['oldPos'])
+    let &scrolloff=old_scrolloff
+endfunction
+
+" FUNCTION: s:UI.saveScreenState() {{{1
+" Saves the current cursor position in the current buffer and the window
+" scroll position
+function! s:UI.saveScreenState()
+    let win = winnr()
+    let self._screenState = {}
+    try
+        call g:NERDTree.CursorToTreeWin()
+        let self._screenState['oldPos'] = getpos('.')
+        let self._screenState['oldTopLine'] = line('w0')
+        let self._screenState['oldWindowSize'] = winnr('$')==1 ? g:NERDTreeWinSize : winwidth('')
+        call nerdtree#exec(win . 'wincmd w', 1)
+    catch
+    endtry
+endfunction
+
+" FUNCTION: s:UI.setShowHidden(val) {{{1
+function! s:UI.setShowHidden(val)
+    let self._showHidden = a:val
+endfunction
+
+" FUNCTION: s:UI._stripMarkup(line){{{1
+" find the filename in the given line, and return it.
+"
+" Args:
+" line: the subject line
+function! s:UI._stripMarkup(line)
+    let l:line = substitute(a:line, '^.\{-}' . g:NERDTreeNodeDelimiter, '', '')
+    return substitute(l:line, g:NERDTreeNodeDelimiter.'.*$', '', '')
+endfunction
+
+" FUNCTION: s:UI.render() {{{1
+function! s:UI.render()
+    setlocal noreadonly modifiable
+
+    " remember the top line of the buffer and the current line so we can
+    " restore the view exactly how it was
+    let curLine = line('.')
+    let curCol = col('.')
+    let topLine = line('w0')
+
+    " delete all lines in the buffer (being careful not to clobber a register)
+    silent 1,$delete _
+
+    call self._dumpHelp()
+
+    " delete the blank line before the help and add one after it
+    if !self.isMinimal()
+        call setline(line('.')+1, '')
+        call cursor(line('.')+1, col('.'))
+    endif
+
+    if self.getShowBookmarks()
+        call self._renderBookmarks()
+    endif
+
+    " add the 'up a dir' line
+    if !self.isMinimal()
+        call setline(line('.')+1, s:UI.UpDirLine())
+        call cursor(line('.')+1, col('.'))
+    endif
+
+    " draw the header line
+    let header = self.nerdtree.root.path.str({'format': 'UI', 'truncateTo': winwidth(0)})
+    call setline(line('.')+1, header)
+    call cursor(line('.')+1, col('.'))
+
+    " draw the tree
+    silent put =self.nerdtree.root.renderToString()
+
+    " delete the blank line at the top of the buffer
+    silent 1,1delete _
+
+    " restore the view
+    let old_scrolloff=&scrolloff
+    let &scrolloff=0
+    call cursor(topLine, 1)
+    normal! zt
+    call cursor(curLine, curCol)
+    let &scrolloff = old_scrolloff
+
+    setlocal readonly nomodifiable
+endfunction
+
+
+" FUNCTION: UI.renderViewSavingPosition {{{1
+" Renders the tree and ensures the cursor stays on the current node or the
+" current nodes parent if it is no longer available upon re-rendering
+function! s:UI.renderViewSavingPosition()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+
+    " go up the tree till we find a node that will be visible or till we run
+    " out of nodes
+    while currentNode !=# {} && !currentNode.isVisible() && !currentNode.isRoot()
+        let currentNode = currentNode.parent
+    endwhile
+
+    call self.render()
+
+    if currentNode !=# {}
+        call currentNode.putCursorHere(0, 0)
+    endif
+endfunction
+
+" FUNCTION: s:UI.toggleHelp() {{{1
+function! s:UI.toggleHelp()
+    let self._showHelp = !self._showHelp
+endfunction
+
+" FUNCTION: s:UI.toggleIgnoreFilter() {{{1
+" toggles the use of the NERDTreeIgnore option
+function! s:UI.toggleIgnoreFilter()
+    let self._ignoreEnabled = !self._ignoreEnabled
+    call self.renderViewSavingPosition()
+    call self.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleShowBookmarks() {{{1
+" Toggle the visibility of the Bookmark table.
+function! s:UI.toggleShowBookmarks()
+    let self._showBookmarks = !self._showBookmarks
+
+    if self.getShowBookmarks()
+        call self.nerdtree.render()
+        call g:NERDTree.CursorToBookmarkTable()
+    else
+
+        if empty(g:NERDTreeFileNode.GetSelected())
+            call b:NERDTree.root.putCursorHere(0, 0)
+            normal! 0
+        endif
+
+        call self.renderViewSavingPosition()
+    endif
+
+    call self.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleShowFiles() {{{1
+" toggles the display of hidden files
+function! s:UI.toggleShowFiles()
+    let self._showFiles = !self._showFiles
+    call self.renderViewSavingPosition()
+    call self.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleShowHidden() {{{1
+" toggles the display of hidden files
+function! s:UI.toggleShowHidden()
+    let self._showHidden = !self._showHidden
+    call self.renderViewSavingPosition()
+    call self.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleZoom() {{{1
+" zoom (maximize/minimize) the NERDTree window
+function! s:UI.toggleZoom()
+    if exists('b:NERDTreeZoomed') && b:NERDTreeZoomed
+        call nerdtree#exec('silent vertical resize '. g:NERDTreeWinSize, 1)
+        let b:NERDTreeZoomed = 0
+    else
+        call nerdtree#exec('vertical resize '. get(g:, 'NERDTreeWinSizeMax', ''), 1)
+        let b:NERDTreeZoomed = 1
+    endif
+endfunction
+
+" FUNCTION: s:UI.UpDirLine() {{{1
+function! s:UI.UpDirLine()
+    return '.. (up a dir)'
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/nerdtree_plugin/exec_menuitem.vim b/.vim/bundle/vim-nerdtree/nerdtree_plugin/exec_menuitem.vim
new file mode 100644
index 0000000..fb6c486
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/nerdtree_plugin/exec_menuitem.vim
@@ -0,0 +1,40 @@
+" ============================================================================
+" File:        exec_menuitem.vim
+" Description: plugin for NERD Tree that provides an execute file menu item
+" Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+" License:     This program is free software. It comes without any warranty,
+"              to the extent permitted by applicable law. You can redistribute
+"              it and/or modify it under the terms of the Do What The Fuck You
+"              Want To Public License, Version 2, as published by Sam Hocevar.
+"              See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" ============================================================================
+if exists('g:loaded_nerdtree_exec_menuitem')
+    finish
+endif
+let g:loaded_nerdtree_exec_menuitem = 1
+
+call NERDTreeAddMenuItem({
+            \ 'text': '(!)Execute file',
+            \ 'shortcut': '!',
+            \ 'callback': 'NERDTreeExecFile',
+            \ 'isActiveCallback': 'NERDTreeExecFileActive' })
+
+function! NERDTreeExecFileActive()
+    let node = g:NERDTreeFileNode.GetSelected()
+    return !node.path.isDirectory && node.path.isExecutable
+endfunction
+
+function! NERDTreeExecFile()
+    let treenode = g:NERDTreeFileNode.GetSelected()
+    echo "==========================================================\n"
+    echo "Complete the command to execute (add arguments etc):\n"
+    let cmd = treenode.path.str({'escape': 1})
+    let cmd = input(':!', cmd . ' ')
+
+    if cmd !=# ''
+        exec ':!' . cmd
+    else
+        echo 'Aborted'
+    endif
+endfunction
diff --git a/.vim/bundle/vim-nerdtree/nerdtree_plugin/fs_menu.vim b/.vim/bundle/vim-nerdtree/nerdtree_plugin/fs_menu.vim
new file mode 100644
index 0000000..05bee60
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/nerdtree_plugin/fs_menu.vim
@@ -0,0 +1,484 @@
+" ============================================================================
+" File:        fs_menu.vim
+" Description: plugin for the NERD Tree that provides a file system menu
+" Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+" License:     This program is free software. It comes without any warranty,
+"              to the extent permitted by applicable law. You can redistribute
+"              it and/or modify it under the terms of the Do What The Fuck You
+"              Want To Public License, Version 2, as published by Sam Hocevar.
+"              See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" ============================================================================
+if exists('g:loaded_nerdtree_fs_menu')
+    finish
+endif
+let g:loaded_nerdtree_fs_menu = 1
+
+"Automatically delete the buffer after deleting or renaming a file
+if !exists('g:NERDTreeAutoDeleteBuffer')
+    let g:NERDTreeAutoDeleteBuffer = 0
+endif
+
+call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'})
+call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
+call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
+
+if has('gui_mac') || has('gui_macvim') || has('mac')
+    call NERDTreeAddMenuItem({'text': '(r)eveal in Finder the current node', 'shortcut': 'r', 'callback': 'NERDTreeRevealInFinder'})
+    call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'})
+    call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'})
+endif
+
+if executable('xdg-open')
+    call NERDTreeAddMenuItem({'text': '(r)eveal the current node in file manager', 'shortcut': 'r', 'callback': 'NERDTreeRevealFileLinux'})
+    call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFileLinux'})
+endif
+
+if nerdtree#runningWindows()
+    call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFileWindows'})
+endif
+
+if g:NERDTreePath.CopyingSupported()
+    call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
+endif
+call NERDTreeAddMenuItem({'text': (has('clipboard')?'copy (p)ath to clipboard':'print (p)ath to screen'), 'shortcut': 'p', 'callback': 'NERDTreeCopyPath'})
+
+if has('unix') || has('osx')
+    call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNode'})
+else
+    call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNodeWin32'})
+endif
+
+if exists('*system')
+    call NERDTreeAddMenuItem({'text': 'Run (s)ystem command in this directory', 'shortcut':'s', 'callback': 'NERDTreeSystemCommand'})
+endif
+
+"FUNCTION: s:inputPrompt(action){{{1
+"returns the string that should be prompted to the user for the given action
+"
+"Args:
+"action: the action that is being performed, e.g. 'delete'
+function! s:inputPrompt(action)
+    if a:action ==# 'add'
+        let title = 'Add a childnode'
+        let info = "Enter the dir/file name to be created. Dirs end with a '/'"
+        let minimal = 'Add node:'
+
+    elseif a:action ==# 'copy'
+        let title = 'Copy the current node'
+        let info = 'Enter the new path to copy the node to:'
+        let minimal = 'Copy to:'
+
+    elseif a:action ==# 'delete'
+        let title = 'Delete the current node'
+        let info = 'Are you sure you wish to delete the node:'
+        let minimal = 'Delete?'
+
+    elseif a:action ==# 'deleteNonEmpty'
+        let title = 'Delete the current node'
+        let info =  "STOP! Directory is not empty! To delete, type 'yes'"
+        let minimal = 'Delete directory?'
+
+    elseif a:action ==# 'move'
+        let title = 'Rename the current node'
+        let info = 'Enter the new path for the node:'
+        let minimal = 'Move to:'
+    endif
+
+    if g:NERDTreeMenuController.isMinimal()
+        redraw! " Clear the menu
+        return minimal . ' '
+    else
+        let divider = '=========================================================='
+        return title . "\n" . divider . "\n" . info . "\n"
+    end
+endfunction
+
+"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1
+"prints out the given msg and, if the user responds by pushing 'y' then the
+"buffer with the given bufnum is deleted
+"
+"Args:
+"bufnum: the buffer that may be deleted
+"msg: a message that will be echoed to the user asking them if they wish to
+"     del the buffer
+function! s:promptToDelBuffer(bufnum, msg)
+    echo a:msg
+    if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y'
+        " 1. ensure that all windows which display the just deleted filename
+        " now display an empty buffer (so a layout is preserved).
+        " Is not it better to close single tabs with this file only ?
+        let s:originalTabNumber = tabpagenr()
+        let s:originalWindowNumber = winnr()
+        " Go to the next buffer in buffer list if at least one extra buffer is listed
+        " Otherwise open a new empty buffer
+        if v:version >= 800
+            let l:listedBufferCount = len(getbufinfo({'buflisted':1}))
+        elseif v:version >= 702
+            let l:listedBufferCount = len(filter(range(1, bufnr('$')), 'buflisted(v:val)'))
+        else
+            " Ignore buffer count in this case to make sure we keep the old
+            " behavior
+            let l:listedBufferCount = 0
+        endif
+        if l:listedBufferCount > 1
+            call nerdtree#exec('tabdo windo if winbufnr(0) ==# ' . a:bufnum . " | exec ':bnext! ' | endif", 1)
+        else
+            call nerdtree#exec('tabdo windo if winbufnr(0) ==# ' . a:bufnum . " | exec ':enew! ' | endif", 1)
+        endif
+        call nerdtree#exec('tabnext ' . s:originalTabNumber, 1)
+        call nerdtree#exec(s:originalWindowNumber . 'wincmd w', 1)
+        " 3. We don't need a previous buffer anymore
+        call nerdtree#exec('bwipeout! ' . a:bufnum, 0)
+    endif
+endfunction
+
+"FUNCTION: s:renameBuffer(bufNum, newNodeName, isDirectory){{{1
+"The buffer with the given bufNum is replaced with a new one
+"
+"Args:
+"bufNum: the buffer that may be deleted
+"newNodeName: the name given to the renamed node
+"isDirectory: determines how to do the create the new filenames
+function! s:renameBuffer(bufNum, newNodeName, isDirectory)
+    if a:isDirectory
+        let quotedFileName = fnameescape(a:newNodeName . '/' . fnamemodify(bufname(a:bufNum),':t'))
+        let editStr = g:NERDTreePath.New(a:newNodeName . '/' . fnamemodify(bufname(a:bufNum),':t')).str({'format': 'Edit'})
+    else
+        let quotedFileName = fnameescape(a:newNodeName)
+        let editStr = g:NERDTreePath.New(a:newNodeName).str({'format': 'Edit'})
+    endif
+    " 1. ensure that a new buffer is loaded
+    call nerdtree#exec('badd ' . quotedFileName, 0)
+    " 2. ensure that all windows which display the just deleted filename
+    " display a buffer for a new filename.
+    let s:originalTabNumber = tabpagenr()
+    let s:originalWindowNumber = winnr()
+    call nerdtree#exec('tabdo windo if winbufnr(0) ==# ' . a:bufNum . " | exec ':e! " . editStr . "' | endif", 0)
+    call nerdtree#exec('tabnext ' . s:originalTabNumber, 1)
+    call nerdtree#exec(s:originalWindowNumber . 'wincmd w', 1)
+    " 3. We don't need a previous buffer anymore
+    try
+        call nerdtree#exec('confirm bwipeout ' . a:bufNum, 0)
+    catch
+        " This happens when answering Cancel if confirmation is needed. Do nothing.
+    endtry
+endfunction
+
+"FUNCTION: NERDTreeAddNode(){{{1
+function! NERDTreeAddNode()
+    let curDirNode = g:NERDTreeDirNode.GetSelected()
+    let prompt = s:inputPrompt('add')
+    let newNodeName = substitute(input(prompt, curDirNode.path.str() . nerdtree#slash(), 'file'), '\(^\s*\|\s*$\)', '', 'g')
+
+    if newNodeName ==# ''
+        call nerdtree#echo('Node Creation Aborted.')
+        return
+    endif
+
+    try
+        let newPath = g:NERDTreePath.Create(newNodeName)
+        let parentNode = b:NERDTree.root.findNode(newPath.getParent())
+
+        let newTreeNode = g:NERDTreeFileNode.New(newPath, b:NERDTree)
+        " Emptying g:NERDTreeOldSortOrder forces the sort to
+        " recalculate the cached sortKey so nodes sort correctly.
+        let g:NERDTreeOldSortOrder = []
+        if empty(parentNode)
+            call b:NERDTree.root.refresh()
+            call b:NERDTree.render()
+        elseif parentNode.isOpen || !empty(parentNode.children)
+            call parentNode.addChild(newTreeNode, 1)
+            call NERDTreeRender()
+            call newTreeNode.putCursorHere(1, 0)
+        endif
+
+        redraw!
+    catch /^NERDTree/
+        call nerdtree#echoWarning('Node Not Created.')
+    endtry
+endfunction
+
+"FUNCTION: NERDTreeMoveNode(){{{1
+function! NERDTreeMoveNode()
+    let curNode = g:NERDTreeFileNode.GetSelected()
+    let prompt = s:inputPrompt('move')
+    let newNodePath = input(prompt, curNode.path.str(), 'file')
+    while filereadable(newNodePath)
+        call nerdtree#echoWarning('This destination already exists. Try again.')
+        let newNodePath = substitute(input(prompt, curNode.path.str(), 'file'), '\(^\s*\|\s*$\)', '', 'g')
+    endwhile
+
+
+    if newNodePath ==# ''
+        call nerdtree#echo('Node Renaming Aborted.')
+        return
+    endif
+
+    try
+        if curNode.path.isDirectory
+            let l:curPath = escape(curNode.path.str(),'\') . (nerdtree#runningWindows()?'\\':'/') . '.*'
+            let l:openBuffers = filter(range(1,bufnr('$')),'bufexists(v:val) && fnamemodify(bufname(v:val),":p") =~# "'.escape(l:curPath,'\').'"')
+        else
+            let l:openBuffers = filter(range(1,bufnr('$')),'bufexists(v:val) && fnamemodify(bufname(v:val),":p") ==# curNode.path.str()')
+        endif
+
+        call curNode.rename(newNodePath)
+        " Emptying g:NERDTreeOldSortOrder forces the sort to
+        " recalculate the cached sortKey so nodes sort correctly.
+        let g:NERDTreeOldSortOrder = []
+        call b:NERDTree.root.refresh()
+        call NERDTreeRender()
+
+        " If the file node is open, or files under the directory node are
+        " open, ask the user if they want to replace the file(s) with the
+        " renamed files.
+        if !empty(l:openBuffers)
+            if curNode.path.isDirectory
+                echo "\nDirectory renamed.\n\nFiles with the old directory name are open in buffers " . join(l:openBuffers, ', ') . '. Replace these buffers with the new files? (yN)'
+            else
+                echo "\nFile renamed.\n\nThe old file is open in buffer " . l:openBuffers[0] . '. Replace this buffer with the new file? (yN)'
+            endif
+            if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y'
+                for bufNum in l:openBuffers
+                    call s:renameBuffer(bufNum, newNodePath, curNode.path.isDirectory)
+                endfor
+            endif
+        endif
+
+        call curNode.putCursorHere(1, 0)
+
+        redraw!
+    catch /^NERDTree/
+        call nerdtree#echoWarning('Node Not Renamed.')
+    endtry
+endfunction
+
+" FUNCTION: NERDTreeDeleteNode() {{{1
+function! NERDTreeDeleteNode()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    let confirmed = 0
+
+    if currentNode.path.isDirectory && ((currentNode.isOpen && currentNode.getChildCount() > 0) ||
+                                      \ (len(currentNode._glob('*', 1)) > 0))
+        let prompt = s:inputPrompt('deleteNonEmpty') . currentNode.path.str() . ': '
+        let choice = input(prompt)
+        let confirmed = choice ==# 'yes'
+    else
+        let prompt = s:inputPrompt('delete') . currentNode.path.str() . ' (yN): '
+        echo prompt
+        let choice = nr2char(getchar())
+        let confirmed = choice ==# 'y'
+    endif
+
+    if confirmed
+        try
+            call currentNode.delete()
+            call NERDTreeRender()
+
+            "if the node is open in a buffer, ask the user if they want to
+            "close that buffer
+            let bufnum = bufnr('^'.currentNode.path.str().'$')
+            if buflisted(bufnum)
+                let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? ' (hidden)' : '') .'. Delete this buffer? (yN)'
+                call s:promptToDelBuffer(bufnum, prompt)
+            endif
+
+            redraw!
+        catch /^NERDTree/
+            call nerdtree#echoWarning('Could not remove node')
+        endtry
+    else
+        call nerdtree#echo('delete aborted')
+    endif
+endfunction
+
+" FUNCTION: NERDTreeListNode() {{{1
+function! NERDTreeListNode()
+    let treenode = g:NERDTreeFileNode.GetSelected()
+    if !empty(treenode)
+        let s:uname = system('uname')
+        let stat_cmd = 'stat -c "%s" '
+
+        if s:uname =~? 'Darwin'
+            let stat_cmd = 'stat -f "%z" '
+        endif
+
+        let cmd = 'size=$(' . stat_cmd . shellescape(treenode.path.str()) . ') && ' .
+        \         'size_with_commas=$(echo $size | sed -e :a -e "s/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta") && ' .
+        \         'ls -ld ' . shellescape(treenode.path.str()) . ' | sed -e "s/ $size / $size_with_commas /"'
+
+        let metadata = split(system(cmd),'\n')
+        call nerdtree#echo(metadata[0])
+    else
+        call nerdtree#echo('No information available')
+    endif
+endfunction
+
+" FUNCTION: NERDTreeListNodeWin32() {{{1
+function! NERDTreeListNodeWin32()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if !empty(l:node)
+        let l:path = l:node.path.str()
+        call nerdtree#echo(printf('%s:%s  MOD:%s  BYTES:%d  PERMISSIONS:%s',
+                    \ toupper(getftype(l:path)),
+                    \ fnamemodify(l:path, ':t'),
+                    \ strftime('%c', getftime(l:path)),
+                    \ getfsize(l:path),
+                    \ getfperm(l:path)))
+        return
+    endif
+
+    call nerdtree#echo('node not recognized')
+endfunction
+
+" FUNCTION: NERDTreeCopyNode() {{{1
+function! NERDTreeCopyNode()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    let prompt = s:inputPrompt('copy')
+    let newNodePath = substitute(input(prompt, currentNode.path.str(), 'file'), '\(^\s*\|\s*$\)', '', 'g')
+
+    if newNodePath !=# ''
+        "strip trailing slash
+        let newNodePath = substitute(newNodePath, '\/$', '', '')
+
+        let confirmed = 1
+        if currentNode.path.copyingWillOverwrite(newNodePath)
+            call nerdtree#echo('Warning: copying may overwrite files! Continue? (yN)')
+            let choice = nr2char(getchar())
+            let confirmed = choice ==# 'y'
+        endif
+
+        if confirmed
+            try
+                let newNode = currentNode.copy(newNodePath)
+                " Emptying g:NERDTreeOldSortOrder forces the sort to
+                " recalculate the cached sortKey so nodes sort correctly.
+                let g:NERDTreeOldSortOrder = []
+                if empty(newNode)
+                    call b:NERDTree.root.refresh()
+                    call b:NERDTree.render()
+                else
+                    call NERDTreeRender()
+                    call newNode.putCursorHere(0, 0)
+                endif
+            catch /^NERDTree/
+                call nerdtree#echoWarning('Could not copy node')
+            endtry
+        endif
+    else
+        call nerdtree#echo('Copy aborted.')
+    endif
+    redraw!
+endfunction
+
+" FUNCTION: NERDTreeCopyPath() {{{1
+function! NERDTreeCopyPath()
+    let l:nodePath = g:NERDTreeFileNode.GetSelected().path.str()
+    if has('clipboard')
+        if &clipboard ==# 'unnamedplus'
+            let @+ = l:nodePath
+        else
+            let @* = l:nodePath
+        endif
+        call nerdtree#echo('The path [' . l:nodePath . '] was copied to your clipboard.')
+    else
+        call nerdtree#echo('The full path is: ' . l:nodePath)
+    endif
+endfunction
+
+" FUNCTION: NERDTreeQuickLook() {{{1
+function! NERDTreeQuickLook()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    call system('qlmanage -p 2>/dev/null ' . shellescape(l:node.path.str()))
+endfunction
+
+" FUNCTION: NERDTreeRevealInFinder() {{{1
+function! NERDTreeRevealInFinder()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    call system('open -R ' . shellescape(l:node.path.str()))
+endfunction
+
+" FUNCTION: NERDTreeExecuteFile() {{{1
+function! NERDTreeExecuteFile()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    call system('open ' . shellescape(l:node.path.str()))
+endfunction
+
+" FUNCTION: NERDTreeRevealFileLinux() {{{1
+function! NERDTreeRevealFileLinux()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    " Handle the edge case of "/", which has no parent.
+    if l:node.path.str() ==# '/'
+        call system('xdg-open /')
+        return
+    endif
+
+    if empty(l:node.parent)
+        return
+    endif
+
+    call system('xdg-open ' . shellescape(l:node.parent.path.str()))
+endfunction
+
+" FUNCTION: NERDTreeExecuteFileLinux() {{{1
+function! NERDTreeExecuteFileLinux()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    call system('xdg-open ' . shellescape(l:node.path.str()))
+endfunction
+
+" FUNCTION: NERDTreeExecuteFileWindows() {{{1
+function! NERDTreeExecuteFileWindows()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    call system('cmd.exe /c start "" ' . shellescape(l:node.path.str()))
+endfunction
+
+" FUNCTION: NERDTreeSystemCommand() {{{1
+function! NERDTreeSystemCommand()
+    let l:node = g:NERDTreeFileNode.GetSelected()
+
+    if empty(l:node)
+        return
+    endif
+
+    let l:cwd = getcwd()
+    let l:directory = l:node.path.isDirectory ? l:node.path.str() : l:node.parent.path.str()
+    execute 'cd '.l:directory
+
+    let l:nl = nr2char(10)
+    echo l:nl . system(input(l:directory . (nerdtree#runningWindows() ? '> ' : ' $ ')))
+    execute 'cd '.l:cwd
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/nerdtree_plugin/vcs.vim b/.vim/bundle/vim-nerdtree/nerdtree_plugin/vcs.vim
new file mode 100644
index 0000000..d20e35e
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/nerdtree_plugin/vcs.vim
@@ -0,0 +1,47 @@
+" ============================================================================
+" File:        vcs.vim
+" Description: NERDTree plugin that provides a command to open on the root of
+"              a version control system repository.
+" Maintainer:  Phil Runninger
+" License:     This program is free software. It comes without any warranty,
+"              to the extent permitted by applicable law. You can redistribute
+"              it and/or modify it under the terms of the Do What The Fuck You
+"              Want To Public License, Version 2, as published by Sam Hocevar.
+"              See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" ============================================================================
+command! -n=? -complete=dir -bar NERDTreeVCS :call <SID>CreateTabTreeVCS('<args>')
+command! -n=? -complete=dir -bar NERDTreeToggleVCS :call <SID>ToggleTabTreeVCS('<args>')
+
+" FUNCTION: s:CreateTabTreeVCS(a:name) {{{1
+function! s:CreateTabTreeVCS(name)
+    let l:path = g:NERDTreeCreator._pathForString(a:name)
+    let l:path = s:FindParentVCSRoot(l:path)
+    call g:NERDTreeCreator.createTabTree(empty(l:path) ? '' : l:path._str())
+endfunction
+
+" FUNCTION: s:ToggleTabTreeVCS(a:name) {{{1
+" Behaves the same as ToggleTabTree except roots directory at VCS root
+function! s:ToggleTabTreeVCS(name)
+    let l:path = g:NERDTreeCreator._pathForString(a:name)
+    let l:path = s:FindParentVCSRoot(l:path)
+    call g:NERDTreeCreator.toggleTabTree(empty(l:path) ? '' : l:path._str())
+endfunction
+
+" FUNCTION: s:FindParentVCSRoot(a:path) {{{1
+" Finds the root version control system folder of the given path. If a:path is
+" not part of a repository, return the original path.
+function! s:FindParentVCSRoot(path)
+    let l:path = a:path
+    while !empty(l:path) &&
+        \ l:path._str() !~# '^\(\a:[\\\/]\|\/\)$' &&
+        \ !isdirectory(l:path._str() . '/.git') &&
+        \ !isdirectory(l:path._str() . '/.svn') &&
+        \ !isdirectory(l:path._str() . '/.hg') &&
+        \ !isdirectory(l:path._str() . '/.bzr') &&
+        \ !isdirectory(l:path._str() . '/_darcs')
+        let l:path = l:path.getParent()
+    endwhile
+    return (empty(l:path) || l:path._str() =~# '^\(\a:[\\\/]\|\/\)$') ? a:path : l:path
+endfunction
+
diff --git a/.vim/bundle/vim-nerdtree/plugin/NERD_tree.vim b/.vim/bundle/vim-nerdtree/plugin/NERD_tree.vim
new file mode 100644
index 0000000..ef60cca
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/plugin/NERD_tree.vim
@@ -0,0 +1,234 @@
+" ============================================================================
+" File:        NERD_tree.vim
+" Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+" License:     This program is free software. It comes without any warranty,
+"              to the extent permitted by applicable law. You can redistribute
+"              it and/or modify it under the terms of the Do What The Fuck You
+"              Want To Public License, Version 2, as published by Sam Hocevar.
+"              See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" ============================================================================
+"
+" SECTION: Script init stuff {{{1
+"============================================================
+scriptencoding utf-8
+
+if exists('loaded_nerd_tree')
+    finish
+endif
+if v:version < 703
+    echoerr "NERDTree: this plugin requires vim >= 7.3. DOWNLOAD IT! You'll thank me later!"
+    finish
+endif
+let loaded_nerd_tree = 1
+
+"for line continuation - i.e dont want C in &cpoptions
+let s:old_cpo = &cpoptions
+set cpoptions&vim
+
+"SECTION: Initialize variable calls and other random constants {{{2
+let g:NERDTreeAutoCenter            = get(g:, 'NERDTreeAutoCenter',            1)
+let g:NERDTreeAutoCenterThreshold   = get(g:, 'NERDTreeAutoCenterThreshold',   3)
+let g:NERDTreeCaseSensitiveSort     = get(g:, 'NERDTreeCaseSensitiveSort',     0)
+let g:NERDTreeNaturalSort           = get(g:, 'NERDTreeNaturalSort',           0)
+let g:NERDTreeSortHiddenFirst       = get(g:, 'NERDTreeSortHiddenFirst',       1)
+let g:NERDTreeUseTCD                = get(g:, 'NERDTreeUseTCD',                0)
+let g:NERDTreeChDirMode             = get(g:, 'NERDTreeChDirMode',             0)
+let g:NERDTreeCreatePrefix          = get(g:, 'NERDTreeCreatePrefix',          'silent')
+let g:NERDTreeMinimalUI             = get(g:, 'NERDTreeMinimalUI',             0)
+let g:NERDTreeMinimalMenu           = get(g:, 'NERDTreeMinimalMenu',           0)
+let g:NERDTreeIgnore                = get(g:, 'NERDTreeIgnore',                ['\~$'])
+let g:NERDTreeBookmarksFile         = get(g:, 'NERDTreeBookmarksFile',         expand('$HOME') . '/.NERDTreeBookmarks')
+let g:NERDTreeBookmarksSort         = get(g:, 'NERDTreeBookmarksSort',         1)
+let g:NERDTreeHighlightCursorline   = get(g:, 'NERDTreeHighlightCursorline',   1)
+let g:NERDTreeHijackNetrw           = get(g:, 'NERDTreeHijackNetrw',           1)
+let g:NERDTreeMarkBookmarks         = get(g:, 'NERDTreeMarkBookmarks',         1)
+let g:NERDTreeMouseMode             = get(g:, 'NERDTreeMouseMode',             1)
+let g:NERDTreeNotificationThreshold = get(g:, 'NERDTreeNotificationThreshold', 100)
+let g:NERDTreeQuitOnOpen            = get(g:, 'NERDTreeQuitOnOpen',            0)
+let g:NERDTreeRespectWildIgnore     = get(g:, 'NERDTreeRespectWildIgnore',     0)
+let g:NERDTreeShowBookmarks         = get(g:, 'NERDTreeShowBookmarks',         0)
+let g:NERDTreeShowFiles             = get(g:, 'NERDTreeShowFiles',             1)
+let g:NERDTreeShowHidden            = get(g:, 'NERDTreeShowHidden',            0)
+let g:NERDTreeShowLineNumbers       = get(g:, 'NERDTreeShowLineNumbers',       0)
+let g:NERDTreeSortDirs              = get(g:, 'NERDTreeSortDirs',              1)
+
+if !nerdtree#runningWindows() && !nerdtree#runningCygwin()
+    let g:NERDTreeDirArrowExpandable  = get(g:, 'NERDTreeDirArrowExpandable',  '▸')
+    let g:NERDTreeDirArrowCollapsible = get(g:, 'NERDTreeDirArrowCollapsible', '▾')
+else
+    let g:NERDTreeDirArrowExpandable  = get(g:, 'NERDTreeDirArrowExpandable',  '+')
+    let g:NERDTreeDirArrowCollapsible = get(g:, 'NERDTreeDirArrowCollapsible', '~')
+endif
+
+let g:NERDTreeCascadeOpenSingleChildDir = get(g:, 'NERDTreeCascadeOpenSingleChildDir', 1)
+let g:NERDTreeCascadeSingleChildDir     = get(g:, 'NERDTreeCascadeSingleChildDir',     1)
+
+let g:NERDTreeSortOrder    = get(g:, 'NERDTreeSortOrder', ['\/$', '*', '\.swp$', '\.bak$', '\~$'])
+let g:NERDTreeOldSortOrder = []
+
+let g:NERDTreeGlyphReadOnly = get(g:, 'NERDTreeGlyphReadOnly', 'RO')
+
+if has('conceal')
+    let g:NERDTreeNodeDelimiter = get(g:, 'NERDTreeNodeDelimiter', "\x07")
+elseif (g:NERDTreeDirArrowExpandable ==# "\u00a0" || g:NERDTreeDirArrowCollapsible ==# "\u00a0")
+    let g:NERDTreeNodeDelimiter = get(g:, 'NERDTreeNodeDelimiter', "\u00b7")
+else
+    let g:NERDTreeNodeDelimiter = get(g:, 'NERDTreeNodeDelimiter', "\u00a0")
+endif
+
+"the exists() crap here is a hack to stop vim spazzing out when
+"loading a session that was created with an open nerd tree. It spazzes
+"because it doesnt store b:NERDTree(its a b: var, and its a hash)
+let g:NERDTreeStatusline = get(g:, 'NERDTreeStatusline', "%{exists('b:NERDTree')?b:NERDTree.root.path.str():''}")
+
+let g:NERDTreeWinPos  = get(g:, 'NERDTreeWinPos', 'left')
+let g:NERDTreeWinSize = get(g:, 'NERDTreeWinSize', 31)
+
+"init the shell commands that will be used to copy nodes, and remove dir trees
+"Note: the space after the command is important
+if nerdtree#runningWindows()
+    let g:NERDTreeRemoveDirCmd = get(g:, 'NERDTreeRemoveDirCmd', 'rmdir /s /q ')
+    let g:NERDTreeCopyDirCmd   = get(g:, 'NERDTreeCopyDirCmd',   'xcopy /s /e /i /y /q ')
+    let g:NERDTreeCopyFileCmd  = get(g:, 'NERDTreeCopyFileCmd',  'copy /y ')
+else
+    let g:NERDTreeRemoveDirCmd = get(g:, 'NERDTreeRemoveDirCmd', 'rm -rf ')
+    let g:NERDTreeCopyCmd      = get(g:, 'NERDTreeCopyCmd',      'cp -r ')
+endif
+
+"SECTION: Init variable calls for key mappings {{{2
+let g:NERDTreeMapCustomOpen      = get(g:, 'NERDTreeMapCustomOpen',      '<CR>')
+let g:NERDTreeMapActivateNode    = get(g:, 'NERDTreeMapActivateNode',    'o')
+let g:NERDTreeMapChangeRoot      = get(g:, 'NERDTreeMapChangeRoot',      'C')
+let g:NERDTreeMapChdir           = get(g:, 'NERDTreeMapChdir',           'cd')
+let g:NERDTreeMapCloseChildren   = get(g:, 'NERDTreeMapCloseChildren',   'X')
+let g:NERDTreeMapCloseDir        = get(g:, 'NERDTreeMapCloseDir',        'x')
+let g:NERDTreeMapDeleteBookmark  = get(g:, 'NERDTreeMapDeleteBookmark',  'D')
+let g:NERDTreeMapMenu            = get(g:, 'NERDTreeMapMenu',            'm')
+let g:NERDTreeMapHelp            = get(g:, 'NERDTreeMapHelp',            '?')
+let g:NERDTreeMapJumpFirstChild  = get(g:, 'NERDTreeMapJumpFirstChild',  'K')
+let g:NERDTreeMapJumpLastChild   = get(g:, 'NERDTreeMapJumpLastChild',   'J')
+let g:NERDTreeMapJumpNextSibling = get(g:, 'NERDTreeMapJumpNextSibling', '<C-j>')
+let g:NERDTreeMapJumpParent      = get(g:, 'NERDTreeMapJumpParent',      'p')
+let g:NERDTreeMapJumpPrevSibling = get(g:, 'NERDTreeMapJumpPrevSibling', '<C-k>')
+let g:NERDTreeMapJumpRoot        = get(g:, 'NERDTreeMapJumpRoot',        'P')
+let g:NERDTreeMapOpenExpl        = get(g:, 'NERDTreeMapOpenExpl',        'e')
+let g:NERDTreeMapOpenInTab       = get(g:, 'NERDTreeMapOpenInTab',       't')
+let g:NERDTreeMapOpenInTabSilent = get(g:, 'NERDTreeMapOpenInTabSilent', 'T')
+let g:NERDTreeMapOpenRecursively = get(g:, 'NERDTreeMapOpenRecursively', 'O')
+let g:NERDTreeMapOpenSplit       = get(g:, 'NERDTreeMapOpenSplit',       'i')
+let g:NERDTreeMapOpenVSplit      = get(g:, 'NERDTreeMapOpenVSplit',      's')
+let g:NERDTreeMapPreview         = get(g:, 'NERDTreeMapPreview',         'g'.NERDTreeMapActivateNode)
+let g:NERDTreeMapPreviewSplit    = get(g:, 'NERDTreeMapPreviewSplit',    'g'.NERDTreeMapOpenSplit)
+let g:NERDTreeMapPreviewVSplit   = get(g:, 'NERDTreeMapPreviewVSplit',   'g'.NERDTreeMapOpenVSplit)
+let g:NERDTreeMapQuit            = get(g:, 'NERDTreeMapQuit',            'q')
+let g:NERDTreeMapRefresh         = get(g:, 'NERDTreeMapRefresh',         'r')
+let g:NERDTreeMapRefreshRoot     = get(g:, 'NERDTreeMapRefreshRoot',     'R')
+let g:NERDTreeMapToggleBookmarks = get(g:, 'NERDTreeMapToggleBookmarks', 'B')
+let g:NERDTreeMapToggleFiles     = get(g:, 'NERDTreeMapToggleFiles',     'F')
+let g:NERDTreeMapToggleFilters   = get(g:, 'NERDTreeMapToggleFilters',   'f')
+let g:NERDTreeMapToggleHidden    = get(g:, 'NERDTreeMapToggleHidden',    'I')
+let g:NERDTreeMapToggleZoom      = get(g:, 'NERDTreeMapToggleZoom',      'A')
+let g:NERDTreeMapUpdir           = get(g:, 'NERDTreeMapUpdir',           'u')
+let g:NERDTreeMapUpdirKeepOpen   = get(g:, 'NERDTreeMapUpdirKeepOpen',   'U')
+let g:NERDTreeMapCWD             = get(g:, 'NERDTreeMapCWD',             'CD')
+let g:NERDTreeMenuDown           = get(g:, 'NERDTreeMenuDown',           'j')
+let g:NERDTreeMenuUp             = get(g:, 'NERDTreeMenuUp',             'k')
+
+"SECTION: Load class files{{{2
+call nerdtree#loadClassFiles()
+
+" SECTION: Commands {{{1
+"============================================================
+call nerdtree#ui_glue#setupCommands()
+
+" SECTION: Auto commands {{{1
+"============================================================
+augroup NERDTree
+    "Save the cursor position whenever we close the nerd tree
+    exec 'autocmd BufLeave,WinLeave '. g:NERDTreeCreator.BufNamePrefix() .'* if g:NERDTree.IsOpen() | call b:NERDTree.ui.saveScreenState() | endif'
+
+    "disallow insert mode in the NERDTree
+    exec 'autocmd BufEnter,WinEnter '. g:NERDTreeCreator.BufNamePrefix() .'* stopinsert'
+augroup END
+
+if g:NERDTreeHijackNetrw
+    augroup NERDTreeHijackNetrw
+        autocmd VimEnter * silent! autocmd! FileExplorer
+        au BufEnter,VimEnter * call nerdtree#checkForBrowse(expand('<amatch>'))
+    augroup END
+endif
+
+if g:NERDTreeChDirMode ==# 3
+    augroup NERDTreeChDirOnTabSwitch
+        autocmd TabEnter * if g:NERDTree.ExistsForTab()|call g:NERDTree.ForCurrentTab().getRoot().path.changeToDir()|endif
+    augroup END
+endif
+
+" SECTION: Public API {{{1
+"============================================================
+function! NERDTreeAddMenuItem(options)
+    call g:NERDTreeMenuItem.Create(a:options)
+endfunction
+
+function! NERDTreeAddMenuSeparator(...)
+    let opts = a:0 ? a:1 : {}
+    call g:NERDTreeMenuItem.CreateSeparator(opts)
+endfunction
+
+function! NERDTreeAddSubmenu(options)
+    return g:NERDTreeMenuItem.Create(a:options)
+endfunction
+
+function! NERDTreeAddKeyMap(options)
+    call g:NERDTreeKeyMap.Create(a:options)
+endfunction
+
+function! NERDTreeRender()
+    call nerdtree#renderView()
+endfunction
+
+function! NERDTreeFocus()
+    if g:NERDTree.IsOpen()
+        call g:NERDTree.CursorToTreeWin(0)
+    else
+        call g:NERDTreeCreator.ToggleTabTree('')
+    endif
+endfunction
+
+function! NERDTreeCWD()
+
+    if empty(getcwd())
+        call nerdtree#echoWarning('current directory does not exist')
+        return
+    endif
+
+    try
+        let l:cwdPath = g:NERDTreePath.New(getcwd())
+    catch /^NERDTree.InvalidArgumentsError/
+        call nerdtree#echoWarning('current directory does not exist')
+        return
+    endtry
+
+    call NERDTreeFocus()
+
+    if b:NERDTree.root.path.equals(l:cwdPath)
+        return
+    endif
+
+    let l:newRoot = g:NERDTreeFileNode.New(l:cwdPath, b:NERDTree)
+    call b:NERDTree.changeRoot(l:newRoot)
+    normal! ^
+endfunction
+
+function! NERDTreeAddPathFilter(callback)
+    call g:NERDTree.AddPathFilter(a:callback)
+endfunction
+
+" SECTION: Post Source Actions {{{1
+call nerdtree#postSourceActions()
+
+"reset &cpoptions back to users setting
+let &cpoptions = s:old_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vim-nerdtree/screenshot.png b/.vim/bundle/vim-nerdtree/screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..c410c5dbb648c394dc74b90393939aa0ea252bb2
GIT binary patch
literal 87896
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
F{67l|-0c7W

literal 0
HcmV?d00001

diff --git a/.vim/bundle/vim-nerdtree/syntax/nerdtree.vim b/.vim/bundle/vim-nerdtree/syntax/nerdtree.vim
new file mode 100644
index 0000000..c4197ee
--- /dev/null
+++ b/.vim/bundle/vim-nerdtree/syntax/nerdtree.vim
@@ -0,0 +1,97 @@
+let s:tree_up_dir_line = '.. (up a dir)'
+syn match NERDTreeIgnore #\~#
+exec 'syn match NERDTreeIgnore #\['.g:NERDTreeGlyphReadOnly.'\]#'
+
+"highlighting for the .. (up dir) line at the top of the tree
+execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line .'#'
+
+"quickhelp syntax elements
+syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#ms=s+2,me=e-1
+syn match NERDTreeHelpKey #" \{1,2\}[^ ]*,#ms=s+2,me=e-1
+syn match NERDTreeHelpTitle #" .*\~$#ms=s+2,me=e-1
+syn match NERDTreeToggleOn #(on)#ms=s+1,he=e-1
+syn match NERDTreeToggleOff #(off)#ms=e-3,me=e-1
+syn match NERDTreeHelpCommand #" :.\{-}\>#hs=s+3
+syn match NERDTreeHelp  #^".*# contains=NERDTreeHelpKey,NERDTreeHelpTitle,NERDTreeIgnore,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand
+
+"highlighting for sym links
+syn match NERDTreeLinkTarget #->.*# containedin=NERDTreeDir,NERDTreeFile
+syn match NERDTreeLinkFile #.* ->#me=e-3 containedin=NERDTreeFile
+syn match NERDTreeLinkDir #.*/ ->#me=e-3 containedin=NERDTreeDir
+
+"highlighting to conceal the delimiter around the file/dir name
+if has('conceal')
+    exec 'syn match NERDTreeNodeDelimiters #\%d' . char2nr(g:NERDTreeNodeDelimiter) . '# conceal containedin=ALL'
+    setlocal conceallevel=2 concealcursor=nvic
+else
+    exec 'syn match NERDTreeNodeDelimiters #\%d' . char2nr(g:NERDTreeNodeDelimiter) . '# containedin=ALL'
+    hi! link NERDTreeNodeDelimiters Ignore
+endif
+
+"highlighing for directory nodes and file nodes
+syn match NERDTreeDirSlash #/# containedin=NERDTreeDir
+
+if g:NERDTreeDirArrowExpandable !=# ''
+    exec 'syn match NERDTreeClosable #' . escape(g:NERDTreeDirArrowCollapsible, '~') . '\ze .*/# containedin=NERDTreeDir,NERDTreeFile'
+    exec 'syn match NERDTreeOpenable #' . escape(g:NERDTreeDirArrowExpandable, '~') . '\ze .*/# containedin=NERDTreeDir,NERDTreeFile'
+    let s:dirArrows = escape(g:NERDTreeDirArrowCollapsible, '~]\-').escape(g:NERDTreeDirArrowExpandable, '~]\-')
+    exec 'syn match NERDTreeDir #[^'.s:dirArrows.' ].*/#'
+    exec 'syn match NERDTreeExecFile #^.*'.g:NERDTreeNodeDelimiter.'\*\($\| \)# contains=NERDTreeRO,NERDTreeBookmarkName'
+    exec 'syn match NERDTreeFile  #^[^"\.'.s:dirArrows.'] *[^'.s:dirArrows.']*# contains=NERDTreeLink,NERDTreeRO,NERDTreeBookmarkName,NERDTreeExecFile'
+else
+    exec 'syn match NERDTreeDir #[^'.g:NERDTreeNodeDelimiter.']\{-}/\ze\($\|'.g:NERDTreeNodeDelimiter.'\)#'
+    exec 'syn match NERDTreeExecFile #[^'.g:NERDTreeNodeDelimiter.']\{-}'.g:NERDTreeNodeDelimiter.'\*\($\| \)# contains=NERDTreeRO,NERDTreeBookmarkName'
+    exec 'syn match NERDTreeFile     #^.*'.g:NERDTreeNodeDelimiter.'.*[^\/]\($\|'.g:NERDTreeNodeDelimiter.'.*\)# contains=NERDTreeLink,NERDTreeRO,NERDTreeBookmarkName,NERDTreeExecFile'
+endif
+
+"highlighting for readonly files
+exec 'syn match NERDTreeRO #.*'.g:NERDTreeNodeDelimiter.'\zs.*\ze'.g:NERDTreeNodeDelimiter.'.*\['.g:NERDTreeGlyphReadOnly.'\]# contains=NERDTreeIgnore,NERDTreeBookmarkName,NERDTreeFile'
+
+exec 'syn match NERDTreeFlags #\[[^\]]*\]\ze'.g:NERDTreeNodeDelimiter.'# containedin=NERDTreeFile,NERDTreeExecFile,NERDTreeLinkFile,NERDTreeRO,NERDTreeDir'
+
+syn match NERDTreeCWD #^[</].*$#
+
+"highlighting for bookmarks
+syn match NERDTreeBookmarkName # {.*}#hs=s+2,he=e-1
+
+"highlighting for the bookmarks table
+syn match NERDTreeBookmarksLeader #^>#
+syn match NERDTreeBookmarksHeader #^>-\+Bookmarks-\+$# contains=NERDTreeBookmarksLeader
+syn match NERDTreeBookmarkName #^>.\{-} #he=e-1 contains=NERDTreeBookmarksLeader
+syn match NERDTreeBookmark #^>.*$# contains=NERDTreeBookmarksLeader,NERDTreeBookmarkName,NERDTreeBookmarksHeader
+
+hi def link NERDTreePart Special
+hi def link NERDTreePartFile Type
+hi def link NERDTreeExecFile Title
+hi def link NERDTreeDirSlash Identifier
+
+hi def link NERDTreeBookmarksHeader statement
+hi def link NERDTreeBookmarksLeader ignore
+hi def link NERDTreeBookmarkName Identifier
+hi def link NERDTreeBookmark normal
+
+hi def link NERDTreeHelp String
+hi def link NERDTreeHelpKey Identifier
+hi def link NERDTreeHelpCommand Identifier
+hi def link NERDTreeHelpTitle Macro
+hi def link NERDTreeToggleOn Question
+hi def link NERDTreeToggleOff WarningMsg
+
+hi def link NERDTreeLinkTarget Type
+hi def link NERDTreeLinkFile Macro
+hi def link NERDTreeLinkDir Macro
+
+hi def link NERDTreeDir Directory
+hi def link NERDTreeUp Directory
+hi def link NERDTreeFile Normal
+hi def link NERDTreeCWD Statement
+hi def link NERDTreeOpenable Directory
+hi def link NERDTreeClosable Directory
+hi def link NERDTreeIgnore ignore
+hi def link NERDTreeRO WarningMsg
+hi def link NERDTreeBookmark Statement
+hi def link NERDTreeFlags Number
+
+hi def link NERDTreeCurrentNode Search
+
+hi NERDTreeFile ctermbg=NONE guibg=NONE