added vim dir

21 files changed, 4166 insertions, 0 deletions

diff --git a/vim/.vim/plugged/vim-gitgutter/LICENCE b/vim/.vim/plugged/vim-gitgutter/LICENCE
new file mode 100644
index 0000000..38e2dc2
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/LICENCE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Andrew Stewart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vim/.vim/plugged/vim-gitgutter/README.mkd b/vim/.vim/plugged/vim-gitgutter/README.mkd
new file mode 100644
index 0000000..a08507b
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/README.mkd
@@ -0,0 +1,582 @@
+## vim-gitgutter
+
+A Vim plugin which shows a git diff in the 'gutter' (sign column).  It shows which lines have been added, modified, or removed.  You can also preview, stage, and undo individual hunks.  The plugin also provides a hunk text object.
+
+The signs are always up to date and the plugin never saves your buffer.
+
+Features:
+
+* Shows signs for added, modified, and removed lines.
+* Runs the diffs asynchronously where possible.
+* Ensures signs are always up to date.
+* Never saves the buffer.
+* Quick jumping between blocks of changed lines ("hunks").
+* Stage/undo/preview individual hunks.
+* Provides a hunk text object.
+* Diffs against index (default) or any commit.
+* Allows folding all unchanged text.
+* Handles line endings correctly, even with repos that do CRLF conversion.
+* Optional line highlighting.
+* Fully customisable (signs, sign column, line highlights, mappings, extra git-diff arguments, etc).
+* Can be toggled on/off, globally or per buffer.
+* Preserves signs from other plugins.
+* Easy to integrate diff stats into status line; built-in integration with [vim-airline](https://github.com/bling/vim-airline/).
+* Works with fish shell (in addition to the usual shells).
+
+Constraints:
+
+* Supports git only.  If you work with other version control systems, I recommend [vim-signify](https://github.com/mhinz/vim-signify).
+* Relies on the `FocusGained` event.  If your terminal doesn't report focus events, either use something like [Terminus][] or set `let g:gitgutter_terminal_reports_focus=0`.
+
+
+### Screenshot
+
+![screenshot](https://raw.github.com/airblade/vim-gitgutter/master/screenshot.png)
+
+In the screenshot above you can see:
+
+* Line 15 has been modified.
+* Lines 21-24 are new.
+* A line or lines were removed between lines 25 and 26.
+
+
+### Installation
+
+Before installation, please check your Vim supports signs by running `:echo has('signs')`.  `1` means you're all set; `0` means you need to install a Vim with signs support.  If you're compiling Vim yourself you need the 'big' or 'huge' feature set.  MacVim supports signs.
+
+You install vim-gitgutter like any other vim plugin.
+
+##### Pathogen
+
+```
+cd ~/.vim/bundle
+git clone git://github.com/airblade/vim-gitgutter.git
+```
+
+##### Voom
+
+Edit your plugin manifest (`voom edit`) and add:
+
+```
+airblade/vim-gitgutter
+```
+
+##### VimPlug
+
+Place this in your .vimrc:
+
+```viml
+Plug 'airblade/vim-gitgutter'
+```
+
+Then run the following in Vim:
+
+```
+:source %
+:PlugInstall
+```
+
+##### NeoBundle
+
+Place this in your .vimrc:
+
+```viml
+NeoBundle 'airblade/vim-gitgutter'
+```
+
+Then run the following in Vim:
+
+```
+:source %
+:NeoBundleInstall
+```
+
+##### No plugin manager
+
+Copy vim-gitgutter's subdirectories into your vim configuration directory:
+
+```
+cd /tmp && git clone git://github.com/airblade/vim-gitgutter.git
+cp -r vim-gitgutter/* ~/.vim/
+```
+
+See `:help add-global-plugin`.
+
+
+### Getting started
+
+When you make a change to a file tracked by git, the diff markers should appear automatically.  The delay is governed by vim's `updatetime` option; the default value is `4000`, i.e. 4 seconds, but I suggest reducing it to around 100ms (add `set updatetime=100` to your vimrc).
+
+You can jump between hunks with `[c` and `]c`.  You can preview, stage, and undo hunks with `<leader>hp`, `<leader>hs`, and `<leader>hu` respectively.
+
+You cannot unstage a staged hunk.
+
+
+#### Activation
+
+You can explicitly turn vim-gitgutter off and on (defaults to on):
+
+* turn off with `:GitGutterDisable`
+* turn on with `:GitGutterEnable`
+* toggle with `:GitGutterToggle`.
+
+To toggle vim-gitgutter per buffer:
+
+* turn off with `:GitGutterBufferDisable`
+* turn on with `:GitGutterBufferEnable`
+* toggle with `:GitGutterBufferToggle`
+
+You can turn the signs on and off (defaults to on):
+
+* turn on with `:GitGutterSignsEnable`
+* turn off with `:GitGutterSignsDisable`
+* toggle with `:GitGutterSignsToggle`.
+
+And you can turn line highlighting on and off (defaults to off):
+
+* turn on with `:GitGutterLineHighlightsEnable`
+* turn off with `:GitGutterLineHighlightsDisable`
+* toggle with `:GitGutterLineHighlightsToggle`.
+
+Note that if you have line highlighting on and signs off, you will have an empty sign column – more accurately, a sign column with invisible signs.  This is because line highlighting requires signs and Vim always shows the sign column even if the signs are invisible.
+
+If you switch off both line highlighting and signs, you won't see the sign column.  That is unless you configure the sign column always to be there (see Sign Column section).
+
+To keep your Vim snappy, vim-gitgutter will suppress the signs when a file has more than 500 changes.  As soon as the number of changes falls below the limit vim-gitgutter will show the signs again.  You can configure the threshold with:
+
+```viml
+let g:gitgutter_max_signs = 500  " default value
+```
+
+#### Hunks
+
+You can jump between hunks:
+
+* jump to next hunk (change): `]c`
+* jump to previous hunk (change): `[c`.
+
+Both of those take a preceding count.
+
+To set your own mappings for these, for example `]h` and `[h`:
+
+```viml
+nmap ]h <Plug>GitGutterNextHunk
+nmap [h <Plug>GitGutterPrevHunk
+```
+
+You can stage or undo an individual hunk when your cursor is in it:
+
+* stage the hunk with `<Leader>hs` or
+* undo it with `<Leader>hu`.
+
+See the FAQ if you want to unstage staged changes.
+
+The `.` command will work with both these if you install [repeat.vim](https://github.com/tpope/vim-repeat).
+
+To set your own mappings for these, for example if you prefer the mnemonics hunk-add and hunk-revert:
+
+```viml
+nmap <Leader>ha <Plug>GitGutterStageHunk
+nmap <Leader>hr <Plug>GitGutterUndoHunk
+```
+
+And you can preview a hunk's changes with `<Leader>hp`.  You can of course change this mapping, e.g:
+
+```viml
+nmap <Leader>hv <Plug>GitGutterPreviewHunk
+```
+
+A hunk text object is provided which works in visual and operator-pending modes.
+
+- `ic` operates on all lines in the current hunk.
+- `ac` operates on all lines in the current hunk and any trailing empty lines.
+
+To re-map these, for example to `ih` and `ah`:
+
+```viml
+omap ih <Plug>GitGutterTextObjectInnerPending
+omap ah <Plug>GitGutterTextObjectOuterPending
+xmap ih <Plug>GitGutterTextObjectInnerVisual
+xmap ah <Plug>GitGutterTextObjectOuterVisual
+```
+
+If you don't want vim-gitgutter to set up any mappings at all, use this:
+
+```viml
+let g:gitgutter_map_keys = 0
+```
+
+Finally, you can force vim-gitgutter to update its signs across all visible buffers with `:GitGutterAll`.
+
+See the customisation section below for how to change the defaults.
+
+
+### Folding
+
+Use the `GitGutterFold` command to fold all unchanged lines, leaving just the hunks visible.  Use `zr` to unfold 3 lines of context above and below a hunk.
+
+Execute `GitGutterFold` a second time to restore the previous view.
+
+
+### Customisation
+
+You can customise:
+
+* The sign column's colours
+* Whether or not the sign column is shown when there aren't any signs (defaults to no)
+* The signs' colours and symbols
+* Line highlights
+* The base of the diff
+* Extra arguments for `git` when running `git diff`
+* Extra arguments for `git diff`
+* Key mappings
+* Whether or not vim-gitgutter is on initially (defaults to on)
+* Whether or not signs are shown (defaults to yes)
+* Whether or not line highlighting is on initially (defaults to off)
+* Whether or not vim-gitgutter runs in "realtime" (defaults to yes)
+* Whether or not vim-gitgutter runs eagerly (defaults to yes)
+* Whether or not vim-gitgutter runs asynchronously (defaults to yes)
+
+Please note that vim-gitgutter won't override any colours or highlights you've set in your colorscheme.
+
+
+#### Sign column
+
+By default vim-gitgutter will make the sign column look like the line number column.
+
+To customise your sign column's background color, first tell vim-gitgutter to leave it alone:
+
+```viml
+let g:gitgutter_override_sign_column_highlight = 0
+```
+
+And then either update your colorscheme's `SignColumn` highlight group or set it in your vimrc:
+
+```viml
+highlight SignColumn ctermbg=whatever    " terminal Vim
+highlight SignColumn guibg=whatever      " gVim/MacVim
+```
+
+By default the sign column will appear when there are signs to show and disappear when there aren't.  To always have the sign column, add to your vimrc:
+
+```viml
+if exists('&signcolumn')  " Vim 7.4.2201
+  set signcolumn=yes
+else
+  let g:gitgutter_sign_column_always = 1
+endif
+```
+
+
+#### Signs' colours and symbols
+
+By default vim-gitgutter uses your colourscheme's `Diff*` highlight groups' foreground colours for the signs' foreground colours.  For example, your `DiffAdd` foreground colour will be used for the `+` sign's foreground colour.
+
+The signs' background colours will all be set to the sign column's background colour.
+
+If you don't like the default colours, you can either fix your colourscheme's `Diff*` highlights or configure your own `GitGutter*` highlight groups.  These groups are:
+
+```viml
+GitGutterAdd          " an added line             (default: links to DiffAdd)
+GitGutterChange       " a changed line            (default: links to DiffChange)
+GitGutterDelete       " at least one removed line (default: links to DiffDelete)
+GitGutterChangeDelete " a changed line followed by at least one removed line (default: links to GitGutterChange)
+```
+
+You can either set these with `highlight GitGutterAdd {key}={arg}...` or link them to existing highlight groups with, say, `highlight link GitGutterAdd MyDiffAdd`.
+
+To get vim-gitgutter's original colours (based on git-diff's colours in my terminal):
+
+```viml
+highlight GitGutterAdd    guifg=#009900 guibg=<X> ctermfg=2 ctermbg=<Y>
+highlight GitGutterChange guifg=#bbbb00 guibg=<X> ctermfg=3 ctermbg=<Y>
+highlight GitGutterDelete guifg=#ff2222 guibg=<X> ctermfg=1 ctermbg=<Y>
+```
+
+– where you would replace `<X>` and `<Y>` with the background colour of your `SignColumn` in the gui and the terminal respectively.  For example, with the solarized colorscheme and a dark background, `guibg=#073642` and `ctermbg=0`.
+
+To customise the symbols, add the following to your `~/.vimrc`:
+
+```viml
+let g:gitgutter_sign_added = 'xx'
+let g:gitgutter_sign_modified = 'yy'
+let g:gitgutter_sign_removed = 'zz'
+let g:gitgutter_sign_removed_first_line = '^^'
+let g:gitgutter_sign_modified_removed = 'ww'
+```
+
+
+#### Line highlights
+
+Similarly to the signs' colours, set up the following highlight groups in your colorscheme or `~/.vimrc`:
+
+```viml
+GitGutterAddLine          " default: links to DiffAdd
+GitGutterChangeLine       " default: links to DiffChange
+GitGutterDeleteLine       " default: links to DiffDelete
+GitGutterChangeDeleteLine " default: links to GitGutterChangeLineDefault, i.e. DiffChange
+```
+
+For example, in some colorschemes the `DiffText` highlight group is easier to read than `DiffChange`.  You could use it like this:
+
+```viml
+highlight link GitGutterChangeLine DiffText
+```
+
+
+#### The base of the diff
+
+By default buffers are diffed against the index.  However you can diff against any commit by setting:
+
+```viml
+let g:gitgutter_diff_base = '<commit SHA>'
+```
+
+
+#### Extra arguments for `git` when running `git diff`
+
+If you want to pass extra arguments to `git` when running `git diff`, do so like this:
+
+```viml
+let g:gitgutter_git_args = '--git-dir-""'
+```
+
+#### Extra arguments for `git diff`
+
+If you want to pass extra arguments to `git diff`, for example to ignore whitespace, do so like this:
+
+```viml
+let g:gitgutter_diff_args = '-w'
+```
+
+#### Key mappings
+
+To disable all key mappings:
+
+```viml
+let g:gitgutter_map_keys = 0
+```
+
+See above for configuring maps for hunk-jumping and staging/undoing.
+
+
+#### Use a custom `grep` command
+
+If you use an alternative to grep, you can tell vim-gitgutter to use it here.
+
+```viml
+" Default:
+let g:gitgutter_grep = 'grep'
+```
+
+#### To turn off vim-gitgutter by default
+
+Add `let g:gitgutter_enabled = 0` to your `~/.vimrc`.
+
+
+#### To turn off signs by default
+
+Add `let g:gitgutter_signs = 0` to your `~/.vimrc`.
+
+
+#### To turn on line highlighting by default
+
+Add `let g:gitgutter_highlight_lines = 1` to your `~/.vimrc`.
+
+
+#### To turn off asynchronous updates
+
+By default diffs are run asynchronously.  To run diffs synchronously instead:
+
+```viml
+let g:gitgutter_async = 0
+```
+
+
+### Extensions
+
+#### Operate on every line in a hunk
+
+You can map an operator to do whatever you want to every line in a hunk.
+
+Let's say, for example, you want to remove trailing whitespace.
+
+```viml
+function! CleanUp(...)
+  if a:0  " opfunc
+    let [first, last] = [line("'["), line("']")]
+  else
+    let [first, last] = [line("'<"), line("'>")]
+  endif
+  for lnum in range(first, last)
+    let line = getline(lnum)
+
+    " clean up the text, e.g.:
+    let line = substitute(line, '\s\+$', '', '')
+
+    call setline(lnum, line)
+  endfor
+endfunction
+
+nmap <silent> <Leader>x :set opfunc=CleanUp<CR>g@
+```
+
+Then place your cursor in a hunk and type `\xic` (assuming a leader of `\`).
+
+Alternatively you could place your cursor in a hunk, type `vic` to select it, then `:call CleanUp()`.
+
+
+#### Operate on every changed line in a file
+
+You can write a command to do whatever you want to every changed line in a file.
+
+```viml
+function! GlobalChangedLines(ex_cmd)
+  for hunk in GitGutterGetHunks()
+    for lnum in range(hunk[2], hunk[2]+hunk[3]-1)
+      let cursor = getcurpos()
+      silent! execute lnum.a:ex_cmd
+      call setpos('.', cursor)
+    endfor
+  endfor
+endfunction
+
+command -nargs=1 Glines call GlobalChangedLines(<q-args>)
+```
+
+Let's say, for example, you want to remove trailing whitespace from all changed lines:
+
+```viml
+:Glines s/\s\+$//
+```
+
+
+#### Cycle through hunks in all buffers
+
+`]c` and `[c` jump from one hunk to the next in the current buffer.  You can use this code to jump to the next hunk no matter which buffer it's in.
+
+```viml
+function! NextHunkAllBuffers()
+  let line = line('.')
+  GitGutterNextHunk
+  if line('.') != line
+    return
+  endif
+
+  let bufnr = bufnr('')
+  while 1
+    bnext
+    if bufnr('') == bufnr
+      return
+    endif
+    if !empty(GitGutterGetHunks())
+      normal! 1G
+      GitGutterNextHunk
+      return
+    endif
+  endwhile
+endfunction
+
+function! PrevHunkAllBuffers()
+  let line = line('.')
+  GitGutterPrevHunk
+  if line('.') != line
+    return
+  endif
+
+  let bufnr = bufnr('')
+  while 1
+    bprevious
+    if bufnr('') == bufnr
+      return
+    endif
+    if !empty(GitGutterGetHunks())
+      normal! G
+      GitGutterPrevHunk
+      return
+    endif
+  endwhile
+endfunction
+
+nmap <silent> ]c :call NextHunkAllBuffers()<CR>
+nmap <silent> [c :call PrevHunkAllBuffers()<CR>
+```
+
+
+### FAQ
+
+> How can I turn off realtime updates?
+
+Add this to your vim configuration (in an `/after/plugin` directory):
+
+```viml
+" .vim/after/plugin/gitgutter.vim
+autocmd! gitgutter CursorHold,CursorHoldI
+```
+
+> I turned off realtime updates, how can I have signs updated when I save a file?
+
+If you really want to update the signs when you save a file, add this to your vimrc:
+
+```viml
+autocmd BufWritePost * GitGutter
+```
+
+> Why can't I unstage staged changes?
+
+This plugin is for showing changes between the working tree and the index (and staging/undoing those changes).  Unstaging a staged hunk would require showing changes between the index and HEAD, which is out of scope.
+
+> Why are the colours in the sign column weird?
+
+Your colorscheme is configuring the `SignColumn` highlight group weirdly.  Please see the section above on customising the sign column.
+
+> What happens if I also use another plugin which uses signs (e.g. Syntastic)?
+
+Vim only allows one sign per line.  Before adding a sign to a line, vim-gitgutter checks whether a sign has already been added by somebody else.  If so it doesn't do anything.  In other words vim-gitgutter won't overwrite another plugin's signs.  It also won't remove another plugin's signs.
+
+
+### Troubleshooting
+
+#### When no signs are showing at all
+
+Here are some things you can check:
+
+* Try adding `let g:gitgutter_grep=''` to your vimrc.  If it works, the problem is grep producing non-plain output; e.g. ANSI escape codes or colours.
+* Verify `:echo system("git --version")` succeeds.
+* Verify your git config is compatible with the version of git returned by the command above.
+* Verify your Vim supports signs (`:echo has('signs')` should give `1`).
+* Verify your file is being tracked by git and has unstaged changes.
+
+#### When the whole file is marked as added
+
+* If you use zsh, and you set `CDPATH`, make sure `CDPATH` doesn't include the current directory.
+
+#### When signs take a few seconds to appear
+
+* Try reducing `updatetime`, e.g. `set updatetime=100`.
+
+#### When signs don't update after focusing Vim
+
+* Your terminal probably isn't reporting focus events.  Either try installing [Terminus][] or set `let g:gitgutter_terminal_reports_focus=0`.
+
+
+### Shameless Plug
+
+If this plugin has helped you, or you'd like to learn more about Vim, why not check out this screencast I wrote for PeepCode:
+
+* [Smash Into Vim][siv]
+
+This was one of PeepCode's all-time top three bestsellers and is now available at Pluralsight.
+
+You can read reviews on my [website][airblade].
+
+
+### Intellectual Property
+
+Copyright Andrew Stewart, AirBlade Software Ltd.  Released under the MIT licence.
+
+
+  [pathogen]: https://github.com/tpope/vim-pathogen
+  [siv]: http://pluralsight.com/training/Courses/TableOfContents/smash-into-vim
+  [airblade]: http://airbladesoftware.com/peepcode-vim
+  [terminus]: https://github.com/wincent/terminus
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter.vim
new file mode 100644
index 0000000..2e17fdb
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter.vim
@@ -0,0 +1,160 @@
+let s:t_string = type('')
+
+" Primary functions {{{
+
+function! gitgutter#all(force) abort
+  let visible = tabpagebuflist()
+
+  for bufnr in range(1, bufnr('$') + 1)
+    if buflisted(bufnr)
+      let file = expand('#'.bufnr.':p')
+      if !empty(file)
+        if index(visible, bufnr) != -1
+          call gitgutter#init_buffer(bufnr)
+          call gitgutter#process_buffer(bufnr, a:force)
+        elseif a:force
+          call s:reset_tick(bufnr)
+        endif
+      endif
+    endif
+  endfor
+endfunction
+
+
+" Finds the file's path relative to the repo root.
+function! gitgutter#init_buffer(bufnr)
+  if gitgutter#utility#is_active(a:bufnr)
+    let p = gitgutter#utility#repo_path(a:bufnr, 0)
+    if type(p) != s:t_string || empty(p)
+      call gitgutter#utility#set_repo_path(a:bufnr)
+      call s:setup_maps()
+    endif
+  endif
+endfunction
+
+
+function! gitgutter#process_buffer(bufnr, force) abort
+  " NOTE a:bufnr is not necessarily the current buffer.
+
+  if gitgutter#utility#is_active(a:bufnr)
+    if a:force || s:has_fresh_changes(a:bufnr)
+
+      let diff = ''
+      try
+        let diff = gitgutter#diff#run_diff(a:bufnr, 'index', 0)
+      catch /gitgutter not tracked/
+        call gitgutter#debug#log('Not tracked: '.gitgutter#utility#file(a:bufnr))
+      catch /gitgutter diff failed/
+        call gitgutter#debug#log('Diff failed: '.gitgutter#utility#file(a:bufnr))
+        call gitgutter#hunk#reset(a:bufnr)
+      endtry
+
+      if diff != 'async'
+        call gitgutter#diff#handler(a:bufnr, diff)
+      endif
+
+    endif
+  endif
+endfunction
+
+
+function! gitgutter#disable() abort
+  " get list of all buffers (across all tabs)
+  for bufnr in range(1, bufnr('$') + 1)
+    if buflisted(bufnr)
+      let file = expand('#'.bufnr.':p')
+      if !empty(file)
+        call s:clear(bufnr)
+      endif
+    endif
+  endfor
+
+  let g:gitgutter_enabled = 0
+endfunction
+
+function! gitgutter#enable() abort
+  let g:gitgutter_enabled = 1
+  call gitgutter#all(1)
+endfunction
+
+function! gitgutter#toggle() abort
+  if g:gitgutter_enabled
+    call gitgutter#disable()
+  else
+    call gitgutter#enable()
+  endif
+endfunction
+
+
+function! gitgutter#buffer_disable() abort
+  let bufnr = bufnr('')
+  call gitgutter#utility#setbufvar(bufnr, 'enabled', 0)
+  call s:clear(bufnr)
+endfunction
+
+function! gitgutter#buffer_enable() abort
+  let bufnr = bufnr('')
+  call gitgutter#utility#setbufvar(bufnr, 'enabled', 1)
+  call gitgutter#process_buffer(bufnr, 1)
+endfunction
+
+function! gitgutter#buffer_toggle() abort
+  if gitgutter#utility#getbufvar(bufnr(''), 'enabled', 1)
+    call gitgutter#buffer_disable()
+  else
+    call gitgutter#buffer_enable()
+  endif
+endfunction
+
+" }}}
+
+function! s:setup_maps()
+  if !g:gitgutter_map_keys
+    return
+  endif
+
+  if !hasmapto('<Plug>GitGutterPrevHunk') && maparg('[c', 'n') ==# ''
+    nmap <buffer> [c <Plug>GitGutterPrevHunk
+  endif
+  if !hasmapto('<Plug>GitGutterNextHunk') && maparg(']c', 'n') ==# ''
+    nmap <buffer> ]c <Plug>GitGutterNextHunk
+  endif
+
+  if !hasmapto('<Plug>GitGutterStageHunk') && maparg('<Leader>hs', 'n') ==# ''
+    nmap <buffer> <Leader>hs <Plug>GitGutterStageHunk
+  endif
+  if !hasmapto('<Plug>GitGutterUndoHunk') && maparg('<Leader>hu', 'n') ==# ''
+    nmap <buffer> <Leader>hu <Plug>GitGutterUndoHunk
+  endif
+  if !hasmapto('<Plug>GitGutterPreviewHunk') && maparg('<Leader>hp', 'n') ==# ''
+    nmap <buffer> <Leader>hp <Plug>GitGutterPreviewHunk
+  endif
+
+  if !hasmapto('<Plug>GitGutterTextObjectInnerPending') && maparg('ic', 'o') ==# ''
+    omap <buffer> ic <Plug>GitGutterTextObjectInnerPending
+  endif
+  if !hasmapto('<Plug>GitGutterTextObjectOuterPending') && maparg('ac', 'o') ==# ''
+    omap <buffer> ac <Plug>GitGutterTextObjectOuterPending
+  endif
+  if !hasmapto('<Plug>GitGutterTextObjectInnerVisual') && maparg('ic', 'x') ==# ''
+    xmap <buffer> ic <Plug>GitGutterTextObjectInnerVisual
+  endif
+  if !hasmapto('<Plug>GitGutterTextObjectOuterVisual') && maparg('ac', 'x') ==# ''
+    xmap <buffer> ac <Plug>GitGutterTextObjectOuterVisual
+  endif
+endfunction
+
+function! s:has_fresh_changes(bufnr) abort
+  return getbufvar(a:bufnr, 'changedtick') != gitgutter#utility#getbufvar(a:bufnr, 'tick')
+endfunction
+
+function! s:reset_tick(bufnr) abort
+  call gitgutter#utility#setbufvar(a:bufnr, 'tick', 0)
+endfunction
+
+function! s:clear(bufnr)
+  call gitgutter#sign#clear_signs(a:bufnr)
+  call gitgutter#sign#remove_dummy_sign(a:bufnr, 1)
+  call gitgutter#hunk#reset(a:bufnr)
+  call s:reset_tick(a:bufnr)
+endfunction
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/async.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/async.vim
new file mode 100644
index 0000000..40f2ad2
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/async.vim
@@ -0,0 +1,95 @@
+let s:available = has('nvim') || (
+      \   has('job') && (
+      \     (has('patch-7-4-1826') && !has('gui_running')) ||
+      \     (has('patch-7-4-1850') &&  has('gui_running')) ||
+      \     (has('patch-7-4-1832') &&  has('gui_macvim'))
+      \   )
+      \ )
+
+function! gitgutter#async#available()
+  return s:available
+endfunction
+
+
+function! gitgutter#async#execute(cmd, bufnr, handler) abort
+  call gitgutter#debug#log('[async] '.a:cmd)
+
+  let options = {
+        \   'stdoutbuffer': [],
+        \   'buffer': a:bufnr,
+        \   'handler': a:handler
+        \ }
+  let command = s:build_command(a:cmd)
+
+  if has('nvim')
+    call jobstart(command, extend(options, {
+          \   'on_stdout': function('s:on_stdout_nvim'),
+          \   'on_stderr': function('s:on_stderr_nvim'),
+          \   'on_exit':   function('s:on_exit_nvim')
+          \ }))
+  else
+    call job_start(command, {
+          \   'out_cb':   function('s:on_stdout_vim', options),
+          \   'err_cb':   function('s:on_stderr_vim', options),
+          \   'close_cb': function('s:on_exit_vim', options)
+          \ })
+  endif
+endfunction
+
+
+function! s:build_command(cmd)
+  if has('unix')
+    return ['sh', '-c', a:cmd]
+  endif
+
+  if has('win32')
+    return has('nvim') ? ['cmd.exe', '/c', a:cmd] : 'cmd.exe /c '.a:cmd
+  endif
+
+  throw 'unknown os'
+endfunction
+
+
+function! s:on_stdout_nvim(_job_id, data, _event) dict abort
+  if empty(self.stdoutbuffer)
+    let self.stdoutbuffer = a:data
+  else
+    let self.stdoutbuffer = self.stdoutbuffer[:-2] +
+          \ [self.stdoutbuffer[-1] . a:data[0]] +
+          \ a:data[1:]
+  endif
+endfunction
+
+function! s:on_stderr_nvim(_job_id, _data, _event) dict abort
+  call self.handler.err(self.buffer)
+endfunction
+
+function! s:on_exit_nvim(_job_id, exit_code, _event) dict abort
+  if !a:exit_code
+    call self.handler.out(self.buffer, join(self.stdoutbuffer, "\n"))
+  endif
+endfunction
+
+
+function! s:on_stdout_vim(_channel, data) dict abort
+  call add(self.stdoutbuffer, a:data)
+endfunction
+
+function! s:on_stderr_vim(channel, _data) dict abort
+  call self.handler.err(self.buffer)
+endfunction
+
+function! s:on_exit_vim(channel) dict abort
+  let job = ch_getjob(a:channel)
+  while 1
+    if job_status(job) == 'dead'
+      let exit_code = job_info(job).exitval
+      break
+    endif
+    sleep 5m
+  endwhile
+
+  if !exit_code
+    call self.handler.out(self.buffer, join(self.stdoutbuffer, "\n"))
+  endif
+endfunction
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/debug.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/debug.vim
new file mode 100644
index 0000000..79d197e
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/debug.vim
@@ -0,0 +1,119 @@
+let s:plugin_dir  = expand('<sfile>:p:h:h:h').'/'
+let s:log_file    = s:plugin_dir.'gitgutter.log'
+let s:channel_log = s:plugin_dir.'channel.log'
+let s:new_log_session = 1
+
+
+function! gitgutter#debug#debug()
+  " Open a scratch buffer
+  vsplit __GitGutter_Debug__
+  normal! ggdG
+  setlocal buftype=nofile
+  setlocal bufhidden=delete
+  setlocal noswapfile
+
+  call s:vim_version()
+  call s:separator()
+
+  call s:git_version()
+  call s:separator()
+
+  call s:grep_version()
+  call s:separator()
+
+  call s:option('updatetime')
+  call s:option('shell')
+  call s:option('shellcmdflag')
+  call s:option('shellpipe')
+  call s:option('shellquote')
+  call s:option('shellredir')
+  call s:option('shellslash')
+  call s:option('shelltemp')
+  call s:option('shelltype')
+  call s:option('shellxescape')
+  call s:option('shellxquote')
+endfunction
+
+
+function! s:separator()
+  call s:output('')
+endfunction
+
+function! s:vim_version()
+  redir => version_info
+    silent execute 'version'
+  redir END
+  call s:output(split(version_info, '\n')[0:2])
+endfunction
+
+function! s:git_version()
+  let v = system(g:gitgutter_git_executable.' --version')
+  call s:output( substitute(v, '\n$', '', '') )
+endfunction
+
+function! s:grep_version()
+  let v = system('grep --version')
+  call s:output( substitute(v, '\n$', '', '') )
+
+  let v = system('grep --help')
+  call s:output( substitute(v, '\%x00', '', 'g') )
+endfunction
+
+function! s:option(name)
+  if exists('+' . a:name)
+    let v = eval('&' . a:name)
+    call s:output(a:name . '=' . v)
+    " redir => output
+    "   silent execute "verbose set " . a:name . "?"
+    " redir END
+    " call s:output(a:name . '=' . output)
+  else
+    call s:output(a:name . ' [n/a]')
+  end
+endfunction
+
+function! s:output(text)
+  call append(line('$'), a:text)
+endfunction
+
+" assumes optional args are calling function's optional args
+function! gitgutter#debug#log(message, ...) abort
+  if g:gitgutter_log
+    if s:new_log_session && gitgutter#async#available()
+      if exists('*ch_logfile')
+        call ch_logfile(s:channel_log, 'w')
+      endif
+    endif
+
+    execute 'redir >> '.s:log_file
+      if s:new_log_session
+        let s:start = reltime()
+        silent echo "\n==== start log session ===="
+      endif
+
+      let elapsed = reltimestr(reltime(s:start)).' '
+      silent echo ''
+      " callers excluding this function
+      silent echo elapsed.expand('<sfile>')[:-22].':'
+      silent echo elapsed.s:format_for_log(a:message)
+      if a:0 && !empty(a:1)
+        for msg in a:000
+          silent echo elapsed.s:format_for_log(msg)
+        endfor
+      endif
+    redir END
+
+    let s:new_log_session = 0
+  endif
+endfunction
+
+function! s:format_for_log(data) abort
+  if type(a:data) == 1
+    return join(split(a:data,'\n'),"\n")
+  elseif type(a:data) == 3
+    return '['.join(a:data,"\n").']'
+  else
+    return a:data
+  endif
+endfunction
+
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/diff.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/diff.vim
new file mode 100644
index 0000000..b270db7
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/diff.vim
@@ -0,0 +1,405 @@
+let s:nomodeline = (v:version > 703 || (v:version == 703 && has('patch442'))) ? '<nomodeline>' : ''
+
+let s:hunk_re = '^@@ -\(\d\+\),\?\(\d*\) +\(\d\+\),\?\(\d*\) @@'
+
+" True for git v1.7.2+.
+function! s:git_supports_command_line_config_override() abort
+  call system(g:gitgutter_git_executable.' -c foo.bar=baz --version')
+  return !v:shell_error
+endfunction
+
+let s:c_flag = s:git_supports_command_line_config_override()
+
+
+let s:temp_from = tempname()
+let s:temp_buffer = tempname()
+let s:counter = 0
+
+" Returns a diff of the buffer against the index or the working tree.
+"
+" After running the diff we pass it through grep where available to reduce
+" subsequent processing by the plugin.  If grep is not available the plugin
+" does the filtering instead.
+"
+" When diffing against the index:
+"
+" The buffer contents is not the same as the file on disk so we need to pass
+" two instances of the file to git-diff:
+"
+"     git diff myfileA myfileB
+"
+" where myfileA comes from
+"
+"     git show :myfile > myfileA
+"
+" and myfileB is the buffer contents.
+"
+" Regarding line endings:
+"
+" git-show does not convert line endings.
+" git-diff FILE FILE does convert line endings for the given files.
+"
+" If a file has CRLF line endings and git's core.autocrlf is true,
+" the file in git's object store will have LF line endings.  Writing
+" it out via git-show will produce a file with LF line endings.
+"
+" If this last file is one of the files passed to git-diff, git-diff will
+" convert its line endings to CRLF before diffing -- which is what we want --
+" but also by default output a warning on stderr.
+"
+"   warning: LF will be replace by CRLF in <temp file>.
+"   The file will have its original line endings in your working directory.
+"
+" When running the diff asynchronously, the warning message triggers the stderr
+" callbacks which assume the overall command has failed and reset all the
+" signs.  As this is not what we want, and we can safely ignore the warning,
+" we turn it off by passing the '-c "core.safecrlf=false"' argument to
+" git-diff.
+"
+" When writing the temporary files we preserve the original file's extension
+" so that repos using .gitattributes to control EOL conversion continue to
+" convert correctly.
+"
+" Arguments:
+"
+" bufnr              - the number of the buffer to be diffed
+" from               - 'index' or 'working_tree'; what the buffer is diffed against
+" preserve_full_diff - truthy to return the full diff or falsey to return only
+"                      the hunk headers (@@ -x,y +m,n @@); only possible if
+"                      grep is available.
+function! gitgutter#diff#run_diff(bufnr, from, preserve_full_diff) abort
+  while gitgutter#utility#repo_path(a:bufnr, 0) == -1
+    sleep 5m
+  endwhile
+
+  if gitgutter#utility#repo_path(a:bufnr, 0) == -2
+    throw 'gitgutter not tracked'
+  endif
+
+  " Wrap compound commands in parentheses to make Windows happy.
+  " bash doesn't mind the parentheses.
+  let cmd = '('
+
+  " Append buffer number to temp filenames to avoid race conditions between
+  " writing and reading the files when asynchronously processing multiple
+  " buffers.
+
+  " Without the buffer number, buff_file would have a race between the
+  " second gitgutter#process_buffer() writing the file (synchronously, below)
+  " and the first gitgutter#process_buffer()'s async job reading it (with
+  " git-diff).
+  let buff_file = s:temp_buffer.'.'.a:bufnr
+
+  " Add a counter to avoid a similar race with two quick writes of the same buffer.
+  " Use a modulus greater than a maximum reasonable number of visible buffers.
+  let s:counter = (s:counter + 1) % 20
+  let buff_file .= '.'.s:counter
+
+  let extension = gitgutter#utility#extension(a:bufnr)
+  if !empty(extension)
+    let buff_file .= '.'.extension
+  endif
+
+  " Write buffer to temporary file.
+  " Note: this is synchronous.
+  call s:write_buffer(a:bufnr, buff_file)
+
+  if a:from ==# 'index'
+    " Without the buffer number, from_file would have a race in the shell
+    " between the second process writing it (with git-show) and the first
+    " reading it (with git-diff).
+    let from_file = s:temp_from.'.'.a:bufnr
+
+    " Add a counter to avoid a similar race with two quick writes of the same buffer.
+    let from_file .= '.'.s:counter
+
+    if !empty(extension)
+      let from_file .= '.'.extension
+    endif
+
+    " Write file from index to temporary file.
+    let index_name = g:gitgutter_diff_base.':'.gitgutter#utility#repo_path(a:bufnr, 1)
+    let cmd .= g:gitgutter_git_executable.' --no-pager show '.index_name.' > '.from_file.' && '
+
+  elseif a:from ==# 'working_tree'
+    let from_file = gitgutter#utility#repo_path(a:bufnr, 1)
+  endif
+
+  " Call git-diff.
+  let cmd .= g:gitgutter_git_executable.' --no-pager '.g:gitgutter_git_args
+  if s:c_flag
+    let cmd .= ' -c "diff.autorefreshindex=0"'
+    let cmd .= ' -c "diff.noprefix=false"'
+    let cmd .= ' -c "core.safecrlf=false"'
+  endif
+  let cmd .= ' diff --no-ext-diff --no-color -U0 '.g:gitgutter_diff_args.' -- '.from_file.' '.buff_file
+
+  " Pipe git-diff output into grep.
+  if !a:preserve_full_diff && !empty(g:gitgutter_grep)
+    let cmd .= ' | '.g:gitgutter_grep.' '.gitgutter#utility#shellescape('^@@ ')
+  endif
+
+  " grep exits with 1 when no matches are found; git-diff exits with 1 when
+  " differences are found.  However we want to treat non-matches and
+  " differences as non-erroneous behaviour; so we OR the command with one
+  " which always exits with success (0).
+  let cmd .= ' || exit 0'
+
+  let cmd .= ')'
+
+  let cmd = gitgutter#utility#cd_cmd(a:bufnr, cmd)
+
+  if g:gitgutter_async && gitgutter#async#available()
+    call gitgutter#async#execute(cmd, a:bufnr, {
+          \   'out': function('gitgutter#diff#handler'),
+          \   'err': function('gitgutter#hunk#reset'),
+          \ })
+    return 'async'
+
+  else
+    let diff = gitgutter#utility#system(cmd)
+
+    if v:shell_error
+      call gitgutter#debug#log(diff)
+      throw 'gitgutter diff failed'
+    endif
+
+    return diff
+  endif
+endfunction
+
+
+function! gitgutter#diff#handler(bufnr, diff) abort
+  call gitgutter#debug#log(a:diff)
+
+  if !bufexists(a:bufnr)
+    return
+  endif
+
+  call gitgutter#hunk#set_hunks(a:bufnr, gitgutter#diff#parse_diff(a:diff))
+  let modified_lines = gitgutter#diff#process_hunks(a:bufnr, gitgutter#hunk#hunks(a:bufnr))
+
+  let signs_count = len(modified_lines)
+  if signs_count > g:gitgutter_max_signs
+    call gitgutter#utility#warn_once(a:bufnr, printf(
+          \ 'exceeded maximum number of signs (%d > %d, configured by g:gitgutter_max_signs).',
+          \ signs_count, g:gitgutter_max_signs), 'max_signs')
+    call gitgutter#sign#clear_signs(a:bufnr)
+
+  else
+    if g:gitgutter_signs || g:gitgutter_highlight_lines
+      call gitgutter#sign#update_signs(a:bufnr, modified_lines)
+    endif
+  endif
+
+  call s:save_last_seen_change(a:bufnr)
+  if exists('#User#GitGutter')
+    let g:gitgutter_hook_context = {'bufnr': a:bufnr}
+    execute 'doautocmd' s:nomodeline 'User GitGutter'
+    unlet g:gitgutter_hook_context
+  endif
+endfunction
+
+
+function! gitgutter#diff#parse_diff(diff) abort
+  let hunks = []
+  for line in split(a:diff, '\n')
+    let hunk_info = gitgutter#diff#parse_hunk(line)
+    if len(hunk_info) == 4
+      call add(hunks, hunk_info)
+    endif
+  endfor
+  return hunks
+endfunction
+
+function! gitgutter#diff#parse_hunk(line) abort
+  let matches = matchlist(a:line, s:hunk_re)
+  if len(matches) > 0
+    let from_line  = str2nr(matches[1])
+    let from_count = (matches[2] == '') ? 1 : str2nr(matches[2])
+    let to_line    = str2nr(matches[3])
+    let to_count   = (matches[4] == '') ? 1 : str2nr(matches[4])
+    return [from_line, from_count, to_line, to_count]
+  else
+    return []
+  end
+endfunction
+
+" This function is public so it may be used by other plugins
+" e.g. vim-signature.
+function! gitgutter#diff#process_hunks(bufnr, hunks) abort
+  let modified_lines = []
+  for hunk in a:hunks
+    call extend(modified_lines, s:process_hunk(a:bufnr, hunk))
+  endfor
+  return modified_lines
+endfunction
+
+" Returns [ [<line_number (number)>, <name (string)>], ...]
+function! s:process_hunk(bufnr, hunk) abort
+  let modifications = []
+  let from_line  = a:hunk[0]
+  let from_count = a:hunk[1]
+  let to_line    = a:hunk[2]
+  let to_count   = a:hunk[3]
+
+  if s:is_added(from_count, to_count)
+    call s:process_added(modifications, from_count, to_count, to_line)
+    call gitgutter#hunk#increment_lines_added(a:bufnr, to_count)
+
+  elseif s:is_removed(from_count, to_count)
+    call s:process_removed(modifications, from_count, to_count, to_line)
+    call gitgutter#hunk#increment_lines_removed(a:bufnr, from_count)
+
+  elseif s:is_modified(from_count, to_count)
+    call s:process_modified(modifications, from_count, to_count, to_line)
+    call gitgutter#hunk#increment_lines_modified(a:bufnr, to_count)
+
+  elseif s:is_modified_and_added(from_count, to_count)
+    call s:process_modified_and_added(modifications, from_count, to_count, to_line)
+    call gitgutter#hunk#increment_lines_added(a:bufnr, to_count - from_count)
+    call gitgutter#hunk#increment_lines_modified(a:bufnr, from_count)
+
+  elseif s:is_modified_and_removed(from_count, to_count)
+    call s:process_modified_and_removed(modifications, from_count, to_count, to_line)
+    call gitgutter#hunk#increment_lines_modified(a:bufnr, to_count)
+    call gitgutter#hunk#increment_lines_removed(a:bufnr, from_count - to_count)
+
+  endif
+  return modifications
+endfunction
+
+function! s:is_added(from_count, to_count) abort
+  return a:from_count == 0 && a:to_count > 0
+endfunction
+
+function! s:is_removed(from_count, to_count) abort
+  return a:from_count > 0 && a:to_count == 0
+endfunction
+
+function! s:is_modified(from_count, to_count) abort
+  return a:from_count > 0 && a:to_count > 0 && a:from_count == a:to_count
+endfunction
+
+function! s:is_modified_and_added(from_count, to_count) abort
+  return a:from_count > 0 && a:to_count > 0 && a:from_count < a:to_count
+endfunction
+
+function! s:is_modified_and_removed(from_count, to_count) abort
+  return a:from_count > 0 && a:to_count > 0 && a:from_count > a:to_count
+endfunction
+
+function! s:process_added(modifications, from_count, to_count, to_line) abort
+  let offset = 0
+  while offset < a:to_count
+    let line_number = a:to_line + offset
+    call add(a:modifications, [line_number, 'added'])
+    let offset += 1
+  endwhile
+endfunction
+
+function! s:process_removed(modifications, from_count, to_count, to_line) abort
+  if a:to_line == 0
+    call add(a:modifications, [1, 'removed_first_line'])
+  else
+    call add(a:modifications, [a:to_line, 'removed'])
+  endif
+endfunction
+
+function! s:process_modified(modifications, from_count, to_count, to_line) abort
+  let offset = 0
+  while offset < a:to_count
+    let line_number = a:to_line + offset
+    call add(a:modifications, [line_number, 'modified'])
+    let offset += 1
+  endwhile
+endfunction
+
+function! s:process_modified_and_added(modifications, from_count, to_count, to_line) abort
+  let offset = 0
+  while offset < a:from_count
+    let line_number = a:to_line + offset
+    call add(a:modifications, [line_number, 'modified'])
+    let offset += 1
+  endwhile
+  while offset < a:to_count
+    let line_number = a:to_line + offset
+    call add(a:modifications, [line_number, 'added'])
+    let offset += 1
+  endwhile
+endfunction
+
+function! s:process_modified_and_removed(modifications, from_count, to_count, to_line) abort
+  let offset = 0
+  while offset < a:to_count
+    let line_number = a:to_line + offset
+    call add(a:modifications, [line_number, 'modified'])
+    let offset += 1
+  endwhile
+  let a:modifications[-1] = [a:to_line + offset - 1, 'modified_removed']
+endfunction
+
+
+" Returns a diff for the current hunk.
+" Assumes there is only 1 current hunk unless the optional argument is given,
+" in which case the cursor is in two hunks and the argument specifies the one
+" to choose.
+"
+" Optional argument: 0 (to use the first hunk) or 1 (to use the second).
+function! gitgutter#diff#hunk_diff(bufnr, full_diff, ...)
+  let modified_diff = []
+  let hunk_index = 0
+  let keep_line = 1
+  " Don't keepempty when splitting because the diff we want may not be the
+  " final one.  Instead add trailing NL at end of function.
+  for line in split(a:full_diff, '\n')
+    let hunk_info = gitgutter#diff#parse_hunk(line)
+    if len(hunk_info) == 4  " start of new hunk
+      let keep_line = gitgutter#hunk#cursor_in_hunk(hunk_info)
+
+      if a:0 && hunk_index != a:1
+        let keep_line = 0
+      endif
+
+      let hunk_index += 1
+    endif
+    if keep_line
+      call add(modified_diff, line)
+    endif
+  endfor
+  return join(modified_diff, "\n")."\n"
+endfunction
+
+
+function! s:write_buffer(bufnr, file)
+  let bufcontents = getbufline(a:bufnr, 1, '$')
+
+  if bufcontents == [''] && line2byte(1) == -1
+    " Special case: completely empty buffer.
+    " A nearly empty buffer of only a newline has line2byte(1) == 1.
+    call writefile([], a:file)
+    return
+  endif
+
+  if getbufvar(a:bufnr, '&fileformat') ==# 'dos'
+    call map(bufcontents, 'v:val."\r"')
+  endif
+
+  let fenc = getbufvar(a:bufnr, '&fileencoding')
+  if fenc !=# &encoding
+    call map(bufcontents, 'iconv(v:val, &encoding, "'.fenc.'")')
+  endif
+
+  if getbufvar(a:bufnr, '&bomb')
+    let bufcontents[0]=''.bufcontents[0]
+  endif
+
+  call writefile(bufcontents, a:file)
+endfunction
+
+
+function! s:save_last_seen_change(bufnr) abort
+  call gitgutter#utility#setbufvar(a:bufnr, 'tick', getbufvar(a:bufnr, 'changedtick'))
+endfunction
+
+
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/fold.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/fold.vim
new file mode 100644
index 0000000..ffc7691
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/fold.vim
@@ -0,0 +1,84 @@
+function! gitgutter#fold#enable()
+  call s:save_fold_state()
+
+  call s:set_fold_levels()
+  setlocal foldexpr=gitgutter#fold#level(v:lnum)
+  setlocal foldmethod=expr
+  setlocal foldlevel=0
+  setlocal foldenable
+
+  call gitgutter#utility#setbufvar(bufnr(''), 'folded', 1)
+endfunction
+
+
+function! gitgutter#fold#disable()
+  call s:restore_fold_state()
+  call gitgutter#utility#setbufvar(bufnr(''), 'folded', 0)
+endfunction
+
+
+function! gitgutter#fold#toggle()
+  if s:folded()
+    call gitgutter#fold#disable()
+  else
+    call gitgutter#fold#enable()
+  endif
+endfunction
+
+
+function! gitgutter#fold#level(lnum)
+  return gitgutter#utility#getbufvar(bufnr(''), 'fold_levels')[a:lnum]
+endfunction
+
+
+" A line in a hunk has a fold level of 0.
+" A line within 3 lines of a hunk has a fold level of 1.
+" All other lines have a fold level of 2.
+function! s:set_fold_levels()
+  let fold_levels = ['']
+
+  for lnum in range(1, line('$'))
+    let in_hunk = gitgutter#hunk#in_hunk(lnum)
+    call add(fold_levels, (in_hunk ? 0 : 2))
+  endfor
+
+  let lines_of_context = 3
+
+  for lnum in range(1, line('$'))
+    if fold_levels[lnum] == 2
+      let pre = lnum >= 3 ? lnum - lines_of_context : 0
+      let post = lnum + lines_of_context
+      if index(fold_levels[pre:post], 0) != -1
+        let fold_levels[lnum] = 1
+      endif
+    endif
+  endfor
+
+  call gitgutter#utility#setbufvar(bufnr(''), 'fold_levels', fold_levels)
+endfunction
+
+
+function! s:save_fold_state()
+  let bufnr = bufnr('')
+  call gitgutter#utility#setbufvar(bufnr, 'foldlevel', &foldlevel)
+  call gitgutter#utility#setbufvar(bufnr, 'foldmethod', &foldmethod)
+  if &foldmethod ==# 'manual'
+    mkview
+  endif
+endfunction
+
+function! s:restore_fold_state()
+  let bufnr = bufnr('')
+  let &foldlevel = gitgutter#utility#getbufvar(bufnr, 'foldlevel')
+  let &foldmethod = gitgutter#utility#getbufvar(bufnr, 'foldmethod')
+  if &foldmethod ==# 'manual'
+    loadview
+  else
+    normal! zx
+  endif
+endfunction
+
+function! s:folded()
+  return gitgutter#utility#getbufvar(bufnr(''), 'folded')
+endfunction
+
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/highlight.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/highlight.vim
new file mode 100644
index 0000000..160856f
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/highlight.vim
@@ -0,0 +1,170 @@
+function! gitgutter#highlight#line_disable() abort
+  let g:gitgutter_highlight_lines = 0
+  call s:define_sign_line_highlights()
+
+  if !g:gitgutter_signs
+    call gitgutter#sign#clear_signs(bufnr(''))
+    call gitgutter#sign#remove_dummy_sign(bufnr(''), 0)
+  endif
+
+  redraw!
+endfunction
+
+function! gitgutter#highlight#line_enable() abort
+  let old_highlight_lines = g:gitgutter_highlight_lines
+
+  let g:gitgutter_highlight_lines = 1
+  call s:define_sign_line_highlights()
+
+  if !old_highlight_lines && !g:gitgutter_signs
+    call gitgutter#all(1)
+  endif
+
+  redraw!
+endfunction
+
+function! gitgutter#highlight#line_toggle() abort
+  if g:gitgutter_highlight_lines
+    call gitgutter#highlight#line_disable()
+  else
+    call gitgutter#highlight#line_enable()
+  endif
+endfunction
+
+
+function! gitgutter#highlight#define_sign_column_highlight() abort
+  if g:gitgutter_override_sign_column_highlight
+    highlight! link SignColumn LineNr
+  else
+    highlight default link SignColumn LineNr
+  endif
+endfunction
+
+function! gitgutter#highlight#define_highlights() abort
+  let [guibg, ctermbg] = s:get_background_colors('SignColumn')
+
+  " Highlights used by the signs.
+
+  " When they are invisible.
+  execute "highlight GitGutterAddInvisible    guifg=bg guibg=" . guibg . " ctermfg=" . ctermbg . " ctermbg=" . ctermbg
+  execute "highlight GitGutterChangeInvisible guifg=bg guibg=" . guibg . " ctermfg=" . ctermbg . " ctermbg=" . ctermbg
+  execute "highlight GitGutterDeleteInvisible guifg=bg guibg=" . guibg . " ctermfg=" . ctermbg . " ctermbg=" . ctermbg
+  highlight default link GitGutterChangeDeleteInvisible GitGutterChangeInvisible
+
+  " When they are visible.
+  " By default use Diff* foreground colors with SignColumn's background.
+  for type in ['Add', 'Change', 'Delete']
+    let [guifg, ctermfg] = s:get_foreground_colors('Diff'.type)
+    execute "highlight GitGutter".type."Default guifg=".guifg." guibg=".guibg." ctermfg=".ctermfg." ctermbg=".ctermbg
+    execute "highlight default link GitGutter".type." GitGutter".type."Default"
+  endfor
+  highlight default link GitGutterChangeDelete GitGutterChange
+
+  " Highlights used for the whole line.
+
+  highlight default link GitGutterAddLine          DiffAdd
+  highlight default link GitGutterChangeLine       DiffChange
+  highlight default link GitGutterDeleteLine       DiffDelete
+  highlight default link GitGutterChangeDeleteLine GitGutterChangeLine
+endfunction
+
+function! gitgutter#highlight#define_signs() abort
+  sign define GitGutterLineAdded
+  sign define GitGutterLineModified
+  sign define GitGutterLineRemoved
+  sign define GitGutterLineRemovedFirstLine
+  sign define GitGutterLineRemovedAboveAndBelow
+  sign define GitGutterLineModifiedRemoved
+  sign define GitGutterDummy
+
+  call s:define_sign_text()
+  call gitgutter#highlight#define_sign_text_highlights()
+  call s:define_sign_line_highlights()
+endfunction
+
+function! s:define_sign_text() abort
+  execute "sign define GitGutterLineAdded                 text=" . g:gitgutter_sign_added
+  execute "sign define GitGutterLineModified              text=" . g:gitgutter_sign_modified
+  execute "sign define GitGutterLineRemoved               text=" . g:gitgutter_sign_removed
+  execute "sign define GitGutterLineRemovedFirstLine      text=" . g:gitgutter_sign_removed_first_line
+  execute "sign define GitGutterLineRemovedAboveAndBelow  text=" . g:gitgutter_sign_removed_above_and_below
+  execute "sign define GitGutterLineModifiedRemoved       text=" . g:gitgutter_sign_modified_removed
+endfunction
+
+function! gitgutter#highlight#define_sign_text_highlights() abort
+  " Once a sign's text attribute has been defined, it cannot be undefined or
+  " set to an empty value.  So to make signs' text disappear (when toggling
+  " off or disabling) we make them invisible by setting their foreground colours
+  " to the background's.
+  if g:gitgutter_signs
+    sign define GitGutterLineAdded                 texthl=GitGutterAdd
+    sign define GitGutterLineModified              texthl=GitGutterChange
+    sign define GitGutterLineRemoved               texthl=GitGutterDelete
+    sign define GitGutterLineRemovedFirstLine      texthl=GitGutterDelete
+    sign define GitGutterLineRemovedAboveAndBelow  texthl=GitGutterDelete
+    sign define GitGutterLineModifiedRemoved       texthl=GitGutterChangeDelete
+  else
+    sign define GitGutterLineAdded                 texthl=GitGutterAddInvisible
+    sign define GitGutterLineModified              texthl=GitGutterChangeInvisible
+    sign define GitGutterLineRemoved               texthl=GitGutterDeleteInvisible
+    sign define GitGutterLineRemovedFirstLine      texthl=GitGutterDeleteInvisible
+    sign define GitGutterLineRemovedAboveAndBelow  texthl=GitGutterDeleteInvisible
+    sign define GitGutterLineModifiedRemoved       texthl=GitGutterChangeDeleteInvisible
+  endif
+endfunction
+
+function! s:define_sign_line_highlights() abort
+  if g:gitgutter_highlight_lines
+    sign define GitGutterLineAdded                 linehl=GitGutterAddLine
+    sign define GitGutterLineModified              linehl=GitGutterChangeLine
+    sign define GitGutterLineRemoved               linehl=GitGutterDeleteLine
+    sign define GitGutterLineRemovedFirstLine      linehl=GitGutterDeleteLine
+    sign define GitGutterLineRemovedAboveAndBelow  linehl=GitGutterDeleteLine
+    sign define GitGutterLineModifiedRemoved       linehl=GitGutterChangeDeleteLine
+  else
+    sign define GitGutterLineAdded                 linehl=
+    sign define GitGutterLineModified              linehl=
+    sign define GitGutterLineRemoved               linehl=
+    sign define GitGutterLineRemovedFirstLine      linehl=
+    sign define GitGutterLineRemovedAboveAndBelow  linehl=
+    sign define GitGutterLineModifiedRemoved       linehl=
+  endif
+endfunction
+
+function! s:get_foreground_colors(group) abort
+  redir => highlight
+  silent execute 'silent highlight ' . a:group
+  redir END
+
+  let link_matches = matchlist(highlight, 'links to \(\S\+\)')
+  if len(link_matches) > 0 " follow the link
+    return s:get_foreground_colors(link_matches[1])
+  endif
+
+  let ctermfg = s:match_highlight(highlight, 'ctermfg=\([0-9A-Za-z]\+\)')
+  let guifg   = s:match_highlight(highlight, 'guifg=\([#0-9A-Za-z]\+\)')
+  return [guifg, ctermfg]
+endfunction
+
+function! s:get_background_colors(group) abort
+  redir => highlight
+  silent execute 'silent highlight ' . a:group
+  redir END
+
+  let link_matches = matchlist(highlight, 'links to \(\S\+\)')
+  if len(link_matches) > 0 " follow the link
+    return s:get_background_colors(link_matches[1])
+  endif
+
+  let ctermbg = s:match_highlight(highlight, 'ctermbg=\([0-9A-Za-z]\+\)')
+  let guibg   = s:match_highlight(highlight, 'guibg=\([#0-9A-Za-z]\+\)')
+  return [guibg, ctermbg]
+endfunction
+
+function! s:match_highlight(highlight, pattern) abort
+  let matches = matchlist(a:highlight, a:pattern)
+  if len(matches) == 0
+    return 'NONE'
+  endif
+  return matches[1]
+endfunction
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/hunk.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/hunk.vim
new file mode 100644
index 0000000..50ea5f4
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/hunk.vim
@@ -0,0 +1,332 @@
+function! gitgutter#hunk#set_hunks(bufnr, hunks) abort
+  call gitgutter#utility#setbufvar(a:bufnr, 'hunks', a:hunks)
+  call s:reset_summary(a:bufnr)
+endfunction
+
+function! gitgutter#hunk#hunks(bufnr) abort
+  return gitgutter#utility#getbufvar(a:bufnr, 'hunks', [])
+endfunction
+
+function! gitgutter#hunk#reset(bufnr) abort
+  call gitgutter#utility#setbufvar(a:bufnr, 'hunks', [])
+  call s:reset_summary(a:bufnr)
+endfunction
+
+
+function! gitgutter#hunk#summary(bufnr) abort
+  return gitgutter#utility#getbufvar(a:bufnr, 'summary', [0,0,0])
+endfunction
+
+function! s:reset_summary(bufnr) abort
+  call gitgutter#utility#setbufvar(a:bufnr, 'summary', [0,0,0])
+endfunction
+
+function! gitgutter#hunk#increment_lines_added(bufnr, count) abort
+  let summary = gitgutter#hunk#summary(a:bufnr)
+  let summary[0] += a:count
+  call gitgutter#utility#setbufvar(a:bufnr, 'summary', summary)
+endfunction
+
+function! gitgutter#hunk#increment_lines_modified(bufnr, count) abort
+  let summary = gitgutter#hunk#summary(a:bufnr)
+  let summary[1] += a:count
+  call gitgutter#utility#setbufvar(a:bufnr, 'summary', summary)
+endfunction
+
+function! gitgutter#hunk#increment_lines_removed(bufnr, count) abort
+  let summary = gitgutter#hunk#summary(a:bufnr)
+  let summary[2] += a:count
+  call gitgutter#utility#setbufvar(a:bufnr, 'summary', summary)
+endfunction
+
+
+function! gitgutter#hunk#next_hunk(count) abort
+  let bufnr = bufnr('')
+  if gitgutter#utility#is_active(bufnr)
+    let current_line = line('.')
+    let hunk_count = 0
+    for hunk in gitgutter#hunk#hunks(bufnr)
+      if hunk[2] > current_line
+        let hunk_count += 1
+        if hunk_count == a:count
+          execute 'normal!' hunk[2] . 'Gzv'
+          return
+        endif
+      endif
+    endfor
+    call gitgutter#utility#warn('No more hunks')
+  endif
+endfunction
+
+function! gitgutter#hunk#prev_hunk(count) abort
+  let bufnr = bufnr('')
+  if gitgutter#utility#is_active(bufnr)
+    let current_line = line('.')
+    let hunk_count = 0
+    for hunk in reverse(copy(gitgutter#hunk#hunks(bufnr)))
+      if hunk[2] < current_line
+        let hunk_count += 1
+        if hunk_count == a:count
+          let target = hunk[2] == 0 ? 1 : hunk[2]
+          execute 'normal!' target . 'Gzv'
+          return
+        endif
+      endif
+    endfor
+    call gitgutter#utility#warn('No previous hunks')
+  endif
+endfunction
+
+" Returns the hunk the cursor is currently in or an empty list if the cursor
+" isn't in a hunk.
+function! s:current_hunk() abort
+  let bufnr = bufnr('')
+  let current_hunk = []
+
+  for hunk in gitgutter#hunk#hunks(bufnr)
+    if gitgutter#hunk#cursor_in_hunk(hunk)
+      let current_hunk = hunk
+      break
+    endif
+  endfor
+
+  return current_hunk
+endfunction
+
+" Returns truthy if the cursor is in two hunks (which can only happen if the
+" cursor is on the first line and lines above have been deleted and lines
+" immediately below have been deleted) or falsey otherwise.
+function! s:cursor_in_two_hunks()
+  let hunks = gitgutter#hunk#hunks(bufnr(''))
+
+  if line('.') == 1 && len(hunks) > 1 && hunks[0][2:3] == [0, 0] && hunks[1][2:3] == [1, 0]
+    return 1
+  endif
+
+  return 0
+endfunction
+
+" A line can be in 0 or 1 hunks, with the following exception: when the first
+" line(s) of a file has been deleted, and the new second line (and
+" optionally below) has been deleted, the new first line is in two hunks.
+function! gitgutter#hunk#cursor_in_hunk(hunk) abort
+  let current_line = line('.')
+
+  if current_line == 1 && a:hunk[2] == 0
+    return 1
+  endif
+
+  if current_line >= a:hunk[2] && current_line < a:hunk[2] + (a:hunk[3] == 0 ? 1 : a:hunk[3])
+    return 1
+  endif
+
+  return 0
+endfunction
+
+
+function! gitgutter#hunk#in_hunk(lnum)
+  " Hunks are sorted in the order they appear in the buffer.
+  for hunk in gitgutter#hunk#hunks(bufnr(''))
+    " if in a hunk on first line of buffer
+    if a:lnum == 1 && hunk[2] == 0
+      return 1
+    endif
+
+    " if in a hunk generally
+    if a:lnum >= hunk[2] && a:lnum < hunk[2] + (hunk[3] == 0 ? 1 : hunk[3])
+      return 1
+    endif
+
+    " if hunk starts after the given line
+    if a:lnum < hunk[2]
+      return 0
+    endif
+  endfor
+
+  return 0
+endfunction
+
+
+function! gitgutter#hunk#text_object(inner) abort
+  let hunk = s:current_hunk()
+
+  if empty(hunk)
+    return
+  endif
+
+  let [first_line, last_line] = [hunk[2], hunk[2] + hunk[3] - 1]
+
+  if ! a:inner
+    let lnum = last_line
+    let eof = line('$')
+    while lnum < eof && empty(getline(lnum + 1))
+      let lnum +=1
+    endwhile
+    let last_line = lnum
+  endif
+
+  execute 'normal! 'first_line.'GV'.last_line.'G'
+endfunction
+
+
+function! gitgutter#hunk#stage() abort
+  call s:hunk_op(function('s:stage'))
+  silent! call repeat#set("\<Plug>GitGutterStageHunk", -1)<CR>
+endfunction
+
+function! gitgutter#hunk#undo() abort
+  call s:hunk_op(function('s:undo'))
+  silent! call repeat#set("\<Plug>GitGutterUndoHunk", -1)<CR>
+endfunction
+
+function! gitgutter#hunk#preview() abort
+  call s:hunk_op(function('s:preview'))
+  silent! call repeat#set("\<Plug>GitGutterPreviewHunk", -1)<CR>
+endfunction
+
+
+function! s:hunk_op(op)
+  let bufnr = bufnr('')
+
+  if gitgutter#utility#is_active(bufnr)
+    " Get a (synchronous) diff.
+    let [async, g:gitgutter_async] = [g:gitgutter_async, 0]
+    let diff = gitgutter#diff#run_diff(bufnr, 'index', 1)
+    let g:gitgutter_async = async
+
+    call gitgutter#hunk#set_hunks(bufnr, gitgutter#diff#parse_diff(diff))
+
+    if empty(s:current_hunk())
+      call gitgutter#utility#warn('cursor is not in a hunk')
+    elseif s:cursor_in_two_hunks()
+      let choice = input('Choose hunk: upper or lower (u/l)? ')
+      " Clear input
+      normal! :<ESC>
+      if choice =~ 'u'
+        call a:op(gitgutter#diff#hunk_diff(bufnr, diff, 0))
+      elseif choice =~ 'l'
+        call a:op(gitgutter#diff#hunk_diff(bufnr, diff, 1))
+      else
+        call gitgutter#utility#warn('did not recognise your choice')
+      endif
+    else
+      call a:op(gitgutter#diff#hunk_diff(bufnr, diff))
+    endif
+  endif
+endfunction
+
+
+function! s:stage(hunk_diff)
+  let bufnr = bufnr('')
+  let diff = s:adjust_header(bufnr, a:hunk_diff)
+  " Apply patch to index.
+  call gitgutter#utility#system(
+        \ gitgutter#utility#cd_cmd(bufnr, g:gitgutter_git_executable.' apply --cached --unidiff-zero - '),
+        \ diff)
+
+  " Refresh gitgutter's view of buffer.
+  call gitgutter#process_buffer(bufnr, 1)
+endfunction
+
+
+function! s:undo(hunk_diff)
+  " Apply reverse patch to buffer.
+  let hunk  = gitgutter#diff#parse_hunk(split(a:hunk_diff, '\n')[4])
+  let lines = map(split(a:hunk_diff, '\n')[5:], 'v:val[1:]')
+  let lnum  = hunk[2]
+  let added_only   = hunk[1] == 0 && hunk[3]  > 0
+  let removed_only = hunk[1]  > 0 && hunk[3] == 0
+
+  if removed_only
+    call append(lnum, lines)
+  elseif added_only
+    execute lnum .','. (lnum+len(lines)-1) .'d'
+  else
+    call append(lnum-1, lines[0:hunk[1]])
+    execute (lnum+hunk[1]) .','. (lnum+hunk[1]+hunk[3]) .'d'
+  endif
+endfunction
+
+
+function! s:preview(hunk_diff)
+  let hunk_lines = split(s:discard_header(a:hunk_diff), "\n")
+  let hunk_lines_length = len(hunk_lines)
+  let previewheight = min([hunk_lines_length, &previewheight])
+
+  silent! wincmd P
+  if !&previewwindow
+    noautocmd execute 'bo' previewheight 'new'
+    set previewwindow
+  else
+    execute 'resize' previewheight
+  endif
+
+  setlocal noreadonly modifiable filetype=diff buftype=nofile bufhidden=delete noswapfile
+  execute "%delete_"
+  call append(0, hunk_lines)
+  normal! gg
+  setlocal readonly nomodifiable
+
+  noautocmd wincmd p
+endfunction
+
+
+function! s:adjust_header(bufnr, hunk_diff)
+  let filepath = gitgutter#utility#repo_path(a:bufnr, 0)
+  return s:adjust_hunk_summary(s:fix_file_references(filepath, a:hunk_diff))
+endfunction
+
+
+" Replaces references to temp files with the actual file.
+function! s:fix_file_references(filepath, hunk_diff)
+  let lines = split(a:hunk_diff, '\n')
+
+  let left_prefix  = matchstr(lines[2], '[abciow12]').'/'
+  let right_prefix = matchstr(lines[3], '[abciow12]').'/'
+  let quote        = lines[0][11] == '"' ? '"' : ''
+
+  let left_file  = quote.left_prefix.a:filepath.quote
+  let right_file = quote.right_prefix.a:filepath.quote
+
+  let lines[0] = 'diff --git '.left_file.' '.right_file
+  let lines[2] = '--- '.left_file
+  let lines[3] = '+++ '.right_file
+
+  return join(lines, "\n")."\n"
+endfunction
+
+if $VIM_GITGUTTER_TEST
+  function! gitgutter#hunk#fix_file_references(filepath, hunk_diff)
+    return s:fix_file_references(a:filepath, a:hunk_diff)
+  endfunction
+endif
+
+
+function! s:adjust_hunk_summary(hunk_diff) abort
+  let line_adjustment = s:line_adjustment_for_current_hunk()
+  let diff = split(a:hunk_diff, '\n', 1)
+  let diff[4] = substitute(diff[4], '+\@<=\(\d\+\)', '\=submatch(1)+line_adjustment', '')
+  return join(diff, "\n")
+endfunction
+
+
+function! s:discard_header(hunk_diff)
+  return join(split(a:hunk_diff, '\n', 1)[5:], "\n")
+endfunction
+
+
+" Returns the number of lines the current hunk is offset from where it would
+" be if any changes above it in the file didn't exist.
+function! s:line_adjustment_for_current_hunk() abort
+  let bufnr = bufnr('')
+  let adj = 0
+  for hunk in gitgutter#hunk#hunks(bufnr)
+    if gitgutter#hunk#cursor_in_hunk(hunk)
+      break
+    else
+      let adj += hunk[1] - hunk[3]
+    endif
+  endfor
+  return adj
+endfunction
+
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/sign.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/sign.vim
new file mode 100644
index 0000000..4c23dbe
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/sign.vim
@@ -0,0 +1,230 @@
+" Vim doesn't namespace sign ids so every plugin shares the same
+" namespace.  Sign ids are simply integers so to avoid clashes with other
+" signs we guess at a clear run.
+"
+" Note also we currently never reset s:next_sign_id.
+let s:first_sign_id = 3000
+let s:next_sign_id  = s:first_sign_id
+let s:dummy_sign_id = s:first_sign_id - 1
+" Remove-all-signs optimisation requires Vim 7.3.596+.
+let s:supports_star = v:version > 703 || (v:version == 703 && has("patch596"))
+
+
+function! gitgutter#sign#enable() abort
+  let old_signs = g:gitgutter_signs
+
+  let g:gitgutter_signs = 1
+  call gitgutter#highlight#define_sign_text_highlights()
+
+  if !old_signs && !g:gitgutter_highlight_lines
+    call gitgutter#all(1)
+  endif
+endfunction
+
+function! gitgutter#sign#disable() abort
+  let g:gitgutter_signs = 0
+  call gitgutter#highlight#define_sign_text_highlights()
+
+  if !g:gitgutter_highlight_lines
+    call gitgutter#sign#clear_signs(bufnr(''))
+    call gitgutter#sign#remove_dummy_sign(bufnr(''), 0)
+  endif
+endfunction
+
+function! gitgutter#sign#toggle() abort
+  if g:gitgutter_signs
+    call gitgutter#sign#disable()
+  else
+    call gitgutter#sign#enable()
+  endif
+endfunction
+
+
+" Removes gitgutter's signs (excluding dummy sign) from the buffer being processed.
+function! gitgutter#sign#clear_signs(bufnr) abort
+  call s:find_current_signs(a:bufnr)
+
+  let sign_ids = map(values(gitgutter#utility#getbufvar(a:bufnr, 'gitgutter_signs')), 'v:val.id')
+  call s:remove_signs(a:bufnr, sign_ids, 1)
+  call gitgutter#utility#setbufvar(a:bufnr, 'gitgutter_signs', {})
+endfunction
+
+
+" Updates gitgutter's signs in the buffer being processed.
+"
+" modified_lines: list of [<line_number (number)>, <name (string)>]
+" where name = 'added|removed|modified|modified_removed'
+function! gitgutter#sign#update_signs(bufnr, modified_lines) abort
+  call s:find_current_signs(a:bufnr)
+
+  let new_gitgutter_signs_line_numbers = map(copy(a:modified_lines), 'v:val[0]')
+  let obsolete_signs = s:obsolete_gitgutter_signs_to_remove(a:bufnr, new_gitgutter_signs_line_numbers)
+
+  let flicker_possible = s:remove_all_old_signs && !empty(a:modified_lines)
+  if flicker_possible
+    call s:add_dummy_sign(a:bufnr)
+  endif
+
+  call s:remove_signs(a:bufnr, obsolete_signs, s:remove_all_old_signs)
+  call s:upsert_new_gitgutter_signs(a:bufnr, a:modified_lines)
+
+  if flicker_possible
+    call gitgutter#sign#remove_dummy_sign(a:bufnr, 0)
+  endif
+endfunction
+
+
+function! s:add_dummy_sign(bufnr) abort
+  if !gitgutter#utility#getbufvar(a:bufnr, 'dummy_sign')
+    execute "sign place" s:dummy_sign_id "line=" . 9999 "name=GitGutterDummy buffer=" . a:bufnr
+    call gitgutter#utility#setbufvar(a:bufnr, 'dummy_sign', 1)
+  endif
+endfunction
+
+function! gitgutter#sign#remove_dummy_sign(bufnr, force) abort
+  if gitgutter#utility#getbufvar(a:bufnr, 'dummy_sign') && (a:force || !g:gitgutter_sign_column_always)
+    execute "sign unplace" s:dummy_sign_id "buffer=" . a:bufnr
+    call gitgutter#utility#setbufvar(a:bufnr, 'dummy_sign', 0)
+  endif
+endfunction
+
+
+"
+" Internal functions
+"
+
+
+function! s:find_current_signs(bufnr) abort
+  let gitgutter_signs = {}  " <line_number (string)>: {'id': <id (number)>, 'name': <name (string)>}
+  let other_signs = []      " [<line_number (number),...]
+  let dummy_sign_placed = 0
+
+  redir => signs
+    silent execute "sign place buffer=" . a:bufnr
+  redir END
+
+  for sign_line in filter(split(signs, '\n')[2:], 'v:val =~# "="')
+    " Typical sign line:  line=88 id=1234 name=GitGutterLineAdded
+    " We assume splitting is faster than a regexp.
+    let components  = split(sign_line)
+    let name        = split(components[2], '=')[1]
+    if name =~# 'GitGutterDummy'
+      let dummy_sign_placed = 1
+    else
+      let line_number = str2nr(split(components[0], '=')[1])
+      if name =~# 'GitGutter'
+        let id = str2nr(split(components[1], '=')[1])
+        " Remove orphaned signs (signs placed on lines which have been deleted).
+        " (When a line is deleted its sign lingers.  Subsequent lines' signs'
+        " line numbers are decremented appropriately.)
+        if has_key(gitgutter_signs, line_number)
+          execute "sign unplace" gitgutter_signs[line_number].id
+        endif
+        let gitgutter_signs[line_number] = {'id': id, 'name': name}
+      else
+        call add(other_signs, line_number)
+      endif
+    end
+  endfor
+
+  call gitgutter#utility#setbufvar(a:bufnr, 'dummy_sign', dummy_sign_placed)
+  call gitgutter#utility#setbufvar(a:bufnr, 'gitgutter_signs', gitgutter_signs)
+  call gitgutter#utility#setbufvar(a:bufnr, 'other_signs', other_signs)
+endfunction
+
+
+" Returns a list of [<id (number)>, ...]
+" Sets `s:remove_all_old_signs` as a side-effect.
+function! s:obsolete_gitgutter_signs_to_remove(bufnr, new_gitgutter_signs_line_numbers) abort
+  let signs_to_remove = []  " list of [<id (number)>, ...]
+  let remove_all_signs = 1
+  let old_gitgutter_signs = gitgutter#utility#getbufvar(a:bufnr, 'gitgutter_signs')
+  for line_number in keys(old_gitgutter_signs)
+    if index(a:new_gitgutter_signs_line_numbers, str2nr(line_number)) == -1
+      call add(signs_to_remove, old_gitgutter_signs[line_number].id)
+    else
+      let remove_all_signs = 0
+    endif
+  endfor
+  let s:remove_all_old_signs = remove_all_signs
+  return signs_to_remove
+endfunction
+
+
+function! s:remove_signs(bufnr, sign_ids, all_signs) abort
+  if a:all_signs && s:supports_star && empty(gitgutter#utility#getbufvar(a:bufnr, 'other_signs'))
+    let dummy_sign_present = gitgutter#utility#getbufvar(a:bufnr, 'dummy_sign')
+    execute "sign unplace * buffer=" . a:bufnr
+    if dummy_sign_present
+      execute "sign place" s:dummy_sign_id "line=" . 9999 "name=GitGutterDummy buffer=" . a:bufnr
+    endif
+  else
+    for id in a:sign_ids
+      execute "sign unplace" id
+    endfor
+  endif
+endfunction
+
+
+function! s:upsert_new_gitgutter_signs(bufnr, modified_lines) abort
+  let other_signs         = gitgutter#utility#getbufvar(a:bufnr, 'other_signs')
+  let old_gitgutter_signs = gitgutter#utility#getbufvar(a:bufnr, 'gitgutter_signs')
+
+  " Handle special case where the first line is the site of two hunks:
+  " lines deleted above at the start of the file, and lines deleted
+  " immediately below.
+  if a:modified_lines[0:1] == [[1, 'removed_first_line'], [1, 'removed']]
+    let modified_lines = [[1, 'removed_above_and_below']] + a:modified_lines[2:]
+  else
+    let modified_lines = a:modified_lines
+  endif
+
+  for line in modified_lines
+    let line_number = line[0]  " <number>
+    if index(other_signs, line_number) == -1  " don't clobber others' signs
+      let name = s:highlight_name_for_change(line[1])
+      if !has_key(old_gitgutter_signs, line_number)  " insert
+        let id = s:next_sign_id()
+        execute "sign place" id "line=" . line_number "name=" . name "buffer=" . a:bufnr
+      else  " update if sign has changed
+        let old_sign = old_gitgutter_signs[line_number]
+        if old_sign.name !=# name
+          execute "sign place" old_sign.id "name=" . name "buffer=" . a:bufnr
+        end
+      endif
+    endif
+  endfor
+  " At this point b:gitgutter_gitgutter_signs is out of date.
+endfunction
+
+
+function! s:next_sign_id() abort
+  let next_id = s:next_sign_id
+  let s:next_sign_id += 1
+  return next_id
+endfunction
+
+
+" Only for testing.
+function! gitgutter#sign#reset()
+  let s:next_sign_id  = s:first_sign_id
+endfunction
+
+
+function! s:highlight_name_for_change(text) abort
+  if a:text ==# 'added'
+    return 'GitGutterLineAdded'
+  elseif a:text ==# 'removed'
+    return 'GitGutterLineRemoved'
+  elseif a:text ==# 'removed_first_line'
+    return 'GitGutterLineRemovedFirstLine'
+  elseif a:text ==# 'modified'
+    return 'GitGutterLineModified'
+  elseif a:text ==# 'modified_removed'
+    return 'GitGutterLineModifiedRemoved'
+  elseif a:text ==# 'removed_above_and_below'
+    return 'GitGutterLineRemovedAboveAndBelow'
+  endif
+endfunction
+
+
diff --git a/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/utility.vim b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/utility.vim
new file mode 100644
index 0000000..470f222
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/autoload/gitgutter/utility.vim
@@ -0,0 +1,222 @@
+function! gitgutter#utility#supports_overscore_sign()
+  if gitgutter#utility#windows()
+    return &encoding ==? 'utf-8'
+  else
+    return &termencoding ==? &encoding || &termencoding == ''
+  endif
+endfunction
+
+function! gitgutter#utility#setbufvar(buffer, varname, val)
+  let buffer = +a:buffer
+  " Default value for getbufvar() was introduced in Vim 7.3.831.
+  let bvars = getbufvar(buffer, '')
+  if empty(bvars)
+    let bvars = {}
+  endif
+  let dict = get(bvars, 'gitgutter', {})
+  let needs_setting = empty(dict)
+  let dict[a:varname] = a:val
+  if needs_setting
+    call setbufvar(buffer, 'gitgutter', dict)
+  endif
+endfunction
+
+function! gitgutter#utility#getbufvar(buffer, varname, ...)
+  let dict = get(getbufvar(a:buffer, ''), 'gitgutter', {})
+  if has_key(dict, a:varname)
+    return dict[a:varname]
+  else
+    if a:0
+      return a:1
+    endif
+  endif
+endfunction
+
+function! gitgutter#utility#warn(message) abort
+  echohl WarningMsg
+  echo 'vim-gitgutter: ' . a:message
+  echohl None
+  let v:warningmsg = a:message
+endfunction
+
+function! gitgutter#utility#warn_once(bufnr, message, key) abort
+  if empty(gitgutter#utility#getbufvar(a:bufnr, a:key))
+    call gitgutter#utility#setbufvar(a:bufnr, a:key, '1')
+    echohl WarningMsg
+    redraw | echom 'vim-gitgutter: ' . a:message
+    echohl None
+    let v:warningmsg = a:message
+  endif
+endfunction
+
+" Returns truthy when the buffer's file should be processed; and falsey when it shouldn't.
+" This function does not and should not make any system calls.
+function! gitgutter#utility#is_active(bufnr) abort
+  return g:gitgutter_enabled &&
+        \ gitgutter#utility#getbufvar(a:bufnr, 'enabled', 1) &&
+        \ !pumvisible() &&
+        \ s:is_file_buffer(a:bufnr) &&
+        \ s:exists_file(a:bufnr) &&
+        \ s:not_git_dir(a:bufnr)
+endfunction
+
+function! s:not_git_dir(bufnr) abort
+  return s:dir(a:bufnr) !~ '[/\\]\.git\($\|[/\\]\)'
+endfunction
+
+function! s:is_file_buffer(bufnr) abort
+  return empty(getbufvar(a:bufnr, '&buftype'))
+endfunction
+
+" From tpope/vim-fugitive
+function! s:winshell()
+  return &shell =~? 'cmd' || exists('+shellslash') && !&shellslash
+endfunction
+
+" From tpope/vim-fugitive
+function! gitgutter#utility#shellescape(arg) abort
+  if a:arg =~ '^[A-Za-z0-9_/.-]\+$'
+    return a:arg
+  elseif s:winshell()
+    return '"' . substitute(substitute(a:arg, '"', '""', 'g'), '%', '"%"', 'g') . '"'
+  else
+    return shellescape(a:arg)
+  endif
+endfunction
+
+function! gitgutter#utility#file(bufnr)
+  return s:abs_path(a:bufnr, 1)
+endfunction
+
+" Not shellescaped
+function! gitgutter#utility#extension(bufnr) abort
+  return fnamemodify(s:abs_path(a:bufnr, 0), ':e')
+endfunction
+
+function! gitgutter#utility#system(cmd, ...) abort
+  call gitgutter#debug#log(a:cmd, a:000)
+
+  call s:use_known_shell()
+  silent let output = (a:0 == 0) ? system(a:cmd) : system(a:cmd, a:1)
+  call s:restore_shell()
+
+  return output
+endfunction
+
+" Path of file relative to repo root.
+"
+" *     empty string - not set
+" * non-empty string - path
+" *               -1 - pending
+" *               -2 - not tracked by git
+function! gitgutter#utility#repo_path(bufnr, shellesc) abort
+  let p = gitgutter#utility#getbufvar(a:bufnr, 'path')
+  return a:shellesc ? gitgutter#utility#shellescape(p) : p
+endfunction
+
+function! gitgutter#utility#set_repo_path(bufnr) abort
+  " Values of path:
+  " * non-empty string - path
+  " *               -1 - pending
+  " *               -2 - not tracked by git
+
+  call gitgutter#utility#setbufvar(a:bufnr, 'path', -1)
+  let cmd = gitgutter#utility#cd_cmd(a:bufnr, g:gitgutter_git_executable.' ls-files --error-unmatch --full-name -z -- '.gitgutter#utility#shellescape(s:filename(a:bufnr)))
+
+  if g:gitgutter_async && gitgutter#async#available()
+    if has('lambda')
+      call gitgutter#async#execute(cmd, a:bufnr, {
+            \   'out': {bufnr, path -> gitgutter#utility#setbufvar(bufnr, 'path', s:strip_trailing_new_line(path))},
+            \   'err': {bufnr       -> gitgutter#utility#setbufvar(bufnr, 'path', -2)},
+            \ })
+    else
+      if has('nvim') && !has('nvim-0.2.0')
+        call gitgutter#async#execute(cmd, a:bufnr, {
+              \   'out': function('s:set_path'),
+              \   'err': function('s:not_tracked_by_git')
+              \ })
+      else
+        call gitgutter#async#execute(cmd, a:bufnr, {
+              \   'out': function('s:set_path'),
+              \   'err': function('s:set_path', [-2])
+              \ })
+      endif
+    endif
+  else
+    let path = gitgutter#utility#system(cmd)
+    if v:shell_error
+      call gitgutter#utility#setbufvar(a:bufnr, 'path', -2)
+    else
+      call gitgutter#utility#setbufvar(a:bufnr, 'path', s:strip_trailing_new_line(path))
+    endif
+  endif
+endfunction
+
+if has('nvim') && !has('nvim-0.2.0')
+  function! s:not_tracked_by_git(bufnr)
+    call s:set_path(a:bufnr, -2)
+  endfunction
+endif
+
+function! s:set_path(bufnr, path)
+  if a:bufnr == -2
+    let [bufnr, path] = [a:path, a:bufnr]
+    call gitgutter#utility#setbufvar(bufnr, 'path', path)
+  else
+    call gitgutter#utility#setbufvar(a:bufnr, 'path', s:strip_trailing_new_line(a:path))
+  endif
+endfunction
+
+function! gitgutter#utility#cd_cmd(bufnr, cmd) abort
+  let cd = s:unc_path(a:bufnr) ? 'pushd' : (gitgutter#utility#windows() ? 'cd /d' : 'cd')
+  return cd.' '.s:dir(a:bufnr).' && '.a:cmd
+endfunction
+
+function! s:unc_path(bufnr)
+  return s:abs_path(a:bufnr, 0) =~ '^\\\\'
+endfunction
+
+function! s:use_known_shell() abort
+  if has('unix') && &shell !=# 'sh'
+    let [s:shell, s:shellcmdflag, s:shellredir] = [&shell, &shellcmdflag, &shellredir]
+    let &shell = 'sh'
+    set shellcmdflag=-c shellredir=>%s\ 2>&1
+  endif
+endfunction
+
+function! s:restore_shell() abort
+  if has('unix') && exists('s:shell')
+    let [&shell, &shellcmdflag, &shellredir] = [s:shell, s:shellcmdflag, s:shellredir]
+  endif
+endfunction
+
+function! s:abs_path(bufnr, shellesc)
+  let p = resolve(expand('#'.a:bufnr.':p'))
+  return a:shellesc ? gitgutter#utility#shellescape(p) : p
+endfunction
+
+function! s:dir(bufnr) abort
+  return gitgutter#utility#shellescape(fnamemodify(s:abs_path(a:bufnr, 0), ':h'))
+endfunction
+
+" Not shellescaped.
+function! s:filename(bufnr) abort
+  return fnamemodify(s:abs_path(a:bufnr, 0), ':t')
+endfunction
+
+function! s:exists_file(bufnr) abort
+  return filereadable(s:abs_path(a:bufnr, 0))
+endfunction
+
+" Get rid of any trailing new line or SOH character.
+"
+" git ls-files -z produces output with null line termination.
+" Vim's system() replaces any null characters in the output
+" with SOH (start of header), i.e. ^A.
+function! s:strip_trailing_new_line(line) abort
+  return substitute(a:line, '[[:cntrl:]]$', '', '')
+endfunction
+
+function! gitgutter#utility#windows()
+  return has('win64') || has('win32') || has('win16')
+endfunction
diff --git a/vim/.vim/plugged/vim-gitgutter/doc/gitgutter.txt b/vim/.vim/plugged/vim-gitgutter/doc/gitgutter.txt
new file mode 100644
index 0000000..87825da
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/doc/gitgutter.txt
@@ -0,0 +1,549 @@
+*gitgutter.txt*              A Vim plugin which shows a git diff in the gutter.
+
+
+                           Vim Git Gutter
+
+
+Author:            Andy Stewart <https://airbladesoftware.com/>
+Plugin Homepage:   <https://github.com/airblade/vim-gitgutter>
+
+
+===============================================================================
+CONTENTS                                                            *gitgutter*
+
+  Introduction ................. |gitgutter-introduction|
+  Installation ................. |gitgutter-installation|
+  Commands ..................... |gitgutter-commands|
+  Mappings ..................... |gitgutter-mappings|
+  Autocommand .................. |gitgutter-autocommand|
+  Options ...................... |gitgutter-options|
+  Highlights ................... |gitgutter-highlights|
+  FAQ .......................... |gitgutter-faq|
+  TROUBLESHOOTING .............. |gitgutter-troubleshooting|
+
+
+===============================================================================
+INTRODUCTION                                           *gitgutter-introduction*
+
+GitGutter is a Vim plugin which shows a git diff in the 'gutter' (sign column).
+It shows which lines have been added, modified, or removed.  You can also
+preview, stage, and undo individual hunks.  The plugin also provides a hunk
+text object.
+
+The signs are always up to date and the plugin never saves your buffer.
+
+
+===============================================================================
+INSTALLATION                                           *gitgutter-installation*
+
+Pathogen:~
+>
+  cd ~/.vim/bundle
+  git clone git://github.com/airblade/vim-gitgutter.git
+<
+Voom:~
+
+Edit your plugin manifest (`voom edit`) and add:
+>
+  airblade/vim-gitgutter
+<
+VimPlug:~
+
+Place this in your .vimrc:
+>
+    Plug 'airblade/vim-gitgutter'
+<
+Then run the following in Vim:
+>
+  :source %
+  :PlugInstall
+<
+NeoBundle:~
+
+Place this in your .vimrc:
+>
+  NeoBundle 'airblade/vim-gitgutter'
+<
+Then run the following in Vim:
+>
+  :source %
+  :NeoBundleInstall
+<
+No plugin manager:~
+
+Copy vim-gitgutter's subdirectories into your vim configuration directory:
+>
+  cd tmp && git clone git://github.com/airblade/vim-gitgutter.git
+  cp vim-gitgutter/* ~/.vim/
+<
+See |add-global-plugin|.
+
+
+===============================================================================
+COMMANDS                                                   *gitgutter-commands*
+
+Commands for turning vim-gitgutter on and off:~
+
+                                                  *gitgutter-:GitGutterDisable*
+:GitGutterDisable       Turn vim-gitgutter off for all buffers.
+
+                                                   *gitgutter-:GitGutterEnable*
+:GitGutterEnable        Turn vim-gitgutter on for all buffers.
+
+                                                   *gitgutter-:GitGutterToggle*
+:GitGutterToggle        Toggle vim-gitgutter on or off for all buffers.
+
+                                                         *gitgutter-:GitGutter*
+:GitGutter              Update signs for the current buffer.  You shouldn't
+                        need to run this.
+
+                                                      *gitgutter-:GitGutterAll*
+:GitGutterAll           Update signs for all buffers.  You shouldn't need to
+                        run this.
+
+
+Commands for turning signs on and off (defaults to on):~
+
+                                              *gitgutter-:GitGutterSignsEnable*
+:GitGutterSignsEnable   Show signs for the diff.
+
+                                             *gitgutter-:GitGutterSignsDisable*
+:GitGutterSignsDisable  Do not show signs for the diff.
+
+                                              *gitgutter-:GitGutterSignsToggle*
+:GitGutterSignsToggle   Toggle signs on or off.
+
+
+Commands for turning line highlighting on and off (defaults to off):~
+
+                                     *gitgutter-:GitGutterLineHighlightsEnable*
+:GitGutterLineHighlightsEnable  Turn on line highlighting.
+
+                                    *gitgutter-:GitGutterLineHighlightsDisable*
+:GitGutterLineHighlightsDisable Turn off line highlighting.
+
+                                     *gitgutter-:GitGutterLineHighlightsToggle*
+:GitGutterLineHighlightsToggle  Turn line highlighting on or off.
+
+
+Commands for jumping between hunks:~
+
+                                                 *gitgutter-:GitGutterNextHunk*
+:GitGutterNextHunk      Jump to the next [count] hunk.
+
+                                                 *gitgutter-:GitGutterPrevHunk*
+:GitGutterPrevHunk      Jump to the previous [count] hunk.
+
+
+Commands for operating on a hunk:~
+
+                                                *gitgutter-:GitGutterStageHunk*
+:GitGutterStageHunk     Stage the hunk the cursor is in.
+
+                                                 *gitgutter-:GitGutterUndoHunk*
+:GitGutterUndoHunk      Undo the hunk the cursor is in.
+
+                                              *gitgutter-:GitGutterPreviewHunk*
+:GitGutterPreviewHunk   Preview the hunk the cursor is in.
+                        Use |:pclose| or |CTRL-W_CTRL-Z| to close the preview
+                        window.
+
+Commands for folds:~
+
+                                                     *gitgutter-:GitGutterFold*
+:GitGutterFold          Fold all unchanged lines.  Execute again to undo.
+
+
+===============================================================================
+AUTOCOMMAND                                             *gitgutter-autocommand*
+
+User GitGutter~
+
+After updating a buffer's signs vim-gitgutter fires a |User| |autocmd| with the
+event GitGutter.  You can listen for this event, for example:
+>
+  autocmd User GitGutter call updateMyStatusLine()
+<
+A dictionary `g:gitgutter_hook_context` is made available during its execution,
+which contains an entry `bufnr` that contains the buffer number being updated.
+
+
+===============================================================================
+MAPPINGS                                                   *gitgutter-mappings*
+
+You can disable all these mappings with:
+>
+    let g:gitgutter_map_keys = 0
+<
+
+Hunk operations:~
+
+These can be repeated with `.` if you have vim-repeat installed.
+
+                                                         *gitgutter-<Leader>hp*
+<Leader>hp              Preview the hunk under the cursor.
+
+                                                         *gitgutter-<Leader>hs*
+<Leader>hs              Stage the hunk under the cursor.
+
+                                                         *gitgutter-<Leader>hu*
+<Leader>hu              Undo the hunk under the cursor.
+
+You can change these mappings like this:
+>
+    nmap ghp <Plug>GitGutterPreviewHunk
+    nmap ghs <Plug>GitGutterStageHunk
+    nmap ghu <Plug>GitGutterUndoHunk
+<
+
+Hunk jumping:~
+
+                                                                 *gitgutter-]c*
+]c                      Jump to the next [count] hunk.
+
+                                                                 *gitgutter-[c*
+[c                      Jump to the previous [count] hunk.
+
+You can change these mappings like this:
+>
+    nmap [c <Plug>GitGutterPrevHunk
+    nmap ]c <Plug>GitGutterNextHunk
+<
+
+Hunk text object:~
+
+                          *gitgutter-ic* *gitgutter-ac* *gitgutter-text-object*
+"ic" operates on the current hunk's lines.  "ac" does the same but also includes
+trailing empty lines.
+>
+    omap ic <Plug>GitGutterTextObjectInnerPending
+    omap ac <Plug>GitGutterTextObjectOuterPending
+    xmap ic <Plug>GitGutterTextObjectInnerVisual
+    xmap ac <Plug>GitGutterTextObjectOuterVisual
+<
+
+
+===============================================================================
+OPTIONS                                                     *gitgutter-options*
+
+The most important option is 'updatetime' which determines how long (in
+milliseconds) the plugin will wait after you stop typing before it updates the
+signs.  Vim's default is 4000.  I recommend 100.
+
+Most important option:~
+
+    'updatetime'
+
+Git:~
+
+    |g:gitgutter_git_executable|
+    |g:gitgutter_git_args|
+    |g:gitgutter_diff_args|
+    |g:gitgutter_diff_base|
+
+Grep:~
+
+    |g:gitgutter_grep|
+
+Signs:~
+
+    |g:gitgutter_signs|
+    |g:gitgutter_highlight_lines|
+    |g:gitgutter_max_signs|
+    |g:gitgutter_sign_added|
+    |g:gitgutter_sign_modified|
+    |g:gitgutter_sign_removed|
+    |g:gitgutter_sign_removed_first_line|
+    |g:gitgutter_sign_modified_removed|
+    |g:gitgutter_sign_column_always|
+    |g:gitgutter_override_sign_column_highlight|
+
+Terminal:~
+
+    |g:gitgutter_terminal_reports_focus|
+
+General:~
+
+    |g:gitgutter_enabled|
+    |g:gitgutter_map_keys|
+    |g:gitgutter_async|
+    |g:gitgutter_log|
+
+
+                                                   *g:gitgutter_git_executable*
+Default: 'git'
+
+This option determines what git binary to use.  Set this if git is not on your
+path.
+
+                                                         *g:gitgutter_git_args*
+Default: empty
+
+Use this option to pass any extra arguments to git when running git-diff.
+For example:
+>
+    let g:gitgutter_git_args = '--git-dir=""'
+<
+
+                                                        *g:gitgutter_diff_args*
+Default: empty
+
+Use this option to pass any extra arguments to git-diff.  For example:
+>
+    let g:gitgutter_diff_args = '-w'
+<
+
+                                                        *g:gitgutter_diff_base*
+Default: empty
+
+By default buffers are diffed against the index.  Use this option to diff against
+a revision instead.  For example:
+>
+    let g:gitgutter_diff_base = '<some commit SHA>'
+<
+
+                                                             *g:gitgutter_grep*
+Default: 'grep'
+
+The plugin pipes the output of git-diff into grep to minimise the amount of data
+vim has to process.  Set this option if grep is not on your path.
+
+grep must produce plain-text output without any ANSI escape codes or colours.
+Use this option to turn off colours if necessary.
+>
+    let g:gitgutter_grep = 'grep --color=never'
+<
+If you do not want to use grep at all (perhaps to debug why signs are not
+showing), set this option to an empty string:
+>
+    let g:gitgutter_grep = ''
+<
+
+                                                            *g:gitgutter_signs*
+Default: 1
+
+Determines whether or not to show signs.
+
+                                                  *g:gitgutter_highlight_lines*
+Default: 0
+
+Determines whether or not to show line highlights.
+
+                                                        *g:gitgutter_max_signs*
+Default: 500
+
+Sets the maximum number of signs to show in a buffer.  Vim is slow at updating
+signs, so to avoid slowing down the GUI the number of signs is capped.  When
+the number of changed lines exceeds this value, the plugin removes all signs
+and displays a warning message.
+
+                                          *g:gitgutter_sign_added*
+                                          *g:gitgutter_sign_modified*
+                                          *g:gitgutter_sign_removed*
+                                          *g:gitgutter_sign_removed_first_line*
+                                          *g:gitgutter_sign_modified_removed*
+Defaults:
+>
+    let g:gitgutter_sign_added              = '+'
+    let g:gitgutter_sign_modified           = '~'
+    let g:gitgutter_sign_removed            = '_'
+    let g:gitgutter_sign_removed_first_line = '‾'
+    let g:gitgutter_sign_modified_removed   = '~_'
+<
+You can use unicode characters but not images.  Signs must not take up more than
+2 columns.
+
+                                               *g:gitgutter_sign_column_always*
+Default: 0
+
+This legacy option controls whether the sign column should always be shown, even
+if there are no signs to display.
+
+From Vim 7.4.2201, use 'signcolumn' instead:
+>
+    set signcolumn=yes
+<
+
+                                   *g:gitgutter_override_sign_column_highlight*
+Default: 1
+
+Controls whether to make the sign column look like the line-number column (i.e.
+the |hl-LineNr| highlight group).
+
+To customise your sign column's background color, first tell vim-gitgutter to
+leave it alone:
+>
+    let g:gitgutter_override_sign_column_highlight = 0
+<
+
+And then either update your colorscheme's |hlSignColumn| highlight group or set
+it in your |vimrc|:
+
+  Desired appearance                  Command ~
+  Same as line-number column          highlight clear SignColumn
+  User-defined (terminal Vim)         highlight SignColumn ctermbg={whatever}
+  User-defined (graphical Vim)        highlight SignColumn guibg={whatever}
+
+
+                                           *g:gitgutter_terminal_reports_focus*
+Default: 1
+
+Normally the plugin uses |FocusGained| to force-update all buffers when Vim
+receives focus.  However some terminals do not report focus events and so the
+|FocusGained| autocommand never fires.
+
+If this applies to you, either install something like Terminus
+(https://github.com/wincent/terminus) to make |FocusGained| work or set this
+option to 0.
+
+When this option is 0, the plugin force-updates the buffer on |BufEnter|
+(instead of only updating if the buffer's contents has changed since the last
+update).
+
+                                                          *g:gitgutter_enabled*
+Default: 1
+
+Controls whether or not the plugin is on at startup.
+
+                                                         *g:gitgutter_map_keys*
+Default: 1
+
+Controls whether or not the plugin provides mappings.  See |gitgutter-mapppings|.
+
+                                                            *g:gitgutter_async*
+Default: 1
+
+Controls whether or not diffs are run in the background.  This has no effect if
+your Vim does not support background jobs.
+
+                                                              *g:gitgutter_log*
+Default: 0
+
+When switched on, the plugin logs to gitgutter.log in the directory where it is
+installed.  Additionally it logs channel activity to channel.log.
+
+
+===============================================================================
+HIGHLIGHTS                                               *gitgutter-highlights*
+
+To change the signs' colours, set up the following highlight groups in your
+colorscheme or |vimrc|:
+>
+    GitGutterAdd          " an added line
+    GitGutterChange       " a changed line
+    GitGutterDelete       " at least one removed line
+    GitGutterChangeDelete " a changed line followed by at least one removed line
+<
+
+You can either set these with `highlight GitGutterAdd {key}={arg}...` or link
+them to existing highlight groups with, say:
+>
+  highlight link GitGutterAdd MyDiffAdd
+<
+
+To change the line highlights, set up the following highlight groups in your
+colorscheme or |vimrc|:
+>
+    GitGutterAddLine          " default: links to DiffAdd
+    GitGutterChangeLine       " default: links to DiffChange
+    GitGutterDeleteLine       " default: links to DiffDelete
+    GitGutterChangeDeleteLine " default: links to GitGutterChangeLineDefault
+<
+
+For example, to use |hl-DiffText| instead of |hl-DiffChange|:
+>
+    highlight link GitGutterChangeLine DiffChange
+<
+
+
+===============================================================================
+FAQ                                                             *gitgutter-faq*
+
+a. How do I turn off realtime updates?
+
+  Add this to your vim configuration in an |after-directory|:
+>
+    autocmd! gitgutter CursorHold,CursorHoldI
+<
+
+b. I turned off realtime updates, how can I have signs updated when I save a
+   file?
+
+  If you really want to update the signs when you save a file, add this to your
+  |vimrc|:
+>
+    autocmd BufWritePost * GitGutter
+<
+
+c. Why can't I unstage staged changes?
+
+  This plugin is for showing changes between the working tree and the index
+  (and staging/undoing those changes). Unstaging a staged hunk would require
+  showing changes between the index and HEAD, which is out of scope.
+
+d. Why are the colours in the sign column weird?
+
+  Your colorscheme is configuring the |hl-SignColumn| highlight group weirdly.
+  Please see |g:gitgutter_override_sign_column_highlight| on customising the
+  sign column.
+
+e. What happens if I also use another plugin which uses signs (e.g. Syntastic)?
+
+  Vim only allows one sign per line.  Vim-gitgutter will not interfere with
+  signs it did not add.
+
+
+===============================================================================
+TROUBLESHOOTING                                     *gitgutter-troubleshooting*
+
+When no signs are showing at all:~
+
+1. Try bypassing grep with:
+>
+    let g:gitgutter_grep = ''
+<
+  If it works, the problem is grep outputting ANSI escape codes.  Use this
+  option to pass arguments to grep to turn off the escape codes.
+
+2. Verify git is on your path:
+>
+    :echo system('git --version')
+<
+
+3. Verify your git config is compatible with the version of git return by the
+   command above.
+
+4. Verify your Vim supports signs.  The following should give 1:
+>
+    :echo has('signs')
+<
+
+5. Check whether the plugin thinks git knows about your file:
+>
+    :echo getbufvar('','gitgutter').path
+<
+  If the result is -2, the plugin thinks your file is not tracked by git.
+
+
+When the whole file is marked as added:~
+
+If you use zsh, and you set "CDPATH", make sure "CDPATH" does not include the
+current directory.
+
+
+When signs take a few seconds to appear:~
+
+Try reducing 'updatetime':
+>
+    set updatetime=100
+<
+
+
+When signs don't update after focusing Vim:~
+
+Your terminal probably isn't reporting focus events.  Either try installing
+Terminus (https://github.com/wincent/terminus) or set:
+>
+    let g:gitgutter_terminal_reports_focus = 0
+<
+
diff --git a/vim/.vim/plugged/vim-gitgutter/doc/tags b/vim/.vim/plugged/vim-gitgutter/doc/tags
new file mode 100644
index 0000000..c6dee73
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/doc/tags
@@ -0,0 +1,56 @@
+g:gitgutter_async	gitgutter.txt	/*g:gitgutter_async*
+g:gitgutter_diff_args	gitgutter.txt	/*g:gitgutter_diff_args*
+g:gitgutter_diff_base	gitgutter.txt	/*g:gitgutter_diff_base*
+g:gitgutter_enabled	gitgutter.txt	/*g:gitgutter_enabled*
+g:gitgutter_git_args	gitgutter.txt	/*g:gitgutter_git_args*
+g:gitgutter_git_executable	gitgutter.txt	/*g:gitgutter_git_executable*
+g:gitgutter_grep	gitgutter.txt	/*g:gitgutter_grep*
+g:gitgutter_highlight_lines	gitgutter.txt	/*g:gitgutter_highlight_lines*
+g:gitgutter_log	gitgutter.txt	/*g:gitgutter_log*
+g:gitgutter_map_keys	gitgutter.txt	/*g:gitgutter_map_keys*
+g:gitgutter_max_signs	gitgutter.txt	/*g:gitgutter_max_signs*
+g:gitgutter_override_sign_column_highlight	gitgutter.txt	/*g:gitgutter_override_sign_column_highlight*
+g:gitgutter_sign_added	gitgutter.txt	/*g:gitgutter_sign_added*
+g:gitgutter_sign_column_always	gitgutter.txt	/*g:gitgutter_sign_column_always*
+g:gitgutter_sign_modified	gitgutter.txt	/*g:gitgutter_sign_modified*
+g:gitgutter_sign_modified_removed	gitgutter.txt	/*g:gitgutter_sign_modified_removed*
+g:gitgutter_sign_removed	gitgutter.txt	/*g:gitgutter_sign_removed*
+g:gitgutter_sign_removed_first_line	gitgutter.txt	/*g:gitgutter_sign_removed_first_line*
+g:gitgutter_signs	gitgutter.txt	/*g:gitgutter_signs*
+g:gitgutter_terminal_reports_focus	gitgutter.txt	/*g:gitgutter_terminal_reports_focus*
+gitgutter	gitgutter.txt	/*gitgutter*
+gitgutter-:GitGutter	gitgutter.txt	/*gitgutter-:GitGutter*
+gitgutter-:GitGutterAll	gitgutter.txt	/*gitgutter-:GitGutterAll*
+gitgutter-:GitGutterDisable	gitgutter.txt	/*gitgutter-:GitGutterDisable*
+gitgutter-:GitGutterEnable	gitgutter.txt	/*gitgutter-:GitGutterEnable*
+gitgutter-:GitGutterFold	gitgutter.txt	/*gitgutter-:GitGutterFold*
+gitgutter-:GitGutterLineHighlightsDisable	gitgutter.txt	/*gitgutter-:GitGutterLineHighlightsDisable*
+gitgutter-:GitGutterLineHighlightsEnable	gitgutter.txt	/*gitgutter-:GitGutterLineHighlightsEnable*
+gitgutter-:GitGutterLineHighlightsToggle	gitgutter.txt	/*gitgutter-:GitGutterLineHighlightsToggle*
+gitgutter-:GitGutterNextHunk	gitgutter.txt	/*gitgutter-:GitGutterNextHunk*
+gitgutter-:GitGutterPrevHunk	gitgutter.txt	/*gitgutter-:GitGutterPrevHunk*
+gitgutter-:GitGutterPreviewHunk	gitgutter.txt	/*gitgutter-:GitGutterPreviewHunk*
+gitgutter-:GitGutterSignsDisable	gitgutter.txt	/*gitgutter-:GitGutterSignsDisable*
+gitgutter-:GitGutterSignsEnable	gitgutter.txt	/*gitgutter-:GitGutterSignsEnable*
+gitgutter-:GitGutterSignsToggle	gitgutter.txt	/*gitgutter-:GitGutterSignsToggle*
+gitgutter-:GitGutterStageHunk	gitgutter.txt	/*gitgutter-:GitGutterStageHunk*
+gitgutter-:GitGutterToggle	gitgutter.txt	/*gitgutter-:GitGutterToggle*
+gitgutter-:GitGutterUndoHunk	gitgutter.txt	/*gitgutter-:GitGutterUndoHunk*
+gitgutter-<Leader>hp	gitgutter.txt	/*gitgutter-<Leader>hp*
+gitgutter-<Leader>hs	gitgutter.txt	/*gitgutter-<Leader>hs*
+gitgutter-<Leader>hu	gitgutter.txt	/*gitgutter-<Leader>hu*
+gitgutter-[c	gitgutter.txt	/*gitgutter-[c*
+gitgutter-]c	gitgutter.txt	/*gitgutter-]c*
+gitgutter-ac	gitgutter.txt	/*gitgutter-ac*
+gitgutter-autocommand	gitgutter.txt	/*gitgutter-autocommand*
+gitgutter-commands	gitgutter.txt	/*gitgutter-commands*
+gitgutter-faq	gitgutter.txt	/*gitgutter-faq*
+gitgutter-highlights	gitgutter.txt	/*gitgutter-highlights*
+gitgutter-ic	gitgutter.txt	/*gitgutter-ic*
+gitgutter-installation	gitgutter.txt	/*gitgutter-installation*
+gitgutter-introduction	gitgutter.txt	/*gitgutter-introduction*
+gitgutter-mappings	gitgutter.txt	/*gitgutter-mappings*
+gitgutter-options	gitgutter.txt	/*gitgutter-options*
+gitgutter-text-object	gitgutter.txt	/*gitgutter-text-object*
+gitgutter-troubleshooting	gitgutter.txt	/*gitgutter-troubleshooting*
+gitgutter.txt	gitgutter.txt	/*gitgutter.txt*
diff --git a/vim/.vim/plugged/vim-gitgutter/plugin/gitgutter.vim b/vim/.vim/plugged/vim-gitgutter/plugin/gitgutter.vim
new file mode 100644
index 0000000..e0b0b92
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/plugin/gitgutter.vim
@@ -0,0 +1,231 @@
+scriptencoding utf-8
+
+if exists('g:loaded_gitgutter') || !has('signs') || &cp
+  finish
+endif
+let g:loaded_gitgutter = 1
+
+" Initialisation {{{
+
+if v:version < 703 || (v:version == 703 && !has("patch105"))
+  call gitgutter#utility#warn('requires Vim 7.3.105')
+  finish
+endif
+
+function! s:set(var, default) abort
+  if !exists(a:var)
+    if type(a:default)
+      execute 'let' a:var '=' string(a:default)
+    else
+      execute 'let' a:var '=' a:default
+    endif
+  endif
+endfunction
+
+call s:set('g:gitgutter_enabled',                     1)
+call s:set('g:gitgutter_max_signs',                 500)
+call s:set('g:gitgutter_signs',                       1)
+call s:set('g:gitgutter_highlight_lines',             0)
+call s:set('g:gitgutter_sign_column_always',          0)
+if g:gitgutter_sign_column_always && exists('&signcolumn')
+  " Vim 7.4.2201.
+  set signcolumn=yes
+  let g:gitgutter_sign_column_always = 0
+  call gitgutter#utility#warn('please replace "let g:gitgutter_sign_column_always=1" with "set signcolumn=yes"')
+endif
+call s:set('g:gitgutter_override_sign_column_highlight', 1)
+call s:set('g:gitgutter_sign_added',                   '+')
+call s:set('g:gitgutter_sign_modified',                '~')
+call s:set('g:gitgutter_sign_removed',                 '_')
+
+if gitgutter#utility#supports_overscore_sign()
+  call s:set('g:gitgutter_sign_removed_first_line', '‾')
+else
+  call s:set('g:gitgutter_sign_removed_first_line', '_^')
+endif
+
+call s:set('g:gitgutter_sign_removed_above_and_below', '[')
+call s:set('g:gitgutter_sign_modified_removed',       '~_')
+call s:set('g:gitgutter_git_args',                      '')
+call s:set('g:gitgutter_diff_args',                     '')
+call s:set('g:gitgutter_diff_base',                     '')
+call s:set('g:gitgutter_map_keys',                       1)
+call s:set('g:gitgutter_terminal_reports_focus',         1)
+call s:set('g:gitgutter_async',                          1)
+call s:set('g:gitgutter_log',                            0)
+
+call s:set('g:gitgutter_git_executable', 'git')
+if !executable(g:gitgutter_git_executable)
+  call gitgutter#utility#warn('cannot find git. Please set g:gitgutter_git_executable.')
+endif
+
+let default_grep = 'grep'
+call s:set('g:gitgutter_grep', default_grep)
+if !empty(g:gitgutter_grep)
+  if executable(split(g:gitgutter_grep)[0])
+    if $GREP_OPTIONS =~# '--color=always'
+      let g:gitgutter_grep .= ' --color=never'
+    endif
+  else
+    if g:gitgutter_grep !=# default_grep
+      call gitgutter#utility#warn('cannot find '.g:gitgutter_grep.'. Please check g:gitgutter_grep.')
+    endif
+    let g:gitgutter_grep = ''
+  endif
+endif
+
+call gitgutter#highlight#define_sign_column_highlight()
+call gitgutter#highlight#define_highlights()
+call gitgutter#highlight#define_signs()
+
+" Prevent infinite loop where:
+" - executing a job in the foreground launches a new window which takes the focus;
+" - when the job finishes, focus returns to gvim;
+" - the FocusGained event triggers a new job (see below).
+if gitgutter#utility#windows() && !(g:gitgutter_async && gitgutter#async#available())
+  set noshelltemp
+endif
+
+" }}}
+
+" Primary functions {{{
+
+command! -bar GitGutterAll call gitgutter#all(1)
+command! -bar GitGutter    call gitgutter#process_buffer(bufnr(''), 1)
+
+command! -bar GitGutterDisable call gitgutter#disable()
+command! -bar GitGutterEnable  call gitgutter#enable()
+command! -bar GitGutterToggle  call gitgutter#toggle()
+
+command! -bar GitGutterBufferDisable call gitgutter#buffer_disable()
+command! -bar GitGutterBufferEnable  call gitgutter#buffer_enable()
+command! -bar GitGutterBufferToggle  call gitgutter#buffer_toggle()
+
+" }}}
+
+" Line highlights {{{
+
+command! -bar GitGutterLineHighlightsDisable call gitgutter#highlight#line_disable()
+command! -bar GitGutterLineHighlightsEnable  call gitgutter#highlight#line_enable()
+command! -bar GitGutterLineHighlightsToggle  call gitgutter#highlight#line_toggle()
+
+" }}}
+
+" Signs {{{
+
+command! -bar GitGutterSignsEnable  call gitgutter#sign#enable()
+command! -bar GitGutterSignsDisable call gitgutter#sign#disable()
+command! -bar GitGutterSignsToggle  call gitgutter#sign#toggle()
+
+" }}}
+
+" Hunks {{{
+
+command! -bar -count=1 GitGutterNextHunk call gitgutter#hunk#next_hunk(<count>)
+command! -bar -count=1 GitGutterPrevHunk call gitgutter#hunk#prev_hunk(<count>)
+
+command! -bar GitGutterStageHunk   call gitgutter#hunk#stage()
+command! -bar GitGutterUndoHunk    call gitgutter#hunk#undo()
+command! -bar GitGutterPreviewHunk call gitgutter#hunk#preview()
+
+" Hunk text object
+onoremap <silent> <Plug>GitGutterTextObjectInnerPending :<C-U>call gitgutter#hunk#text_object(1)<CR>
+onoremap <silent> <Plug>GitGutterTextObjectOuterPending :<C-U>call gitgutter#hunk#text_object(0)<CR>
+xnoremap <silent> <Plug>GitGutterTextObjectInnerVisual  :<C-U>call gitgutter#hunk#text_object(1)<CR>
+xnoremap <silent> <Plug>GitGutterTextObjectOuterVisual  :<C-U>call gitgutter#hunk#text_object(0)<CR>
+
+
+" Returns the git-diff hunks for the file or an empty list if there
+" aren't any hunks.
+"
+" The return value is a list of lists.  There is one inner list per hunk.
+"
+"   [
+"     [from_line, from_count, to_line, to_count],
+"     [from_line, from_count, to_line, to_count],
+"     ...
+"   ]
+"
+" where:
+"
+" `from`  - refers to the staged file
+" `to`    - refers to the working tree's file
+" `line`  - refers to the line number where the change starts
+" `count` - refers to the number of lines the change covers
+function! GitGutterGetHunks()
+  let bufnr = bufnr('')
+  return gitgutter#utility#is_active(bufnr) ? gitgutter#hunk#hunks(bufnr) : []
+endfunction
+
+" Returns an array that contains a summary of the hunk status for the current
+" window.  The format is [ added, modified, removed ], where each value
+" represents the number of lines added/modified/removed respectively.
+function! GitGutterGetHunkSummary()
+  return gitgutter#hunk#summary(winbufnr(0))
+endfunction
+
+" }}}
+
+" Folds {{{
+
+command! -bar GitGutterFold call gitgutter#fold#toggle()
+
+" }}}
+
+command! -bar GitGutterDebug call gitgutter#debug#debug()
+
+" Maps {{{
+
+nnoremap <silent> <expr> <Plug>GitGutterNextHunk &diff ? ']c' : ":\<C-U>execute v:count1 . 'GitGutterNextHunk'\<CR>"
+nnoremap <silent> <expr> <Plug>GitGutterPrevHunk &diff ? '[c' : ":\<C-U>execute v:count1 . 'GitGutterPrevHunk'\<CR>"
+
+nnoremap <silent> <Plug>GitGutterStageHunk   :GitGutterStageHunk<CR>
+nnoremap <silent> <Plug>GitGutterUndoHunk    :GitGutterUndoHunk<CR>
+nnoremap <silent> <Plug>GitGutterPreviewHunk :GitGutterPreviewHunk<CR>
+
+" }}}
+
+function! s:on_bufenter()
+  if exists('t:gitgutter_didtabenter') && t:gitgutter_didtabenter
+    let t:gitgutter_didtabenter = 0
+    call gitgutter#all(!g:gitgutter_terminal_reports_focus)
+  else
+    call gitgutter#init_buffer(bufnr(''))
+    call gitgutter#process_buffer(bufnr(''), !g:gitgutter_terminal_reports_focus)
+  endif
+endfunction
+
+" Autocommands {{{
+
+augroup gitgutter
+  autocmd!
+
+  autocmd TabEnter * let t:gitgutter_didtabenter = 1
+
+  autocmd BufEnter * call s:on_bufenter()
+
+  autocmd CursorHold,CursorHoldI * call gitgutter#process_buffer(bufnr(''), 0)
+  autocmd FileChangedShellPost   * call gitgutter#process_buffer(bufnr(''), 1)
+
+  " Ensure that all buffers are processed when opening vim with multiple files, e.g.:
+  "
+  "   vim -o file1 file2
+  autocmd VimEnter * if winnr() != winnr('$') | call gitgutter#all(0) | endif
+
+  autocmd FocusGained,ShellCmdPost * call gitgutter#all(1)
+  autocmd WinLeave * if bufname('') =~ '^term://' | call gitgutter#all(1) | endif
+
+  if exists('##VimResume')
+    autocmd VimResume * call gitgutter#all(1)
+  endif
+
+  autocmd ColorScheme * call gitgutter#highlight#define_sign_column_highlight() | call gitgutter#highlight#define_highlights()
+
+  " Disable during :vimgrep
+  autocmd QuickFixCmdPre  *vimgrep* let g:gitgutter_enabled = 0
+  autocmd QuickFixCmdPost *vimgrep* let g:gitgutter_enabled = 1
+augroup END
+
+" }}}
+
+" vim:set et sw=2 fdm=marker:
diff --git a/vim/.vim/plugged/vim-gitgutter/screenshot.png b/vim/.vim/plugged/vim-gitgutter/screenshot.png
new file mode 100644
index 0000000..6b50f83
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/screenshot.png
diff --git a/vim/.vim/plugged/vim-gitgutter/test/cp932.txt b/vim/.vim/plugged/vim-gitgutter/test/cp932.txt
new file mode 100644
index 0000000..80cb10b
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/test/cp932.txt
@@ -0,0 +1,8 @@
+The quick brown fox jumps
+over the lazy dog
+
+‚¢‚ë‚Í‚É‚Ù‚Ö‚Æ‚¿‚è‚Ê‚é‚ð
+‚í‚©‚悽‚ê‚»‚‚˂Ȃç‚Þ
+‚¤‚î‚Ì‚¨‚­‚â‚Ü‚¯‚Ó‚±‚¦‚Ä
+‚ ‚³‚«‚ä‚ß‚Ý‚µ‚ï‚Ð‚à‚¹‚·
+
diff --git a/vim/.vim/plugged/vim-gitgutter/test/fixture.txt b/vim/.vim/plugged/vim-gitgutter/test/fixture.txt
new file mode 100644
index 0000000..f5c6aff
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/test/fixture.txt
@@ -0,0 +1,11 @@
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+
diff --git a/vim/.vim/plugged/vim-gitgutter/test/runner.vim b/vim/.vim/plugged/vim-gitgutter/test/runner.vim
new file mode 100644
index 0000000..630693c
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/test/runner.vim
@@ -0,0 +1,162 @@
+"
+" Adapted from https://github.com/vim/vim/blob/master/src/testdir/runtest.vim
+"
+" When debugging tests it can help to write debug output:
+"    call Log('oh noes')
+"
+
+function RunTest(test)
+  if exists("*SetUp")
+    call SetUp()
+  endif
+
+  try
+    execute 'call '.a:test
+  catch
+    call Exception()
+    let s:errored = 1
+  endtry
+
+  if exists("*TearDown")
+    call TearDown()
+  endif
+endfunction
+
+function Log(msg)
+  if type(a:msg) == type('')
+    call add(s:messages, a:msg)
+  elseif type(a:msg) == type([])
+    call extend(s:messages, a:msg)
+  else
+    call add(v:errors, 'Exception: unsupported type: '.type(a:msg))
+  endif
+endfunction
+
+function Exception()
+  call add(v:errors, v:throwpoint.'..'.'Exception: '.v:exception)
+endfunction
+
+" Shuffles list in place.
+function Shuffle(list)
+  " Fisher-Yates-Durstenfeld-Knuth
+  let n = len(a:list)
+  if n < 2
+    return a:list
+  endif
+  for i in range(0, n-2)
+    let j = Random(0, n-i-1)
+    let e = a:list[i]
+    let a:list[i] = a:list[i+j]
+    let a:list[i+j] = e
+  endfor
+  return a:list
+endfunction
+
+" Returns a pseudorandom integer i such that 0 <= i <= max
+function Random(min, max)
+  if has('unix')
+    let i = system('echo $RANDOM')  " 0 <= i <= 32767
+  else
+    let i = system('echo %RANDOM%')  " 0 <= i <= 32767
+  endif
+  return i * (a:max - a:min + 1) / 32768 + a:min
+endfunction
+
+function FriendlyName(test_name)
+  return substitute(a:test_name[5:-3], '_', ' ', 'g')
+endfunction
+
+function Align(left, right)
+  if type(a:right) == type([])
+    let result = []
+    for s in a:right
+      if empty(result)
+        call add(result, printf('%-'.s:indent.'S', a:left).s)
+      else
+        call add(result, printf('%-'.s:indent.'S',     '').s)
+      endif
+    endfor
+    return result
+  endif
+
+  return printf('%-'.s:indent.'S', a:left).a:right
+endfunction
+
+let g:testname = expand('%')
+let s:errored = 0
+let s:done = 0
+let s:fail = 0
+let s:errors = 0
+let s:messages = []
+let s:indent = ''
+
+call Log(g:testname.':')
+
+" Source the test script.
+try
+  source %
+catch
+  let s:errors += 1
+  call Exception()
+endtry
+
+" Locate the test functions.
+set nomore
+redir @q
+silent function /^Test_
+redir END
+let s:tests = split(substitute(@q, 'function \(\k*()\)', '\1', 'g'))
+
+" If there is another argument, filter test-functions' names against it.
+if argc() > 1
+  let s:tests = filter(s:tests, 'v:val =~ argv(1)')
+endif
+
+let s:indent = max(map(copy(s:tests), {_, val -> len(FriendlyName(val))}))
+
+" Run the tests in random order.
+for test in Shuffle(s:tests)
+  call RunTest(test)
+  let s:done += 1
+
+  let friendly_name = FriendlyName(test)
+  if len(v:errors) == 0
+    call Log(Align(friendly_name, ' - ok'))
+  else
+    if s:errored
+      let s:errors += 1
+      let s:errored = 0
+    else
+      let s:fail += 1
+    endif
+    call Log(Align(friendly_name, ' - not ok'))
+
+    let i = 0
+    for error in v:errors
+      if i != 0
+        call Log(Align('','   ! ----'))
+      endif
+      for trace in reverse(split(error, '\.\.'))
+        call Log(Align('', '   ! '.trace))
+      endfor
+      let i += 1
+    endfor
+
+    let v:errors = []
+  endif
+endfor
+
+let summary = [
+      \ s:done.(  s:done   == 1 ? ' test'    : ' tests'),
+      \ s:errors.(s:errors == 1 ? ' error'   : ' errors'),
+      \ s:fail.(  s:fail   == 1 ? ' failure' : ' failures'),
+      \ ]
+call Log('')
+call Log(join(summary, ', '))
+
+split messages.log
+call append(line('$'), s:messages)
+write
+
+qall!
+
diff --git a/vim/.vim/plugged/vim-gitgutter/test/test b/vim/.vim/plugged/vim-gitgutter/test/test
new file mode 100644
index 0000000..4daf052
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/test/test
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+VIM="/Applications/MacVim.app/Contents/MacOS/Vim -v"
+
+export VIM_GITGUTTER_TEST=1
+
+$VIM -u NONE -U NONE -N                      \
+  --cmd 'set rtp+=../'                       \
+  --cmd 'let g:gitgutter_async=0'            \
+  --cmd 'source ../plugin/gitgutter.vim'     \
+  -S runner.vim                              \
+  test_*.vim                                 \
+  $*
+
+cat messages.log
+
+grep -q "0 errors, 0 failures" messages.log
+status=$?
+rm messages.log
+exit $status
+
diff --git a/vim/.vim/plugged/vim-gitgutter/test/test_gitgutter.vim b/vim/.vim/plugged/vim-gitgutter/test/test_gitgutter.vim
new file mode 100644
index 0000000..855eca3
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/test/test_gitgutter.vim
@@ -0,0 +1,680 @@
+let s:current_dir = expand('%:p:h')
+let s:test_repo   = s:current_dir.'/test-repo'
+let s:bufnr       = bufnr('')
+
+"
+" Helpers
+"
+
+function s:signs(filename)
+  redir => signs
+    silent execute 'sign place'
+  redir END
+
+  let signs = split(signs, '\n')
+
+  " filter out signs for this test file
+  " assumes a:filename's signs are last set listed
+  let i = index(signs, 'Signs for '.a:filename.':')
+  let signs = (i > -1 ? signs[i+1:] : [])
+
+  call map(signs, {_, v -> substitute(v, '    ', '', '')})
+
+  return signs
+endfunction
+
+function s:git_diff()
+  return split(system('git diff -U0 fixture.txt'), '\n')
+endfunction
+
+function s:git_diff_staged()
+  return split(system('git diff -U0 --staged fixture.txt'), '\n')
+endfunction
+
+function s:trigger_gitgutter()
+  doautocmd CursorHold
+endfunction
+
+
+"
+" SetUp / TearDown
+"
+
+function SetUp()
+  call system("git init ".s:test_repo.
+        \ " && cd ".s:test_repo.
+        \ " && cp ../fixture.txt .".
+        \ " && git add . && git commit -m 'initial'".
+        \ " && git config diff.mnemonicPrefix false")
+  execute ':cd' s:test_repo
+  edit! fixture.txt
+  call gitgutter#sign#reset()
+endfunction
+
+function TearDown()
+  " delete all buffers except this one
+  " TODO: move to runner.vim, accounting for multiple test files
+  if s:bufnr > 1
+    silent! execute '1,'.s:bufnr-1.'bdelete!'
+  endif
+  silent! execute s:bufnr+1.',$bdelete!'
+
+  execute ':cd' s:current_dir
+  call system("rm -rf ".s:test_repo)
+endfunction
+
+"
+" The tests
+"
+
+function Test_add_lines()
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = ["line=2  id=3000  name=GitGutterLineAdded"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_add_lines_fish()
+  let _shell = &shell
+  set shell=/usr/local/bin/fish
+
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = ["line=2  id=3000  name=GitGutterLineAdded"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+
+  let &shell = _shell
+endfunction
+
+
+function Test_modify_lines()
+  normal ggi*
+  call s:trigger_gitgutter()
+
+  let expected = ["line=1  id=3000  name=GitGutterLineModified"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_remove_lines()
+  execute '5d'
+  call s:trigger_gitgutter()
+
+  let expected = ["line=4  id=3000  name=GitGutterLineRemoved"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_remove_first_lines()
+  execute '1d'
+  call s:trigger_gitgutter()
+
+  let expected = ["line=1  id=3000  name=GitGutterLineRemovedFirstLine"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_overlapping_hunks()
+  execute '3d'
+  execute '1d'
+  call s:trigger_gitgutter()
+
+  let expected = ["line=1  id=3000  name=GitGutterLineRemovedAboveAndBelow"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_edit_file_with_same_name_as_a_branch()
+  normal 5Gi*
+  call system('git checkout -b fixture.txt')
+  call s:trigger_gitgutter()
+
+  let expected = ["line=5  id=3000  name=GitGutterLineModified"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_file_added_to_git()
+  let tmpfile = 'fileAddedToGit.tmp'
+  call system('touch '.tmpfile.' && git add '.tmpfile)
+  execute 'edit '.tmpfile
+  normal ihello
+  call s:trigger_gitgutter()
+
+  let expected = ["line=1  id=3000  name=GitGutterLineAdded"]
+  call assert_equal(expected, s:signs('fileAddedToGit.tmp'))
+endfunction
+
+
+function Test_filename_with_equals()
+  call system('touch =fixture=.txt && git add =fixture=.txt')
+  edit =fixture=.txt
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=1  id=3000  name=GitGutterLineAdded',
+        \ 'line=2  id=3001  name=GitGutterLineAdded'
+        \ ]
+  call assert_equal(expected, s:signs('=fixture=.txt'))
+endfunction
+
+
+function Test_filename_with_square_brackets()
+  call system('touch fix[tu]re.txt && git add fix[tu]re.txt')
+  edit fix[tu]re.txt
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=1  id=3000  name=GitGutterLineAdded',
+        \ 'line=2  id=3001  name=GitGutterLineAdded'
+        \ ]
+  call assert_equal(expected, s:signs('fix[tu]re.txt'))
+endfunction
+
+
+function Test_filename_leading_dash()
+  call system('touch -- -fixture.txt && git add -- -fixture.txt')
+  edit -fixture.txt
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=1  id=3000  name=GitGutterLineAdded',
+        \ 'line=2  id=3001  name=GitGutterLineAdded'
+        \ ]
+  call assert_equal(expected, s:signs('-fixture.txt'))
+endfunction
+
+
+function Test_filename_umlaut()
+  call system('touch -- fixtüre.txt && git add -- fixtüre.txt')
+  edit fixtüre.txt
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=1  id=3000  name=GitGutterLineAdded',
+        \ 'line=2  id=3001  name=GitGutterLineAdded'
+        \ ]
+  call assert_equal(expected, s:signs('fixtüre.txt'))
+endfunction
+
+
+" FIXME: this test fails when it is the first (or only) test to be run
+function Test_follow_symlink()
+  let tmp = 'symlink'
+  call system('ln -nfs fixture.txt '.tmp)
+  execute 'edit '.tmp
+  6d
+  call s:trigger_gitgutter()
+
+  let expected = ['line=5  id=3000  name=GitGutterLineRemoved']
+  call assert_equal(expected, s:signs('symlink'))
+endfunction
+
+
+function Test_keep_alt()
+  enew
+  execute "normal! \<C-^>"
+
+  call assert_equal('fixture.txt', bufname(''))
+  call assert_equal('',            bufname('#'))
+
+  normal ggx
+  call s:trigger_gitgutter()
+
+  call assert_equal('', bufname('#'))
+endfunction
+
+
+function Test_keep_modified()
+  normal 5Go*
+  call assert_equal(1, getbufvar('', '&modified'))
+
+  call s:trigger_gitgutter()
+
+  call assert_equal(1, getbufvar('', '&modified'))
+endfunction
+
+
+function Test_keep_op_marks()
+  normal 5Go*
+  call assert_equal([0,6,1,0], getpos("'["))
+  call assert_equal([0,6,2,0], getpos("']"))
+
+  call s:trigger_gitgutter()
+
+  call assert_equal([0,6,1,0], getpos("'["))
+  call assert_equal([0,6,2,0], getpos("']"))
+endfunction
+
+
+function Test_no_modifications()
+  call assert_equal([], s:signs('fixture.txt'))
+endfunction
+
+
+function Test_orphaned_signs()
+  execute "normal 5GoX\<CR>Y"
+  call s:trigger_gitgutter()
+  6d
+  call s:trigger_gitgutter()
+
+  let expected = ['line=6  id=3001  name=GitGutterLineAdded']
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_untracked_file_outside_repo()
+  let tmp = tempname()
+  call system('touch '.tmp)
+  execute 'edit '.tmp
+
+  call assert_equal([], s:signs(tmp))
+endfunction
+
+
+function Test_untracked_file_within_repo()
+  let tmp = 'untrackedFileWithinRepo.tmp'
+  call system('touch '.tmp)
+  execute 'edit '.tmp
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  call assert_equal([], s:signs(tmp))
+  call assert_equal(-2, b:gitgutter.path)
+
+  call system('rm '.tmp)
+endfunction
+
+
+function Test_untracked_file_square_brackets_within_repo()
+  let tmp = '[un]trackedFileWithinRepo.tmp'
+  call system('touch '.tmp)
+  execute 'edit '.tmp
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  call assert_equal([], s:signs(tmp))
+
+  call system('rm '.tmp)
+endfunction
+
+
+function Test_hunk_outside_noop()
+  normal 5G
+  GitGutterStageHunk
+
+  call assert_equal([], s:signs('fixture.txt'))
+  call assert_equal([], s:git_diff())
+  call assert_equal([], s:git_diff_staged())
+
+  GitGutterUndoHunk
+
+  call assert_equal([], s:signs('fixture.txt'))
+  call assert_equal([], s:git_diff())
+  call assert_equal([], s:git_diff_staged())
+endfunction
+
+
+function Test_hunk_stage()
+  let _shell = &shell
+  set shell=foo
+
+  normal 5Gi*
+  GitGutterStageHunk
+
+  call assert_equal('foo', &shell)
+  let &shell = _shell
+
+  call assert_equal([], s:signs('fixture.txt'))
+
+  " Buffer is unsaved
+  let expected = [
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index ae8e546..f5c6aff 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -5 +5 @@ d',
+        \ '-*e',
+        \ '+e'
+        \ ]
+  call assert_equal(expected, s:git_diff())
+
+  " Index has been updated
+  let expected = [
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index f5c6aff..ae8e546 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -5 +5 @@ d',
+        \ '-e',
+        \ '+*e'
+        \ ]
+  call assert_equal(expected, s:git_diff_staged())
+
+  " Save the buffer
+  write
+
+  call assert_equal([], s:git_diff())
+endfunction
+
+
+function Test_hunk_stage_nearby_hunk()
+  execute "normal! 2Gox\<CR>y\<CR>z"
+  normal 2jdd
+  normal k
+  GitGutterStageHunk
+
+  let expected = [
+        \ 'line=3  id=3000  name=GitGutterLineAdded',
+        \ 'line=4  id=3001  name=GitGutterLineAdded',
+        \ 'line=5  id=3002  name=GitGutterLineAdded'
+        \ ]
+  call assert_equal(expected, s:signs('fixture.txt'))
+
+  " Buffer is unsaved
+  let expected = [
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index 53b13df..f5c6aff 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -3,0 +4 @@ c',
+        \ '+d',
+        \ ]
+  call assert_equal(expected, s:git_diff())
+
+  " Index has been updated
+  let expected = [
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index f5c6aff..53b13df 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -4 +3,0 @@ c',
+        \ '-d',
+        \ ]
+  call assert_equal(expected, s:git_diff_staged())
+
+  " Save the buffer
+  write
+
+  let expected = [
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index 53b13df..8fdfda7 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -2,0 +3,3 @@ b',
+        \ '+x',
+        \ '+y',
+        \ '+z',
+        \ ]
+  call assert_equal(expected, s:git_diff())
+endfunction
+
+
+function Test_hunk_undo()
+  let _shell = &shell
+  set shell=foo
+
+  normal 5Gi*
+  GitGutterUndoHunk
+
+  call assert_equal('foo', &shell)
+  let &shell = _shell
+
+  call assert_equal([], s:signs('fixture.txt'))
+  call assert_equal([], s:git_diff())
+  call assert_equal([], s:git_diff_staged())
+endfunction
+
+
+function Test_undo_nearby_hunk()
+  execute "normal! 2Gox\<CR>y\<CR>z"
+  normal 2jdd
+  normal k
+  call s:trigger_gitgutter()
+  GitGutterUndoHunk
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=3  id=3000  name=GitGutterLineAdded',
+        \ 'line=4  id=3001  name=GitGutterLineAdded',
+        \ 'line=5  id=3002  name=GitGutterLineAdded'
+        \ ]
+  call assert_equal(expected, s:signs('fixture.txt'))
+
+  call assert_equal([], s:git_diff())
+
+  call assert_equal([], s:git_diff_staged())
+
+  " Save the buffer
+  write
+
+  let expected = [
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index f5c6aff..3fbde56 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -2,0 +3,3 @@ b',
+        \ '+x',
+        \ '+y',
+        \ '+z',
+        \ ]
+  call assert_equal(expected, s:git_diff())
+
+endfunction
+
+
+function Test_overlapping_hunk_op()
+  func Answer(char)
+    call feedkeys(a:char."\<CR>")
+  endfunc
+
+  " Undo upper
+
+  execute '3d'
+  execute '1d'
+  call s:trigger_gitgutter()
+  normal gg
+  call timer_start(100, {-> Answer('u')} )
+  GitGutterUndoHunk
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=2  id=3000  name=GitGutterLineRemoved',
+        \ ]
+  call assert_equal(expected, s:signs('fixture.txt'))
+
+  " Undo lower
+
+  execute '1d'
+  call s:trigger_gitgutter()
+  normal gg
+  call timer_start(100, {-> Answer('l')} )
+  GitGutterUndoHunk
+  call s:trigger_gitgutter()
+
+  let expected = [
+        \ 'line=1  id=3000  name=GitGutterLineRemovedFirstLine',
+        \ ]
+  call assert_equal(expected, s:signs('fixture.txt'))
+endfunction
+
+
+function Test_write_option()
+  set nowrite
+
+  normal ggo*
+  call s:trigger_gitgutter()
+
+  let expected = ["line=2  id=3000  name=GitGutterLineAdded"]
+  call assert_equal(expected, s:signs('fixture.txt'))
+
+  set write
+endfunction
+
+
+function Test_inner_text_object()
+  execute "normal! 2Gox\<CR>y\<CR>z\<CR>\<CR>"
+  call s:trigger_gitgutter()
+  normal dic
+  call s:trigger_gitgutter()
+
+  call assert_equal([], s:signs('fixture.txt'))
+  call assert_equal(readfile('fixture.txt'), getline(1,'$'))
+
+  " Excludes trailing lines
+  normal 9Gi*
+  normal 10Gi*
+  call s:trigger_gitgutter()
+  execute "normal vic\<Esc>"
+  call assert_equal([9, 10], [line("'<"), line("'>")])
+endfunction
+
+
+function Test_around_text_object()
+  execute "normal! 2Gox\<CR>y\<CR>z\<CR>\<CR>"
+  call s:trigger_gitgutter()
+  normal dac
+  call s:trigger_gitgutter()
+
+  call assert_equal([], s:signs('fixture.txt'))
+  call assert_equal(readfile('fixture.txt'), getline(1,'$'))
+
+  " Includes trailing lines
+  normal 9Gi*
+  normal 10Gi*
+  call s:trigger_gitgutter()
+  execute "normal vac\<Esc>"
+  call assert_equal([9, 11], [line("'<"), line("'>")])
+endfunction
+
+
+function Test_user_autocmd()
+  autocmd User GitGutter let s:autocmd_user = g:gitgutter_hook_context.bufnr
+
+  " Verify not fired when nothing changed.
+  let s:autocmd_user = 0
+  call s:trigger_gitgutter()
+  call assert_equal(0, s:autocmd_user)
+
+  " Verify fired when there was a change.
+  normal ggo*
+  let bufnr = bufnr('')
+  call s:trigger_gitgutter()
+  call assert_equal(bufnr, s:autocmd_user)
+endfunction
+
+
+function Test_fix_file_references()
+  " No special characters
+  let hunk_diff = join([
+        \ 'diff --git a/fixture.txt b/fixture.txt',
+        \ 'index f5c6aff..3fbde56 100644',
+        \ '--- a/fixture.txt',
+        \ '+++ b/fixture.txt',
+        \ '@@ -2,0 +3,1 @@ b',
+        \ '+x'
+        \ ], "\n")."\n"
+  let filepath = 'blah.txt'
+
+  let expected = join([
+        \ 'diff --git a/blah.txt b/blah.txt',
+        \ 'index f5c6aff..3fbde56 100644',
+        \ '--- a/blah.txt',
+        \ '+++ b/blah.txt',
+        \ '@@ -2,0 +3,1 @@ b',
+        \ '+x'
+        \ ], "\n")."\n"
+
+  call assert_equal(expected, gitgutter#hunk#fix_file_references(filepath, hunk_diff))
+
+  " diff.mnemonicPrefix; spaces in filename
+  let hunk_diff = join([
+        \ 'diff --git i/x/cat dog w/x/cat dog',
+        \ 'index f5c6aff..3fbde56 100644',
+        \ '--- i/x/cat dog',
+        \ '+++ w/x/cat dog',
+        \ '@@ -2,0 +3,1 @@ b',
+        \ '+x'
+        \ ], "\n")."\n"
+  let filepath = 'blah.txt'
+
+  let expected = join([
+        \ 'diff --git i/blah.txt w/blah.txt',
+        \ 'index f5c6aff..3fbde56 100644',
+        \ '--- i/blah.txt',
+        \ '+++ w/blah.txt',
+        \ '@@ -2,0 +3,1 @@ b',
+        \ '+x'
+        \ ], "\n")."\n"
+
+  call assert_equal(expected, gitgutter#hunk#fix_file_references(filepath, hunk_diff))
+
+  " Backslashes in filename; quotation marks
+  let hunk_diff = join([
+        \ 'diff --git "a/C:\\Users\\FOO~1.PAR\\AppData\\Local\\Temp\\nvimJcmSv9\\11.1.vim" "b/C:\\Users\\FOO~1.PAR\\AppData\\Local\\Temp\\nvimJcmSv9\\12.1.vim"',
+        \ 'index f42aeb0..4930403 100644',
+        \ '--- "a/C:\\Users\\FOO~1.PAR\\AppData\\Local\\Temp\\nvimJcmSv9\\11.1.vim"',
+        \ '+++ "b/C:\\Users\\FOO~1.PAR\\AppData\\Local\\Temp\\nvimJcmSv9\\12.1.vim"',
+        \ '@@ -172,0 +173 @@ stuff',
+        \ '+x'
+        \ ], "\n")."\n"
+  let filepath = 'init.vim'
+
+  let expected = join([
+        \ 'diff --git "a/init.vim" "b/init.vim"',
+        \ 'index f42aeb0..4930403 100644',
+        \ '--- "a/init.vim"',
+        \ '+++ "b/init.vim"',
+        \ '@@ -172,0 +173 @@ stuff',
+        \ '+x'
+        \ ], "\n")."\n"
+
+  call assert_equal(expected, gitgutter#hunk#fix_file_references(filepath, hunk_diff))
+endfunction
+
+
+function Test_encoding()
+  call system('cp ../cp932.txt . && git add cp932.txt')
+  edit ++enc=cp932 cp932.txt
+
+  call s:trigger_gitgutter()
+
+  call assert_equal([], s:signs('cp932.txt'))
+endfunction
+
+
+function Test_empty_file()
+  " 0-byte file
+  call system('touch empty.txt && git add empty.txt')
+  edit empty.txt
+
+  call s:trigger_gitgutter()
+  call assert_equal([], s:signs('empty.txt'))
+
+
+  " File consisting only of a newline
+  call system('echo "" > newline.txt && git add newline.txt')
+  edit newline.txt
+
+  call s:trigger_gitgutter()
+  call assert_equal([], s:signs('newline.txt'))
+
+
+  " 1 line file without newline
+  " Vim will force a newline unless we tell it not to.
+  call system('echo -n a > oneline.txt && git add oneline.txt')
+  set noeol nofixeol
+  edit! oneline.txt
+
+  call s:trigger_gitgutter()
+  call assert_equal([], s:signs('oneline.txt'))
+
+  set eol fixeol
+endfunction
diff --git a/vim/.vim/plugged/vim-gitgutter/unplace.vim b/vim/.vim/plugged/vim-gitgutter/unplace.vim
new file mode 100644
index 0000000..a97993d
--- /dev/null
+++ b/vim/.vim/plugged/vim-gitgutter/unplace.vim
@@ -0,0 +1,27 @@
+" Measure how long it takes to unplace signs.
+"
+" Source this file with `:source %` or `vim -S unplace.vim`
+
+
+let num = 500
+sign define Foo text=*
+
+new
+
+call append(0, range(1, num))
+
+for i in range(1, num)
+  execute "sign place ".i." line=".i." name=Foo buffer=".bufnr('')
+endfor
+
+let start = reltime()
+for i in range(1, num)
+  execute "sign unplace ".i
+endfor
+let elapsed = reltime(start)
+
+bdelete!
+
+echom split(reltimestr(elapsed))[0]."s to remove ".num." signs"
+echom string(reltimefloat(elapsed) * 1000 / num).' ms/sign'
+echom string(float2nr(num / reltimefloat(elapsed))).' sign/s'