diff --git a/.gitmodules b/.gitmodules
index ee17b37..e69de29 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,42 +0,0 @@
-[submodule "vim/bundle/pathogen"]
-	path = vim/bundle/pathogen
-    url = https://github.com/tpope/vim-pathogen
-[submodule "vim/bundle/fugitive"]
-	path = vim/bundle/fugitive
-    url = https://github.com/tpope/vim-fugitive
-[submodule "vim/bundle/commentary"]
-	path = vim/bundle/commentary
-    url = https://github.com/tpope/vim-commentary
-[submodule "vim/bundle/eunuch"]
-	path = vim/bundle/eunuch
-    url = https://github.com/tpope/vim-eunuch
-[submodule "vim/bundle/vinegar"]
-	path = vim/bundle/vinegar
-    url = https://github.com/tpope/vim-vinegar
-[submodule "vim/bundle/sleuth"]
-	path = vim/bundle/sleuth
-    url = https://github.com/tpope/vim-sleuth
-[submodule "vim/bundle/endwise"]
-	path = vim/bundle/endwise
-    url = https://github.com/tpope/vim-endwise
-[submodule "vim/bundle/tagbar"]
-	path = vim/bundle/tagbar
-    url = https://github.com/majutsushi/tagbar
-[submodule "vim/bundle/pencil"]
-	path = vim/bundle/pencil
-    url = https://github.com/reedes/vim-pencil
-[submodule "vim/bundle/snipmate"]
-	path = vim/bundle/snipmate
-	url = https://github.com/garbas/vim-snipmate
-[submodule "vim/bundle/snipmate-tlib"]
-	path = vim/bundle/snipmate-tlib
-	url = https://github.com/tomtom/tlib_vim
-[submodule "vim/bundle/snipmate-addon-mw-utils"]
-	path = vim/bundle/snipmate-addon-mw-utils
-	url = https://github.com/MarcWeber/vim-addon-mw-utils
-[submodule "vim/bundle/filetype-nix"]
-	path = vim/bundle/filetype-nix
-	url = https://github.com/LnL7/vim-nix
-[submodule "vim/bundle/supertab"]
-	path = vim/bundle/supertab
-	url = https://github.com/ervandew/supertab
diff --git a/aliases b/bash/.aliases
similarity index 100%
rename from aliases
rename to bash/.aliases
diff --git a/bash_profile b/bash/.bash_profile
similarity index 89%
rename from bash_profile
rename to bash/.bash_profile
index 22f9020..fd7e6f8 100644
--- a/bash_profile
+++ b/bash/.bash_profile
@@ -10,10 +10,16 @@ export PS3='select: '
 #{- ENVIRONMENT VARIABLES -}#
 
 # History preferences
-export HISTSIZE=-1
-export HISTFILESIZE=-1
-export HISTFILE="$HOME/.history/bash"
+if [ -w "$HOME/.history/bash" ]; then
+	if [ ! -d "$HOME/.history" ]; then
+		mkdir "$HOME/.history"
+	fi
+	touch "$HOME/.history/bash"
+fi
 export HISTCONTROL="erasedups:ignoreboth"
+export HISTFILE="$HOME/.history/bash"
+export HISTFILESIZE=-1
+export HISTSIZE=-1
 
 #{- SHELL OPTIONS -}#
 
diff --git a/bashrc b/bash/.bashrc
similarity index 100%
rename from bashrc
rename to bash/.bashrc
diff --git a/functions b/bash/.functions
similarity index 100%
rename from functions
rename to bash/.functions
diff --git a/ghci/.ghci b/ghci/.ghci
new file mode 100644
index 0000000..4972383
--- /dev/null
+++ b/ghci/.ghci
@@ -0,0 +1,6 @@
+-- Enable overloaded string literals
+:set -XOverloadedStrings
+-- Enable multiline formatting
+:set +m
+:set prompt  "\ESC[1;35mλ\ESC[1;34m>\ESC[0m "
+:set prompt2 "\ESC[1;34m|\ESC[1;35m>\ESC[0m "
diff --git a/ghci/.haskeline b/ghci/.haskeline
new file mode 100644
index 0000000..fa85bca
--- /dev/null
+++ b/ghci/.haskeline
@@ -0,0 +1,8 @@
+bellStyle: NoBell
+maxHistorySize: Just 100
+editMode: Vi
+completionType: MenuCompletion
+completionPaging: False
+completionPromptLimit: Just 100
+listCompletionsImmediately: True
+historyDuplicates: IgnoreAll
diff --git a/kwm/.khdrc b/kwm/.khdrc
new file mode 100644
index 0000000..eca9912
--- /dev/null
+++ b/kwm/.khdrc
@@ -0,0 +1,69 @@
+# Enable kwm compatibility khd kwm on
+khd kwm on
+
+cmd + shift - q : kwmc quit
+cmd + shift - r : kwmc config reload && khd -e "reload"
+
+cmd - return : "$HOME"/.kwm/iterm
+cmd - escape : "$HOME"/.kwm/screensaver
+
+cmd + alt + ctrl - space : kwmc config focus-follows-mouse toggle
+
+cmd - h : kwmc window -f west
+cmd - j : kwmc window -f south
+cmd - k : kwmc window -f north
+cmd - l : kwmc window -f east
+
+cmd + shift - h : kwmc window -s west
+cmd + shift - j : kwmc window -s south
+cmd + shift - k : kwmc window -s north
+cmd + shift - l : kwmc window -s east
+
+cmd + ctrl - h : kwmc window -c expand 0.05 west
+cmd + ctrl - j : kwmc window -c expand 0.05 south
+cmd + ctrl - k : kwmc window -c expand 0.05 north
+cmd + ctrl - l : kwmc window -c expand 0.05 east
+
+cmd + shift + ctrl - h : kwmc window -c reduce 0.05 west
+cmd + shift + ctrl - j : kwmc window -c reduce 0.05 south
+cmd + shift + ctrl - k : kwmc window -c reduce 0.05 north
+cmd + shift + ctrl - l : kwmc window -c reduce 0.05 east
+
+cmd - tab         : kwmc window -f next
+cmd + shift - tab : kwmc window -f prev 
+
+cmd - f : kwmc window -z fullscreen
+cmd - r : kwmc tree rotate 90
+
+cmd + ctrl - b : kwmc window -c type bsp
+cmd + ctrl - m : kwmc window -c type monocle
+cmd + ctrl - f : kwmc window -c type float
+
+cmd + shift - b : kwmc space -t bsp
+cmd + shift - m : kwmc space -t monocle
+cmd + shift - f : kwmc space -t float
+
+cmd - 1 : kwmc space -fExperimental 1
+cmd - 2 : kwmc space -fExperimental 2
+cmd - 3 : kwmc space -fExperimental 3
+cmd - 4 : kwmc space -fExperimental 4
+cmd - 5 : kwmc space -fExperimental 5
+cmd - 6 : kwmc space -fExperimental 6
+cmd - 7 : kwmc space -fExperimental 7
+cmd - 8 : kwmc space -fExperimental 8
+cmd - 9 : kwmc space -fExperimental 9
+cmd - 0 : kwmc space -fExperimental 10
+
+cmd + shift - 1 : kwmc window -m space 1
+cmd + shift - 2 : kwmc window -m space 2
+cmd + shift - 3 : kwmc window -m space 3
+cmd + shift - 4 : kwmc window -m space 4
+cmd + shift - 5 : kwmc window -m space 5
+cmd + shift - 6 : kwmc window -m space 6
+cmd + shift - 7 : kwmc window -m space 7
+cmd + shift - 8 : kwmc window -m space 8
+cmd + shift - 9 : kwmc window -m space 9
+cmd + shift - 0 : kwmc window -m space 10
+
+cmd - backspace : kwmc display -f next
+cmd + shift - backspace : kwmc window -m display next
diff --git a/kwm/.kwm/iterm b/kwm/.kwm/iterm
new file mode 100755
index 0000000..9f21dbc
--- /dev/null
+++ b/kwm/.kwm/iterm
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+if [ $# -eq 0 ]; then
+  osascript <<< "
+    tell application \"iTerm2\"
+      create window with default profile
+    end tell
+  "
+else
+  osascript <<< "
+    tell application \"iTerm2\"
+      create window with default profile command \"$*\"
+    end tell
+  "
+fi
diff --git a/kwm/.kwm/kwmrc b/kwm/.kwm/kwmrc
new file mode 100644
index 0000000..b40dd7c
--- /dev/null
+++ b/kwm/.kwm/kwmrc
@@ -0,0 +1,32 @@
+/*{-- Functional --}*/
+kwmc config tiling bsp
+kwmc config spawn right
+
+/* Focus follows the mouse and the mouse follows focus */
+kwmc config focus-follows-mouse on
+kwmc config mouse-follows-focus on
+
+/* Allow a window to be moved and resized by clicking with CMD held */
+kwmc config mouse-drag on
+kwmc config mouse-drag mod cmd
+
+/* Automagically resize windows */
+kwmc config lock-to-container on
+
+/* Allow window focus to wrap */
+kwmc config cycle-focus on
+
+kwmc config float-non-resizable on
+kwmc config standby-on-float on
+kwmc config center-on-float on
+
+kwmc rule owner="iTerm2" properties={role="AXDialog"}
+
+/*{-- Cosmetic --}*/
+kwmc config padding 30 30 30 30
+kwmc config gap 30 30
+
+kwmc config border focused on
+kwmc config border focused size 3
+kwmc config border focused color 0xFFAE9DAB
+kwmc config border focused radius 10
diff --git a/kwm/.kwm/screensaver b/kwm/.kwm/screensaver
new file mode 100755
index 0000000..19eb10b
--- /dev/null
+++ b/kwm/.kwm/screensaver
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+osascript << EOF
+  tell application "ScreenSaverEngine"
+		activate
+	end tell
+EOF
diff --git a/kwm/.kwm/vim b/kwm/.kwm/vim
new file mode 100755
index 0000000..2be6a76
--- /dev/null
+++ b/kwm/.kwm/vim
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+osascript <<< "
+  tell application \"iTerm2\"
+    create window with default profile command \"/Users/andrew/.nix-profile/bin/vim \\\"$@\\\"\"
+  end tell
+"
diff --git a/python/.pythonrc b/python/.pythonrc
new file mode 100644
index 0000000..8c57829
--- /dev/null
+++ b/python/.pythonrc
@@ -0,0 +1,48 @@
+#{- ~/.pythonrc -}#
+
+import atexit
+import os
+import readline
+import sys
+
+blue    = '\001\033[1;34m\002'
+yellow  = '\001\033[1;33m\002'
+
+magenta = '\001\033[1;35m\002'
+red     = '\001\033[1;31m\002'
+reset   = '\001\033[0m\002'
+
+# Primary prompt: (>>> ) in magenta
+sys.ps1 = blue + '>' + reset + ' '
+# Secondary prompt: (... ) in red
+sys.ps2 = yellow + '.' + reset + ' '
+
+# Use ~/.history/python as a history file instead of ~/.python_history
+def custom_readline():
+    import atexit
+    try:
+        import readline
+        import rlcompleter
+    except ImportError:
+        return
+
+    readline_doc = getattr(readline, '__doc__', '')
+    if readline_doc is not None and 'libedit' in readline_doc:
+        readline.parse_and_bind('bind ^I rl_complete')
+    else:
+        readline.parse_and_bind('tab: complete')
+    
+    try:
+        readline.read_init_file()
+    except OSError:
+        pass
+
+    if readline.get_current_history_length() == 0:
+        history = os.path.join(os.path.expanduser('~'), '.history', 'python')
+    try:
+        readline.read_history_file(history)
+    except IOError:
+        pass
+    atexit.register(readline.write_history_file, history)
+
+sys.__interactivehook__ = custom_readline
diff --git a/pythonrc b/pythonrc
deleted file mode 100644
index 2f88b26..0000000
--- a/pythonrc
+++ /dev/null
@@ -1,17 +0,0 @@
-#{- ~/.pythonrc -}#
-
-import atexit
-import os
-import readline
-import sys
-
-# Primary prompt: (>>> ) in magenta
-sys.ps1 = '\033[1;35m>>>\033[0m '
-# Secondary prompt: (... ) in red
-sys.ps2 = '\033[1;31m...\033[0m '
-
-# Use ~/.history/python as a history file instead of ~/.python_history
-history_file = os.path.join (os.environ['HOME'], '.history', 'python')
-if os.path.exists(history_file):
-    readline.read_history_file(history_file)
-atexit.register(readline.write_history_file, history_file)
diff --git a/inputrc b/readline/.inputrc
similarity index 100%
rename from inputrc
rename to readline/.inputrc
diff --git a/profile b/sh/.profile
similarity index 57%
rename from profile
rename to sh/.profile
index 074005e..91ed393 100644
--- a/profile
+++ b/sh/.profile
@@ -2,10 +2,23 @@
 
 #{- PROMPT -}#
 
-# Primary prompt: ($/# ) in magenta
-export PS1='\[\033[1;35m\]\$\[\033[0m\] '
-# Secondary prompt: (> ) in red
-export PS2='\[\033[1;31\]m>\[\033[0m\] '
+magenta="\[\033[1;35m\]"
+red="\[\033[1;31m\]"
+no_color="\[\033[0m\]"
+
+# Primary prompt: ($/# )
+# Secondary prompt: (> )
+# Primary prompt is magenta on local machines, red on remote hosts
+case $(hostname) in
+  pebble|stone|rock|boulder)
+    export PS1="${magenta}\$${no_color} "
+    export PS2="${red}>${no_color} "
+    ;;
+  *)
+    export PS1="$red\$$no_color "
+    export PS2="$magenta>$no_color "
+    ;;
+esac
 
 #{- PATH -}#
 
@@ -30,7 +43,13 @@ export LESSHISTFILE="-"
 export PYTHONSTARTUP="$HOME/.pythonrc"
 
 # History preferences
-export HISTFILE="$HOME/.history/posh"
+if [ -w "$HOME/.history/sh" ]; then
+	if [ ! -d "$HOME/.history" ]; then
+		mkdir "$HOME/.history"
+	fi
+	touch "$HOME/.history/sh"
+fi
+export HISTFILE="$HOME/.history/sh"
 export HISTSIZE=10000
 
 #{- SOURCING -}#
diff --git a/vim/.vim/bundle/commentary/CONTRIBUTING.markdown b/vim/.vim/bundle/commentary/CONTRIBUTING.markdown
new file mode 100644
index 0000000..b3f0095
--- /dev/null
+++ b/vim/.vim/bundle/commentary/CONTRIBUTING.markdown
@@ -0,0 +1 @@
+See the [contribution guidelines for pathogen.vim](https://github.com/tpope/vim-pathogen/blob/master/CONTRIBUTING.markdown).
diff --git a/vim/.vim/bundle/commentary/README.markdown b/vim/.vim/bundle/commentary/README.markdown
new file mode 100644
index 0000000..5387ba6
--- /dev/null
+++ b/vim/.vim/bundle/commentary/README.markdown
@@ -0,0 +1,51 @@
+# commentary.vim
+
+Comment stuff out.  Use `gcc` to comment out a line (takes a count),
+`gc` to comment out the target of a motion (for example, `gcap` to
+comment out a paragraph), `gc` in visual mode to comment out the selection,
+and `gc` in operator pending mode to target a comment.  You can also use
+it as a command, either with a range like `:7,17Commentary`, or as part of a
+`:global` invocation like with `:g/TODO/Commentary`. That's it.
+
+I wrote this because 5 years after Vim added support for mapping an
+operator, I still couldn't find a commenting plugin that leveraged that
+feature (I overlooked
+[tcomment.vim](https://github.com/tomtom/tcomment_vim)).  Striving for
+minimalism, it weighs in at under 100 lines of code.
+
+Oh, and it uncomments, too.  The above maps actually toggle, and `gcgc`
+uncomments a set of adjacent commented lines.
+
+## Installation
+
+If you don't have a preferred installation method, I recommend
+installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
+then simply copy and paste:
+
+    cd ~/.vim/bundle
+    git clone git://github.com/tpope/vim-commentary.git
+
+Once help tags have been generated, you can view the manual with
+`:help commentary`.
+
+## FAQ
+
+> My favorite file type isn't supported!
+
+Relax!  You just have to adjust `'commentstring'`:
+
+    autocmd FileType apache setlocal commentstring=#\ %s
+
+## Self-Promotion
+
+Like commentary.vim? Follow the repository on
+[GitHub](https://github.com/tpope/vim-commentary) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=3695).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/commentary/doc/commentary.txt b/vim/.vim/bundle/commentary/doc/commentary.txt
new file mode 100644
index 0000000..b048569
--- /dev/null
+++ b/vim/.vim/bundle/commentary/doc/commentary.txt
@@ -0,0 +1,32 @@
+*commentary.txt*  Comment stuff out
+
+Author:  Tim Pope <http://tpo.pe/>
+License: Same terms as Vim itself (see |license|)
+
+Comment stuff out.  Then uncomment it later.  Relies on 'commentstring' to be
+correctly set, or uses b:commentary_format if it is set.
+
+                                                *gc*
+gc{motion}              Comment or uncomment lines that {motion} moves over.
+
+                                                *gcc*
+gcc                     Comment or uncomment [count] lines.
+
+                                                *v_gc*
+{Visual}gc              Comment or uncomment the highlighted lines.
+
+                                                *o_gc*
+gc                      Text object for a comment (operator pending mode
+                        only.)
+
+                                                *gcgc* *gcu*
+gcgc                    Uncomment the current and adjacent commented lines.
+gcu
+
+                                                *:Commentary*
+:[range]Commentary      Comment or uncomment [range] lines
+
+The |User| CommentaryPost autocommand fires after a successful operation and
+can be used for advanced customization.
+
+ vim:tw=78:et:ft=help:norl:
diff --git a/vim/.vim/bundle/commentary/plugin/commentary.vim b/vim/.vim/bundle/commentary/plugin/commentary.vim
new file mode 100644
index 0000000..0bef7cc
--- /dev/null
+++ b/vim/.vim/bundle/commentary/plugin/commentary.vim
@@ -0,0 +1,103 @@
+" commentary.vim - Comment stuff out
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      1.3
+" GetLatestVimScripts: 3695 1 :AutoInstall: commentary.vim
+
+if exists("g:loaded_commentary") || &cp || v:version < 700
+  finish
+endif
+let g:loaded_commentary = 1
+
+function! s:surroundings() abort
+  return split(get(b:, 'commentary_format', substitute(substitute(
+        \ &commentstring, '\S\zs%s',' %s','') ,'%s\ze\S', '%s ', '')), '%s', 1)
+endfunction
+
+function! s:strip_white_space(l,r,line) abort
+  let [l, r] = [a:l, a:r]
+  if stridx(a:line,l) == -1 && stridx(a:line,l[0:-2]) == 0 && a:line[strlen(a:line)-strlen(r[1:]):-1] == r[1:]
+    return [l[0:-2], r[1:]]
+  endif
+  return [l, r]
+endfunction
+
+function! s:go(type,...) abort
+  if a:0
+    let [lnum1, lnum2] = [a:type, a:1]
+  else
+    let [lnum1, lnum2] = [line("'["), line("']")]
+  endif
+
+  let [l_, r_] = s:surroundings()
+  let uncomment = 2
+  for lnum in range(lnum1,lnum2)
+    let line = matchstr(getline(lnum),'\S.*\s\@<!')
+    let [l, r] = s:strip_white_space(l_,r_,line)
+    if line != '' && (stridx(line,l) || line[strlen(line)-strlen(r) : -1] != r)
+      let uncomment = 0
+    endif
+  endfor
+
+  for lnum in range(lnum1,lnum2)
+    let line = getline(lnum)
+    if strlen(r) > 2 && l.r !~# '\\'
+      let line = substitute(line,
+            \'\M'.r[0:-2].'\zs\d\*\ze'.r[-1:-1].'\|'.l[0].'\zs\d\*\ze'.l[1:-1],
+            \'\=substitute(submatch(0)+1-uncomment,"^0$\\|^-\\d*$","","")','g')
+    endif
+    if uncomment
+      let line = substitute(line,'\S.*\s\@<!','\=submatch(0)[strlen(l):-strlen(r)-1]','')
+    else
+      let line = substitute(line,'^\%('.matchstr(getline(lnum1),'^\s*').'\|\s*\)\zs.*\S\@<=','\=l.submatch(0).r','')
+    endif
+    call setline(lnum,line)
+  endfor
+  let modelines = &modelines
+  try
+    set modelines=0
+    silent doautocmd User CommentaryPost
+  finally
+    let &modelines = modelines
+  endtry
+endfunction
+
+function! s:textobject(inner) abort
+  let [l_, r_] = s:surroundings()
+  let [l, r] = [l_, r_]
+  let lnums = [line('.')+1, line('.')-2]
+  for [index, dir, bound, line] in [[0, -1, 1, ''], [1, 1, line('$'), '']]
+    while lnums[index] != bound && line ==# '' || !(stridx(line,l) || line[strlen(line)-strlen(r) : -1] != r)
+      let lnums[index] += dir
+      let line = matchstr(getline(lnums[index]+dir),'\S.*\s\@<!')
+      let [l, r] = s:strip_white_space(l_,r_,line)
+    endwhile
+  endfor
+  while (a:inner || lnums[1] != line('$')) && empty(getline(lnums[0]))
+    let lnums[0] += 1
+  endwhile
+  while a:inner && empty(getline(lnums[1]))
+    let lnums[1] -= 1
+  endwhile
+  if lnums[0] <= lnums[1]
+    execute 'normal! 'lnums[0].'GV'.lnums[1].'G'
+  endif
+endfunction
+
+xnoremap <silent> <Plug>Commentary     :<C-U>call <SID>go(line("'<"),line("'>"))<CR>
+nnoremap <silent> <Plug>Commentary     :<C-U>set opfunc=<SID>go<CR>g@
+nnoremap <silent> <Plug>CommentaryLine :<C-U>set opfunc=<SID>go<Bar>exe 'norm! 'v:count1.'g@_'<CR>
+onoremap <silent> <Plug>Commentary        :<C-U>call <SID>textobject(0)<CR>
+nnoremap <silent> <Plug>ChangeCommentary c:<C-U>call <SID>textobject(1)<CR>
+nmap <silent> <Plug>CommentaryUndo <Plug>Commentary<Plug>Commentary
+command! -range -bar Commentary call s:go(<line1>,<line2>)
+
+if !hasmapto('<Plug>Commentary') || maparg('gc','n') ==# ''
+  xmap gc  <Plug>Commentary
+  nmap gc  <Plug>Commentary
+  omap gc  <Plug>Commentary
+  nmap gcc <Plug>CommentaryLine
+  nmap cgc <Plug>ChangeCommentary
+  nmap gcu <Plug>Commentary<Plug>Commentary
+endif
+
+" vim:set et sw=2:
diff --git a/vim/.vim/bundle/endwise/CONTRIBUTING.markdown b/vim/.vim/bundle/endwise/CONTRIBUTING.markdown
new file mode 100644
index 0000000..b3f0095
--- /dev/null
+++ b/vim/.vim/bundle/endwise/CONTRIBUTING.markdown
@@ -0,0 +1 @@
+See the [contribution guidelines for pathogen.vim](https://github.com/tpope/vim-pathogen/blob/master/CONTRIBUTING.markdown).
diff --git a/vim/.vim/bundle/endwise/README.markdown b/vim/.vim/bundle/endwise/README.markdown
new file mode 100644
index 0000000..08f9d70
--- /dev/null
+++ b/vim/.vim/bundle/endwise/README.markdown
@@ -0,0 +1,42 @@
+# endwise.vim
+
+This is a simple plugin that helps to end certain structures
+automatically.  In Ruby, this means adding `end` after `if`, `do`, `def`
+and several other keywords. In Vimscript, this amounts to appropriately
+adding `endfunction`, `endif`, etc.  There's also Bourne shell, VB
+(don't ask), C/C++ preprocessor, and Lua support.
+
+A primary guiding principle in designing this plugin was that an
+erroneous insertion is never acceptable.  The behavior is only triggered
+once pressing enter on the end of the line.  When this happens, endwise
+searches for a matching end structure and only adds one if none is
+found.
+
+While the goal was to make it customizable, this turned out to be a tall
+order.  Every language has vastly different requirements.  Nonetheless,
+for those bold enough to attempt it, you can follow the model of the
+autocmds in the plugin to set the three magic variables governing
+endwise's behavior.
+
+## Installation
+
+If you don't have a preferred installation method, I recommend
+installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
+then simply copy and paste:
+
+    cd ~/.vim/bundle
+    git clone git://github.com/tpope/vim-endwise.git
+
+## Self-Promotion
+
+Like endwise.vim? Follow the repository on
+[GitHub](https://github.com/tpope/vim-endwise) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=2386).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/endwise/plugin/endwise.vim b/vim/.vim/bundle/endwise/plugin/endwise.vim
new file mode 100644
index 0000000..23eb339
--- /dev/null
+++ b/vim/.vim/bundle/endwise/plugin/endwise.vim
@@ -0,0 +1,196 @@
+" Location:     plugin/endwise.vim
+" Author:       Tim Pope <http://tpo.pe/>
+" Version:      1.2
+" License:      Same as Vim itself.  See :help license
+" GetLatestVimScripts: 2386 1 :AutoInstall: endwise.vim
+
+if exists("g:loaded_endwise") || &cp
+  finish
+endif
+let g:loaded_endwise = 1
+
+augroup endwise " {{{1
+  autocmd!
+  autocmd FileType lua
+        \ let b:endwise_addition = 'end' |
+        \ let b:endwise_words = 'function,do,then' |
+        \ let b:endwise_pattern = '^\s*\zs\%(\%(local\s\+\)\=function\)\>\%(.*\<end\>\)\@!\|\<\%(then\|do\)\ze\s*$' |
+        \ let b:endwise_syngroups = 'luaFunction,luaStatement,luaCond'
+  autocmd FileType elixir
+        \ let b:endwise_addition = 'end' |
+        \ let b:endwise_words = 'do,fn' |
+        \ let b:endwise_pattern = '.*[^.:@$]\zs\<\%(do\(:\)\@!\|fn\)\>\ze\%(.*[^.:@$]\<end\>\)\@!' |
+        \ let b:endwise_syngroups = 'elixirBlockDefinition'
+  autocmd FileType ruby
+        \ let b:endwise_addition = 'end' |
+        \ let b:endwise_words = 'module,class,def,if,unless,case,while,until,begin,do' |
+        \ let b:endwise_pattern = '^\(.*=\)\?\s*\%(private\s\+\|protected\s\+\|public\s\+\|module_function\s\+\)*\zs\%(module\|class\|def\|if\|unless\|case\|while\|until\|for\|\|begin\)\>\%(.*[^.:@$]\<end\>\)\@!\|\<do\ze\%(\s*|.*|\)\=\s*$' |
+        \ let b:endwise_syngroups = 'rubyModule,rubyClass,rubyDefine,rubyControl,rubyConditional,rubyRepeat'
+  autocmd FileType crystal
+        \ let b:endwise_addition = 'end' |
+        \ let b:endwise_words = 'module,class,lib,macro,struct,union,enum,def,if,unless,ifdef,case,while,until,for,begin,do' |
+        \ let b:endwise_pattern = '^\(.*=\)\?\s*\%(private\s\+\|protected\s\+\|public\s\+\|abstract\s\+\)*\zs\%(module\|class\|lib\|macro\|struct\|union\|enum\|def\|if\|unless\|ifdef\|case\|while\|until\|for\|begin\)\>\%(.*[^.:@$]\<end\>\)\@!\|\<do\ze\%(\s*|.*|\)\=\s*$' |
+        \ let b:endwise_syngroups = 'crystalModule,crystalClass,crystalLib,crystalMacro,crystalStruct,crystalDefine,crystalConditional,crystalRepeat,crystalControl'
+  autocmd FileType sh,zsh
+        \ let b:endwise_addition = '\=submatch(0)=="then" ? "fi" : submatch(0)=="case" ? "esac" : "done"' |
+        \ let b:endwise_words = 'then,case,do' |
+        \ let b:endwise_pattern = '\%(^\s*\zscase\>\ze\|\zs\<\%(do\|then\)\ze\s*$\)' |
+        \ let b:endwise_syngroups = 'shConditional,shLoop,shIf,shFor,shRepeat,shCaseEsac,zshConditional,zshRepeat,zshDelimiter'
+  autocmd FileType vb,vbnet,aspvbs
+        \ let b:endwise_addition = 'End &' |
+        \ let b:endwise_words = 'Function,Sub,Class,Module,Enum,Namespace' |
+        \ let b:endwise_pattern = '\%(\<End\>.*\)\@<!\<&\>' |
+        \ let b:endwise_syngroups = 'vbStatement,vbnetStorage,vbnetProcedure,vbnet.*Words,AspVBSStatement'
+  autocmd FileType vim
+        \ let b:endwise_addition = '\=submatch(0)=="augroup" ? submatch(0) . " END" : "end" . submatch(0)' |
+        \ let b:endwise_words = 'fu,fun,func,function,wh,while,if,for,try,au,augroup' |
+        \ let b:endwise_syngroups = 'vimFuncKey,vimNotFunc,vimCommand,vimAugroupKey'
+  autocmd FileType c,cpp,xdefaults,haskell
+        \ let b:endwise_addition = '#endif' |
+        \ let b:endwise_words = 'if,ifdef,ifndef' |
+        \ let b:endwise_pattern = '^\s*#\%(if\|ifdef\|ifndef\)\>' |
+        \ let b:endwise_syngroups = 'cPreCondit,cPreConditMatch,cCppInWrapper,xdefaultsPreProc'
+  autocmd FileType objc
+        \ let b:endwise_addition = '@end' |
+        \ let b:endwise_words = 'interface,implementation' |
+        \ let b:endwise_pattern = '^\s*@\%(interface\|implementation\)\>' |
+        \ let b:endwise_syngroups = 'objcObjDef'
+  autocmd FileType matlab
+        \ let b:endwise_addition = 'end' |
+        \ let b:endwise_words = 'function,if,for' |
+        \ let b:endwise_syngroups = 'matlabStatement,matlabFunction,matlabConditional,matlabRepeat'
+  autocmd FileType htmldjango
+        \ let b:endwise_addition = '{% end& %}' |
+        \ let b:endwise_words = 'autoescape,block\(\s\+\S*\)\?,blocktrans,cache,comment,filter,for,if,ifchanged,ifequal,ifnotequal,language,spaceless,verbatim,with' |
+        \ let b:endwise_syngroups = 'djangoTagBlock,djangoStatement'
+  autocmd FileType snippets
+        \ let b:endwise_addition = 'endsnippet' |
+        \ let b:endwise_words = 'snippet' |
+        \ let b:endwise_syngroups = 'snipSnippet,snipSnippetHeader,snipSnippetHeaderKeyword'
+  autocmd FileType * call s:abbrev()
+augroup END " }}}1
+
+function! s:abbrev()
+  if exists('g:endwise_abbreviations')
+    for word in split(get(b:, 'endwise_words', ''), ',')
+      execute 'iabbrev <buffer><script>' word word.'<CR><SID>DiscretionaryEnd<Space><C-U><BS>'
+    endfor
+  endif
+endfunction
+
+function! s:teardownMappings()
+  inoremap <buffer> <C-X><CR> <C-X><CR>
+  inoremap <buffer> <CR> <CR>
+endfunction
+
+" Functions {{{1
+
+function! EndwiseDiscretionary()
+  return <SID>crend(0)
+endfunction
+
+function! EndwiseAlways()
+  return <SID>crend(1)
+endfunction
+
+" }}}1
+
+" Maps {{{1
+
+if maparg("<Plug>DiscretionaryEnd") == ""
+  inoremap <silent> <SID>DiscretionaryEnd <C-R>=<SID>crend(0)<CR>
+  inoremap <silent> <SID>AlwaysEnd        <C-R>=<SID>crend(1)<CR>
+  imap    <script> <Plug>DiscretionaryEnd <SID>DiscretionaryEnd
+  imap    <script> <Plug>AlwaysEnd        <SID>AlwaysEnd
+endif
+
+if !exists('g:endwise_no_mappings')
+  if maparg('<CR>','i') =~# '<C-R>=.*crend(.)<CR>\|<\%(Plug\|SNR\|SID\)>.*End'
+    " Already mapped
+  elseif maparg('<CR>','i') =~ '<CR>'
+    exe "imap <script> <C-X><CR> ".maparg('<CR>','i')."<SID>AlwaysEnd"
+    exe "imap <script> <CR>      ".maparg('<CR>','i')."<SID>DiscretionaryEnd"
+  elseif maparg('<CR>','i') =~ '<Plug>\w\+CR'
+    exe "imap <C-X><CR> ".maparg('<CR>', 'i')."<Plug>AlwaysEnd"
+    exe "imap <CR> ".maparg('<CR>', 'i')."<Plug>DiscretionaryEnd"
+  else
+    imap <script> <C-X><CR> <CR><SID>AlwaysEnd
+    imap <CR> <CR><Plug>DiscretionaryEnd
+  endif
+  autocmd endwise CmdwinEnter * call s:teardownMappings()
+endif
+
+" }}}1
+
+" Code {{{1
+
+function! s:mysearchpair(beginpat,endpat,synpat)
+  let g:endwise_syntaxes = ""
+  let s:lastline = line('.')
+  call s:synname()
+  let line = searchpair(a:beginpat,'',a:endpat,'Wn','<SID>synname() !~# "^'.substitute(a:synpat,'\\','\\\\','g').'$"',line('.')+50)
+  return line
+endfunction
+
+function! s:crend(always)
+  let n = ""
+  if !exists("b:endwise_addition") || !exists("b:endwise_words") || !exists("b:endwise_syngroups")
+    return n
+  end
+  let synpat  = '\%('.substitute(b:endwise_syngroups,',','\\|','g').'\)'
+  let wordchoice = '\%('.substitute(b:endwise_words,',','\\|','g').'\)'
+  if exists("b:endwise_pattern")
+    let beginpat = substitute(b:endwise_pattern,'&',substitute(wordchoice,'\\','\\&','g'),'g')
+  else
+    let beginpat = '\<'.wordchoice.'\>'
+  endif
+  let lnum = line('.') - 1
+  let space = matchstr(getline(lnum),'^\s*')
+  let col  = match(getline(lnum),beginpat) + 1
+  let word  = matchstr(getline(lnum),beginpat)
+  let endword = substitute(word,'.*',b:endwise_addition,'')
+  let y = n.endword."\<C-O>O"
+  if b:endwise_addition[0:1] ==# '\='
+    let endpat = '\w\@<!'.endword.'\w\@!'
+  else
+    let endpat = '\w\@<!'.substitute('\w\+', '.*', b:endwise_addition, '').'\w\@!'
+  endif
+  if a:always
+    return y
+  elseif col <= 0 || synIDattr(synID(lnum,col,1),'name') !~ '^'.synpat.'$'
+    return n
+  elseif getline('.') !~ '^\s*#\=$'
+    return n
+  endif
+  let line = s:mysearchpair(beginpat,endpat,synpat)
+  " even is false if no end was found, or if the end found was less
+  " indented than the current line
+  let even = strlen(matchstr(getline(line),'^\s*')) >= strlen(space)
+  if line == 0
+    let even = 0
+  endif
+  if !even && line == line('.') + 1
+    return y
+  endif
+  if even
+    return n
+  endif
+  return y
+endfunction
+
+function! s:synname()
+  " Checking this helps to force things to stay in sync
+  while s:lastline < line('.')
+    let s = synIDattr(synID(s:lastline,indent(s:lastline)+1,1),'name')
+    let s:lastline = nextnonblank(s:lastline + 1)
+  endwhile
+
+  let s = synIDattr(synID(line('.'),col('.'),1),'name')
+  let g:endwise_syntaxes = g:endwise_syntaxes . line('.').','.col('.')."=".s."\n"
+  let s:lastline = line('.')
+  return s
+endfunction
+
+" }}}1
+
+" vim:set sw=2 sts=2:
diff --git a/vim/.vim/bundle/eunuch/README.markdown b/vim/.vim/bundle/eunuch/README.markdown
new file mode 100644
index 0000000..5f64b06
--- /dev/null
+++ b/vim/.vim/bundle/eunuch/README.markdown
@@ -0,0 +1,52 @@
+# eunuch.vim
+
+Vim sugar for the UNIX shell commands that need it the most.  Features
+include:
+
+* `:Remove`: Delete a buffer and the file on disk simultaneously.
+* `:Unlink`: Like `:Remove`, but keeps the now empty buffer.
+* `:Move`: Rename a buffer and the file on disk simultaneously.
+* `:Rename`: Like `:Move`, but relative to the current file's containing directory.
+* `:Chmod`: Change the permissions of the current file.
+* `:Mkdir`: Create a directory, defaulting to the parent of the current file.
+* `:Find`: Run `find` and load the results into the quickfix list.
+* `:Locate`: Run `locate` and load the results into the quickfix list.
+* `:Wall`: Write every open window.  Handy for kicking off tools like [guard][].
+* `:SudoWrite`: Write a privileged file with `sudo`.
+* `:SudoEdit`: Edit a privileged file with `sudo`.
+* File type detection for `sudo -e` is based on original file name.
+* New files created with a shebang line are automatically made executable.
+* New init scripts are automatically prepopulated with `/etc/init.d/skeleton`.
+
+[guard]: https://github.com/guard/guard
+
+## Installation
+
+If you don't have a preferred installation method, I recommend
+installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
+then simply copy and paste:
+
+    cd ~/.vim/bundle
+    git clone git://github.com/tpope/vim-eunuch.git
+
+Once help tags have been generated, you can view the manual with
+`:help eunuch`.
+
+## Contributing
+
+See the contribution guidelines for
+[pathogen.vim](https://github.com/tpope/vim-pathogen#readme).
+
+## Self-Promotion
+
+Like eunuch.vim? Follow the repository on
+[GitHub](https://github.com/tpope/vim-eunuch) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=4300).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/eunuch/plugin/eunuch.vim b/vim/.vim/bundle/eunuch/plugin/eunuch.vim
new file mode 100644
index 0000000..2dab31c
--- /dev/null
+++ b/vim/.vim/bundle/eunuch/plugin/eunuch.vim
@@ -0,0 +1,213 @@
+" eunuch.vim - Helpers for UNIX
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      1.1
+
+if exists('g:loaded_eunuch') || &cp || v:version < 700
+  finish
+endif
+let g:loaded_eunuch = 1
+
+function! s:fnameescape(string) abort
+  if exists('*fnameescape')
+    return fnameescape(a:string)
+  elseif a:string ==# '-'
+    return '\-'
+  else
+    return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
+  endif
+endfunction
+
+function! s:separator()
+  return !exists('+shellslash') || &shellslash ? '/' : '\\'
+endfunction
+
+command! -bar -bang Unlink
+      \ if <bang>1 && &modified |
+      \   edit |
+      \ elseif delete(expand('%')) |
+      \   echoerr 'Failed to delete "'.expand('%').'"' |
+      \ else |
+      \   edit! |
+      \ endif
+
+command! -bar -bang Remove
+      \ let s:file = fnamemodify(bufname(<q-args>),':p') |
+      \ execute 'bdelete<bang>' |
+      \ if !bufloaded(s:file) && delete(s:file) |
+      \   echoerr 'Failed to delete "'.s:file.'"' |
+      \ endif |
+      \ unlet s:file
+
+command! -bar -nargs=1 -bang -complete=file Move :
+      \ let s:src = expand('%:p') |
+      \ let s:dst = expand(<q-args>) |
+      \ if isdirectory(s:dst) || s:dst[-1:-1] =~# '[\\/]' |
+      \   let s:dst .= (s:dst[-1:-1] =~# '[\\/]' ? '' : s:separator()) .
+      \     fnamemodify(s:src, ':t') |
+      \ endif |
+      \ if !isdirectory(fnamemodify(s:dst, ':h')) |
+      \   call mkdir(fnamemodify(s:dst, ':h'), 'p') |
+      \ endif |
+      \ let s:dst = substitute(simplify(s:dst), '^\.\'.s:separator(), '', '') |
+      \ if <bang>1 && filereadable(s:dst) |
+      \   exe 'keepalt saveas '.s:fnameescape(s:dst) |
+      \ elseif rename(s:src, s:dst) |
+      \   echoerr 'Failed to rename "'.s:src.'" to "'.s:dst.'"' |
+      \ else |
+      \   setlocal modified |
+      \   exe 'keepalt saveas! '.s:fnameescape(s:dst) |
+      \   if s:src !=# expand('%:p') |
+      \     execute 'bwipe '.s:fnameescape(s:src) |
+      \   endif |
+      \ endif |
+      \ unlet s:src |
+      \ unlet s:dst |
+      \ filetype detect
+
+function! s:Rename_complete(A, L, P) abort
+  let sep = s:separator()
+  let prefix = expand('%:p:h').sep
+  let files = split(glob(prefix.a:A.'*'), "\n")
+  call filter(files, 'simplify(v:val) !=# simplify(expand("%:p"))')
+  call map(files, 'v:val[strlen(prefix) : -1] . (isdirectory(v:val) ? sep : "")')
+  return join(files + ['..'.s:separator()], "\n")
+endfunction
+
+command! -bar -nargs=1 -bang -complete=custom,s:Rename_complete Rename
+      \ Move<bang> %:h/<args>
+
+command! -bar -nargs=1 Chmod :
+      \ echoerr get(split(system('chmod '.<q-args>.' '.shellescape(expand('%'))), "\n"), 0, '') |
+
+command! -bar -bang -nargs=? -complete=dir Mkdir
+      \ call mkdir(empty(<q-args>) ? expand('%:h') : <q-args>, <bang>0 ? 'p' : '') |
+      \ if empty(<q-args>) |
+      \  silent keepalt execute 'file' s:fnameescape(expand('%')) |
+      \ endif
+
+command! -bar -bang -complete=file -nargs=+ Find   exe s:Grep(<q-bang>, <q-args>, 'find')
+command! -bar -bang -complete=file -nargs=+ Locate exe s:Grep(<q-bang>, <q-args>, 'locate')
+function! s:Grep(bang,args,prg) abort
+  let grepprg = &l:grepprg
+  let grepformat = &l:grepformat
+  let shellpipe = &shellpipe
+  try
+    let &l:grepprg = a:prg
+    setlocal grepformat=%f
+    if &shellpipe ==# '2>&1| tee' || &shellpipe ==# '|& tee'
+      let &shellpipe = "| tee"
+    endif
+    execute 'grep! '.a:args
+    if empty(a:bang) && !empty(getqflist())
+      return 'cfirst'
+    else
+      return ''
+    endif
+  finally
+    let &l:grepprg = grepprg
+    let &l:grepformat = grepformat
+    let &shellpipe = shellpipe
+  endtry
+endfunction
+
+function! s:SudoSetup(file) abort
+  if !filereadable(a:file) && !exists('#BufReadCmd#'.s:fnameescape(a:file))
+    execute 'autocmd BufReadCmd ' s:fnameescape(a:file) 'call s:SudoReadCmd()'
+  endif
+  if !filewritable(a:file) && !exists('#BufWriteCmd#'.s:fnameescape(a:file))
+    execute 'autocmd BufReadPost ' s:fnameescape(a:file) 'set noreadonly'
+    execute 'autocmd BufWriteCmd ' s:fnameescape(a:file) 'call s:SudoWriteCmd()'
+  endif
+endfunction
+
+function! s:SudoReadCmd() abort
+  silent %delete_
+  let pipe = printf(&shellpipe . (&shellpipe =~ '%s' ? '' : ' %s'), '/dev/null')
+  execute (has('gui_running') ? '' : 'silent') 'read !env SUDO_EDITOR=cat VISUAL=cat sudo -e "%" ' . pipe
+  silent 1delete_
+  set nomodified
+endfunction
+
+function! s:SudoWriteCmd() abort
+  execute (has('gui_running') ? '' : 'silent') 'write !env SUDO_EDITOR=tee VISUAL=tee sudo -e "%" >/dev/null'
+  let &modified = v:shell_error
+endfunction
+
+command! -bar -bang -complete=file -nargs=? SudoEdit
+      \ call s:SudoSetup(fnamemodify(empty(<q-args>) ? expand('%') : <q-args>, ':p')) |
+      \ if !&modified || !empty(<q-args>) |
+      \   edit<bang> <args> |
+      \ endif |
+      \ if empty(<q-args>) || expand('%:p') ==# fnamemodify(<q-args>, ':p') |
+      \   set noreadonly |
+      \ endif
+
+if exists(':SudoWrite') != 2
+command! -bar SudoWrite
+      \ call s:SudoSetup(expand('%:p')) |
+      \ write!
+endif
+
+function! s:SudoEditInit() abort
+  let files = split($SUDO_COMMAND, ' ')[1:-1]
+  if len(files) ==# argc()
+    for i in range(argc())
+      execute 'autocmd BufEnter' s:fnameescape(argv(i))
+            \ 'if empty(&filetype) || &filetype ==# "conf"'
+            \ '|doautocmd filetypedetect BufReadPost' s:fnameescape(files[i])
+            \ '|endif'
+    endfor
+  endif
+endfunction
+if $SUDO_COMMAND =~# '^sudoedit '
+  call s:SudoEditInit()
+endif
+
+command! -bar -nargs=? Wall
+      \ if empty(<q-args>) |
+      \   call s:Wall() |
+      \ else |
+      \   call system('wall', <q-args>) |
+      \ endif
+if exists(':W') !=# 2
+  command! -bar W Wall
+endif
+function! s:Wall() abort
+  let tab = tabpagenr()
+  let win = winnr()
+  let seen = {}
+  if !&readonly && expand('%') !=# ''
+    let seen[bufnr('')] = 1
+    write
+  endif
+  tabdo windo if !&readonly && &buftype =~# '^\%(acwrite\)\=$' && expand('%') !=# '' && !has_key(seen, bufnr('')) | silent write | let seen[bufnr('')] = 1 | endif
+  execute 'tabnext '.tab
+  execute win.'wincmd w'
+endfunction
+
+augroup eunuch
+  autocmd!
+  autocmd BufNewFile  * let b:brand_new_file = 1
+  autocmd BufWritePost * unlet! b:brand_new_file
+  autocmd BufWritePre *
+        \ if exists('b:brand_new_file') |
+        \   if getline(1) =~ '^#!' |
+        \     let b:chmod_post = '+x' |
+        \   endif |
+        \ endif
+  autocmd BufWritePost,FileWritePost * nested
+        \ if exists('b:chmod_post') && executable('chmod') |
+        \   silent! execute '!chmod '.b:chmod_post.' "<afile>"' |
+        \   edit |
+        \   unlet b:chmod_post |
+        \ endif
+
+  autocmd BufNewFile */init.d/*
+        \ if filereadable("/etc/init.d/skeleton") |
+        \   keepalt read /etc/init.d/skeleton |
+        \   1delete_ |
+        \ endif |
+        \ set ft=sh
+augroup END
+
+" vim:set sw=2 sts=2:
diff --git a/vim/.vim/bundle/filetype-nix/.travis.yml b/vim/.vim/bundle/filetype-nix/.travis.yml
new file mode 100644
index 0000000..27e8060
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/.travis.yml
@@ -0,0 +1,6 @@
+language: vim
+
+before_script: |
+  git clone https://github.com/junegunn/vader.vim.git
+script: |
+  ./test/run-tests.sh
diff --git a/vim/.vim/bundle/filetype-nix/LICENSE b/vim/.vim/bundle/filetype-nix/LICENSE
new file mode 100644
index 0000000..16dc3e8
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 <Daiderd Jordan>
+
+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/bundle/filetype-nix/README.md b/vim/.vim/bundle/filetype-nix/README.md
new file mode 100644
index 0000000..e5bcc3c
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/README.md
@@ -0,0 +1,48 @@
+# vim-nix
+
+[![Build Status](https://travis-ci.org/LnL7/vim-nix.svg?branch=master)](https://travis-ci.org/LnL7/vim-nix)
+
+Support for writing [Nix expressions](http://nixos.org/nix/manual/#chap-writing-nix-expressions) in vim.
+
+Features included so far:
+
+* Syntax highlighting for Nix
+* Filetype detection for `.nix` files
+* Automatic indentation
+
+
+## Installation
+
+### Plugin managers
+
+The most common plugin managers include [vim-plug][vim-plug],
+[NeoBundle][neobundle], [Vundle][vundle] and [pathogen.vim][pathogen].
+
+With pathogen.vim, just clone this repository inside `~/.vim/bundle`:
+
+```bash
+git clone https://github.com/LnL7/vim-nix.git ~/.vim/bundle
+```
+
+With the other plugin managers, just follow the instructions on the homepage of
+each plugin. In general, you have to add a line to your `~/.vimrc`:
+
+```viml
+" vim-plug
+Plug 'LnL7/vim-nix'
+" NeoBundle
+NeoBundle 'LnL7/vim-nix'
+" Vundle
+Plugin 'LnL7/vim-nix'
+```
+
+### Manual installation
+
+Copy the contents of each directory in the respective directories inside
+`~/.vim`.
+
+
+[vim-plug]: https://github.com/junegunn/vim-plug
+[vundle]: https://github.com/gmarik/Vundle.vim
+[neobundle]: https://github.com/Shougo/neobundle.vim
+[pathogen]: https://github.com/tpope/vim-pathogen
diff --git a/vim/.vim/bundle/filetype-nix/default.nix b/vim/.vim/bundle/filetype-nix/default.nix
new file mode 100644
index 0000000..70f3fc0
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/default.nix
@@ -0,0 +1,47 @@
+{ pkgs ? import <nixpkgs> {} }:
+
+let
+  inherit (pkgs) stdenv fetchFromGitHub writeText runCommand;
+
+  vim-vader = fetchFromGitHub {
+    owner = "junegunn";
+    repo = "vader.vim";
+    rev = "ad2c752435baba9e7544d0046f0277c3573439bd";
+    sha256 = "0yvnah4lxk5w5qidc3y5nvl6lpi8rcv26907b3w7vjskqc935b8f";
+  };
+
+  vim-nix = ./.;
+
+  rcFile = writeText "vimrc" ''
+    filetype off
+    set rtp+=${vim-vader}
+    set rtp+=${vim-nix}
+    filetype plugin indent on
+    syntax enable
+  '';
+
+  vim = "${pkgs.vim}/bin/vim";
+
+  env = stdenv.mkDerivation {
+    name = "build-environment";
+    shellHook = ''
+      alias vim='${vim} -XNu ${rcFile} -i NONE'
+    '';
+  };
+
+in stdenv.mkDerivation {
+  name = "vim-nix-2016-08-07";
+
+  src = ./.;
+
+  installPhase = ''
+    mkdir -p $out
+    cp -r ftdetect ftplugin indent syntax $out
+  '';
+
+  checkPhase = ''
+    ( ${vim} -XNu ${rcFile} -i NONE -c 'Vader! test/*.vader' ) |& tee vim-nix-test.log >&2
+  '';
+
+  doCheck = true;
+} // { inherit env; }
diff --git a/vim/.vim/bundle/filetype-nix/ftdetect/nix.vim b/vim/.vim/bundle/filetype-nix/ftdetect/nix.vim
new file mode 100644
index 0000000..bb03a89
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/ftdetect/nix.vim
@@ -0,0 +1,7 @@
+" Vim filetype detect
+" Language:    Nix
+" Maintainer:  Daiderd Jordan <daiderd@gmail.com>
+" URL:         https://github.com/LnL7/vim-nix
+
+au BufRead,BufNewFile *.nix set filetype=nix
+au FileType nix setl sw=2 sts=2 et iskeyword+=-
diff --git a/vim/.vim/bundle/filetype-nix/ftplugin/nix.vim b/vim/.vim/bundle/filetype-nix/ftplugin/nix.vim
new file mode 100644
index 0000000..b739fc7
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/ftplugin/nix.vim
@@ -0,0 +1,13 @@
+" Vim filetype plugin
+" Language:    Nix
+" Maintainer:  Daiderd Jordan <daiderd@gmail.com>
+" URL:         https://github.com/LnL7/vim-nix
+
+if (exists("b:did_ftplugin"))
+  finish
+endif
+let b:did_ftplugin = 1
+
+
+setlocal comments=:#
+setlocal commentstring=#\ %s
diff --git a/vim/.vim/bundle/filetype-nix/indent/nix.vim b/vim/.vim/bundle/filetype-nix/indent/nix.vim
new file mode 100644
index 0000000..e5a4eb0
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/indent/nix.vim
@@ -0,0 +1,62 @@
+" Vim indent file
+" Language:    Nix
+" Maintainer:  Daiderd Jordan <daiderd@gmail.com>
+" URL:         https://github.com/LnL7/vim-nix
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetNixIndent()
+
+if exists("*GetNixIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+let s:skip_syntax  = '\%(Comment\|String\)$'
+let s:block_open   = '\%({\|[\)'
+let s:block_close  = '\%(}\|]\)'
+
+function! GetNixIndent()
+  let lnum = prevnonblank(v:lnum - 1)
+  let ind  = indent(lnum)
+
+  " At the start of the file use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  if synIDattr(synID(v:lnum, 1, 1), "name") !~ s:skip_syntax
+    let current_line = getline(v:lnum)
+    let last_line = getline(lnum)
+
+    if last_line =~ s:block_open . '\s*$'
+      let ind += &sw
+    endif
+
+    if current_line =~ '^\s*' . s:block_close
+      let ind -= &sw
+    endif
+
+    if last_line =~ '\<let\s*$'
+      let ind += &sw
+    endif
+
+    if last_line =~ '^\<in\s*$'
+      let ind += &sw
+    endif
+
+    if current_line =~ '^\s*in\>'
+      let ind -= &sw
+    endif
+  endif
+
+  return ind
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
diff --git a/vim/.vim/bundle/filetype-nix/syntax/nix.vim b/vim/.vim/bundle/filetype-nix/syntax/nix.vim
new file mode 100644
index 0000000..c7d8d20
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/syntax/nix.vim
@@ -0,0 +1,183 @@
+" Vim syntax file
+" Language:    Nix
+" Maintainer:  Daiderd Jordan <daiderd@gmail.com>
+" URL:         https://github.com/LnL7/vim-nix
+
+if exists("b:current_syntax")
+  finish
+endif
+
+syn keyword nixBoolean     true false
+syn keyword nixNull        null
+syn keyword nixRecKeyword  rec
+
+syn keyword nixOperator or
+syn match   nixOperator '!=\|!'
+syn match   nixOperator '<=\?'
+syn match   nixOperator '>=\?'
+syn match   nixOperator '&&'
+syn match   nixOperator '//\='
+syn match   nixOperator '=='
+syn match   nixOperator '?'
+syn match   nixOperator '||'
+syn match   nixOperator '++\='
+syn match   nixOperator '-'
+syn match   nixOperator '\*'
+syn match   nixOperator '->'
+
+syn match nixParen '[()]'
+syn match nixInteger '\d\+'
+
+syn keyword nixTodo FIXME NOTE TODO OPTIMIZE XXX HACK contained
+syn match   nixComment '#.*' contains=nixTodo,@Spell
+syn region  nixComment start=+/\*+ end=+\*/+ contains=nixTodo,@Spell
+
+syn region nixInterpolation matchgroup=nixInterpolationDelimiter start="\${" end="}" contained contains=@nixExpr,nixInterpolationParam
+
+syn match nixSimpleStringSpecial /\\["nrt\\$]/ contained
+syn match nixInterpolationSpecial /''['$]/ contained
+
+syn region nixSimpleString matchgroup=nixStringDelimiter start=+"+ skip=+\\"+ end=+"+ contains=nixInterpolation,nixSimpleStringSpecial
+syn region nixString matchgroup=nixStringDelimiter start=+''+ skip=+''['$]+ end=+''+ contains=nixInterpolation,nixInterpolationSpecial
+
+syn match nixFunctionCall "[a-zA-Z_][a-zA-Z0-9_'-]*"
+
+syn match nixPath "[a-zA-Z0-9._+-]*\%(/[a-zA-Z0-9._+-]\+\)\+"
+syn match nixHomePath "\~\%(/[a-zA-Z0-9._+-]\+\)\+"
+syn match nixSearchPath "[a-zA-Z0-9._+-]\+\%(\/[a-zA-Z0-9._+-]\+\)*" contained
+syn match nixPathDelimiter "[<>]" contained
+syn match nixSearchPathRef "<[a-zA-Z0-9._+-]\+\%(\/[a-zA-Z0-9._+-]\+\)*>" contains=nixSearchPath,nixPathDelimiter
+syn match nixURI "[a-zA-Z][a-zA-Z0-9.+-]*:[a-zA-Z0-9%/?:@&=$,_.!~*'+-]\+"
+
+syn match nixAttributeDot "\." contained
+syn match nixAttribute "[a-zA-Z_][a-zA-Z0-9_'-]*\ze\%([^a-zA-Z0-9_'-.]\|$\)" contained
+syn region nixAttributeAssignment start="=" end="\ze;" contained contains=@nixExpr
+syn region nixAttributeDefinition start=/\ze[a-zA-Z_"$]/ end=";" contained contains=nixComment,nixAttribute,nixInterpolation,nixSimpleString,nixAttributeDot,nixAttributeAssignment
+
+syn region nixInheritAttributeScope start="(" end=")" contained contains=nixComment,nixAttributeDot
+syn region nixAttributeDefinition matchgroup=nixInherit start="\<inherit\>" matchgroup=NONE end=";" contained contains=nixComment,nixInheritAttributeScope,nixAttribute
+
+syn region nixAttributeSet start="{" end="}" contains=nixComment,nixAttributeDefinition
+
+"                                                                                                              vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn region nixArgumentDefinitionWithDefault matchgroup=nixArgumentDefinition start="[a-zA-Z_][a-zA-Z0-9_'-]*\ze\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*?\@=" matchgroup=NONE end="[,}]\@=" transparent contained contains=@nixExpr
+"                                                           vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn match nixArgumentDefinition "[a-zA-Z_][a-zA-Z0-9_'-]*\ze\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*[,}]\@=" contained
+syn match nixArgumentEllipsis "\.\.\." contained
+syn match nixArgumentSeparator "," contained
+
+"                          vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv                        vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn match nixArgOperator '@\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*[a-zA-Z_][a-zA-Z0-9_'-]*\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*:'he=s+1 contained contains=nixAttribute
+
+"                                                 vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn match nixArgOperator '[a-zA-Z_][a-zA-Z0-9_'-]*\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*@'hs=e-1 contains=nixAttribute nextgroup=nixFunctionArgument
+
+" This is a bit more complicated, because function arguments can be passed in a
+" very similar form on how attribute sets are defined and two regions with the
+" same start patterns will shadow each other. Instead of a region we could use a
+" match on {\_.\{-\}}, which unfortunately doesn't take nesting into account.
+"
+" So what we do instead is that we look forward until we are sure that it's a
+" function argument. Unfortunately, we need to catch comments and both vertical
+" and horizontal white space, which the following regex should hopefully do:
+"
+" "\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*"
+"
+" It is also used throught the whole file and is marked with 'v's as well.
+"
+" Fortunately the matching rules for function arguments are much simpler than
+" for real attribute sets, because we can stop when we hit the first ellipsis or
+" default value operator, but we also need to paste the "whitespace & comments
+" eating" regex all over the place (marked with 'v's):
+"
+" Region match 1: { foo ? ... } or { foo, ... } or { ... } (ellipsis)
+"                                         vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv   {----- identifier -----}vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn region nixFunctionArgument start="{\ze\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*\%([a-zA-Z_][a-zA-Z0-9_'-]*\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*[,?}]\|\.\.\.\)" end="}" contains=nixComment,nixArgumentDefinitionWithDefault,nixArgumentDefinition,nixArgumentEllipsis,nixArgumentSeparator nextgroup=nixArgOperator
+
+" Now it gets more tricky, because we need to look forward for the colon, but
+" there could be something like "{}@foo:", even though it's highly unlikely.
+"
+" Region match 2: {}
+"                                         vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv    vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv@vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv{----- identifier -----}  vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn region nixFunctionArgument start="{\ze\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*}\%(\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*@\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*[a-zA-Z_][a-zA-Z0-9_'-]*\)\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*:" end="}" contains=nixComment nextgroup=nixArgOperator
+
+"                                                               vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+syn match nixSimpleFunctionArgument "[a-zA-Z_][a-zA-Z0-9_'-]*\ze\%(\s\|#.\{-\}\n\|\n\|/\*\_.\{-\}\*/\)*:/\@!"
+
+syn region nixList matchgroup=nixListBracket start="\[" end="\]" contains=@nixExpr
+
+syn region nixLetExpr matchgroup=nixLetExprKeyword start="\<let\>" end="\<in\>" contains=nixComment,nixAttributeDefinition
+
+syn keyword nixIfExprKeyword then contained
+syn region nixIfExpr matchgroup=nixIfExprKeyword start="\<if\>" end="\<else\>" contains=@nixExpr,nixIfExprKeyword
+
+syn region nixWithExpr matchgroup=nixWithExprKeyword start="\<with\>" matchgroup=NONE end=";" contains=@nixExpr
+
+syn region nixAssertExpr matchgroup=nixAssertKeyword start="\<assert\>" matchgroup=NONE end=";" contains=@nixExpr
+
+syn cluster nixExpr contains=nixBoolean,nixNull,nixOperator,nixParen,nixInteger,nixRecKeyword,nixConditional,nixBuiltin,nixSimpleBuiltin,nixComment,nixFunctionCall,nixFunctionArgument,nixSimpleFunctionArgument,nixPath,nixHomePath,nixSearchPathRef,nixURI,nixAttributeSet,nixList,nixSimpleString,nixString,nixLetExpr,nixIfExpr,nixWithExpr,nixAssertExpr
+
+" These definitions override @nixExpr and have to come afterwards:
+
+syn match nixInterpolationParam "[a-zA-Z_][a-zA-Z0-9_'-]*\%(\.[a-zA-Z_][a-zA-Z0-9_'-]*\)*" contained
+
+" Non-namespaced Nix builtins as of version 1.10:
+syn keyword nixSimpleBuiltin
+      \ abort baseNameOf derivation dirOf fetchTarball import map removeAttrs
+      \ throw toString
+
+" Namespaced and non-namespaced Nix builtins as of version 1.10:
+syn keyword nixNamespacedBuiltin contained
+      \ abort add all any attrNames attrValues baseNameOf compareVersions
+      \ concatLists currentSystem deepSeq derivation dirOf div elem elemAt
+      \ fetchTarball fetchurl filter filterSource foldl' fromJSON genList
+      \ getAttr getEnv hasAttr hashString head import intersectAttrs isAttrs
+      \ isBool isFunction isInt isList isString length lessThan listToAttrs map
+      \ mul parseDrvName pathExists readDir readFile removeAttrs replaceStrings
+      \ seq sort stringLength sub substring tail throw toFile toJSON toPath
+      \ toString toXML trace typeOf
+
+syn match nixBuiltin "builtins\.[a-zA-Z']\+"he=s+9 contains=nixComment,nixNamespacedBuiltin
+
+hi def link nixArgOperator            Operator
+hi def link nixArgumentDefinition     Identifier
+hi def link nixArgumentEllipsis       Operator
+hi def link nixAssertKeyword          Keyword
+hi def link nixAttribute              Identifier
+hi def link nixAttributeDot           Operator
+hi def link nixBoolean                Boolean
+hi def link nixBuiltin                Special
+hi def link nixComment                Comment
+hi def link nixConditional            Conditional
+hi def link nixHomePath               Include
+hi def link nixIfExprKeyword          Keyword
+hi def link nixInherit                Keyword
+hi def link nixInteger                Integer
+hi def link nixInterpolation          Macro
+hi def link nixInterpolationDelimiter Delimiter
+hi def link nixInterpolationParam     Macro
+hi def link nixInterpolationSpecial   Special
+hi def link nixLetExprKeyword         Keyword
+hi def link nixNamespacedBuiltin      Special
+hi def link nixNull                   Constant
+hi def link nixOperator               Operator
+hi def link nixPath                   Include
+hi def link nixPathDelimiter          Delimiter
+hi def link nixRecKeyword             Keyword
+hi def link nixSearchPath             Include
+hi def link nixSimpleBuiltin          Keyword
+hi def link nixSimpleFunctionArgument Identifier
+hi def link nixSimpleString           String
+hi def link nixSimpleStringSpecial    SpecialChar
+hi def link nixString                 String
+hi def link nixStringDelimiter        Delimiter
+hi def link nixTodo                   Todo
+hi def link nixURI                    Include
+hi def link nixWithExprKeyword        Keyword
+
+" This could lead up to slow syntax highlighting for large files, but usually
+" large files such as all-packages.nix are one large attribute set, so if we'd
+" use sync patterns we'd have to go back to the start of the file anyway
+syn sync fromstart
+
+let b:current_syntax = "nix"
diff --git a/vim/.vim/bundle/filetype-nix/test/nix.vader b/vim/.vim/bundle/filetype-nix/test/nix.vader
new file mode 100644
index 0000000..6efb17b
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/test/nix.vader
@@ -0,0 +1,326 @@
+Given nix (attribute):
+  {
+    foo = pkgs.callPackage ./examples/foo {};
+  }
+
+Do (reindent):
+  vip=
+
+Expect (indentation):
+~~~~~~~
+  {
+    foo = pkgs.callPackage ./examples/foo {};
+  }
+~~~~~~~
+
+Execute (syntax):
+  AssertEqual SyntaxOf('foo'), 'nixAttribute'
+
+Given nix (attribute-assignment):
+  {
+    foo = rec { };
+  }
+
+Execute (syntax):
+  AssertEqual SyntaxOf('foo'), 'nixAttribute'
+  AssertEqual SyntaxOf('rec'), 'nixRecKeyword'
+
+Given nix (attribute-path):
+  {
+    foo.bar.baz = 2;
+  }
+
+Execute (syntax):
+  AssertNotEqual SyntaxOf('foo'), 'nixAttribute'
+  AssertNotEqual SyntaxOf('bar'), 'nixAttribute'
+  AssertEqual SyntaxOf('\.'), 'nixAttributeDot'
+  AssertEqual SyntaxOf('baz'), 'nixAttribute'
+  AssertEqual SyntaxOf('2'), 'nixInteger'
+
+Given nix (attribute-nested):
+  {
+    a = {
+      b = {
+        c = "2}";
+      };
+    };
+  }
+
+Execute (syntax):
+  AssertEqual SyntaxOf('a'), 'nixAttribute'
+  AssertEqual SyntaxOf('b'), 'nixAttribute'
+  AssertEqual SyntaxOf('c'), 'nixAttribute'
+  AssertEqual SyntaxOf('2}'), 'nixSimpleString'
+
+Given nix (attribute-inherit):
+  {
+    inherit (a.b.c) foo;
+    inherit bar baz;
+  }
+
+Execute (syntax):
+  AssertNotEqual SyntaxOf('c'), 'nixAttribute'
+  AssertEqual SyntaxOf('inherit'), 'nixInherit'
+  AssertEqual SyntaxOf('('), 'nixInheritAttributeScope'
+  AssertEqual SyntaxOf(')'), 'nixInheritAttributeScope'
+  AssertEqual SyntaxOf('\.'), 'nixAttributeDot'
+  AssertEqual SyntaxOf('foo'), 'nixAttribute'
+  AssertEqual SyntaxOf('bar'), 'nixAttribute'
+  AssertEqual SyntaxOf('baz'), 'nixAttribute'
+
+Given nix (list):
+  {
+    foo = [
+      a
+      b
+    ];
+  }
+
+Do (reindent):
+  vip=
+
+Expect (indentation):
+~~~~~~~
+  {
+    foo = [
+      a
+      b
+    ];
+  }
+~~~~~~~
+
+Execute (syntax):
+  AssertEqual SyntaxOf('foo'), 'nixAttribute'
+  AssertEqual SyntaxOf('a'), 'nixFunctionCall'
+  AssertEqual SyntaxOf('b'), 'nixFunctionCall'
+
+Given nix (string):
+  "https://github.com/${owner}/${repo}/archive/${rev}.tar.gz"
+
+Execute (syntax):
+  AssertEqual SyntaxOf('"'), 'nixStringDelimiter'
+  AssertEqual SyntaxOf('https'), 'nixSimpleString'
+  AssertEqual SyntaxOf('${'), 'nixInterpolationDelimiter'
+  AssertEqual SyntaxOf('}'), 'nixInterpolationDelimiter'
+  AssertEqual SyntaxOf('owner'), 'nixInterpolationParam'
+  AssertEqual SyntaxOf('repo'), 'nixInterpolationParam'
+  AssertEqual SyntaxOf('rev'), 'nixInterpolationParam'
+
+Given nix (multiline-string):
+  ''
+    line1 ${ref1}
+    ${ref2} line2
+    line3 ${ref3}
+  ''
+
+Execute (syntax):
+  AssertEqual SyntaxOf('line1'), 'nixString'
+  AssertEqual SyntaxOf('line2'), 'nixString'
+  AssertEqual SyntaxOf('line3'), 'nixString'
+  AssertEqual SyntaxOf('ref1'), 'nixInterpolationParam'
+  AssertEqual SyntaxOf('ref2'), 'nixInterpolationParam'
+  AssertEqual SyntaxOf('ref3'), 'nixInterpolationParam'
+
+Given nix (url):
+  https://github.com/LnL7/vim-nix
+
+Execute (syntax):
+  AssertEqual SyntaxOf('https'), 'nixURI'
+  AssertEqual SyntaxOf('github'), 'nixURI'
+  AssertEqual SyntaxOf('nix'), 'nixURI'
+
+Given nix (nix-search-path):
+  assert <foo-bar/blah/xxx.nix>;
+
+Execute (syntax):
+  AssertEqual SyntaxOf('<'), 'nixPathDelimiter'
+  AssertEqual SyntaxOf('foo'), 'nixSearchPath'
+  AssertEqual SyntaxOf('-'), 'nixSearchPath'
+  AssertEqual SyntaxOf('bar'), 'nixSearchPath'
+  AssertEqual SyntaxOf('/'), 'nixSearchPath'
+  AssertEqual SyntaxOf('\.'), 'nixSearchPath'
+  AssertEqual SyntaxOf('>'), 'nixPathDelimiter'
+
+Given nix (nix-paths):
+  [ ~/homefile ./. /etc/passwd ]
+
+Execute (syntax):
+  AssertEqual SyntaxOf('\~/homefile'), 'nixHomePath'
+  AssertEqual SyntaxOf('\./\.'), 'nixPath'
+  AssertEqual SyntaxOf('/etc/passwd'), 'nixPath'
+
+Given nix (let):
+  let
+    foo = true;
+    bar = false;
+  in {
+    result = foo && bar;
+  }
+
+Do (reindent):
+  vip=
+
+Expect (indentation):
+~~~~~~~
+  let
+    foo = true;
+    bar = false;
+  in {
+    result = foo && bar;
+  }
+~~~~~~~
+
+Execute (syntax):
+  AssertEqual SyntaxOf('let'), 'nixLetExprKeyword'
+  AssertEqual SyntaxOf('in'), 'nixLetExprKeyword'
+  AssertEqual SyntaxOf('foo'), 'nixAttribute'
+  AssertEqual SyntaxOf('bar'), 'nixAttribute'
+  AssertEqual SyntaxOf('result'), 'nixAttribute'
+  AssertEqual SyntaxOf('&&'), 'nixOperator'
+
+Given nix (builtins):
+  builtins.doesntexist (builtins.map id [
+    hashString (builtins.fetchurl (toString "abort"))
+  ])
+
+Execute (syntax):
+  AssertNotEqual SyntaxOf('doesntexist'), 'nixBuiltin'
+  AssertEqual SyntaxOf('map'), 'nixNamespacedBuiltin'
+  AssertNotEqual SyntaxOf('hashString'), 'nixBuiltin'
+  AssertNotEqual SyntaxOf('hashString'), 'nixNamespacedBuiltin'
+  AssertEqual SyntaxOf('builtins'), 'nixBuiltin'
+  AssertEqual SyntaxOf('\.'), 'nixBuiltin'
+  AssertEqual SyntaxOf('fetchurl'), 'nixNamespacedBuiltin'
+  AssertEqual SyntaxOf('toString'), 'nixSimpleBuiltin'
+  AssertEqual SyntaxOf('abort'), 'nixSimpleString'
+
+Given nix (simple-string-escape):
+  "foo\nbar\"end\${xxx}"
+
+Execute (syntax):
+  AssertEqual SyntaxAt(1, 1), 'nixStringDelimiter'
+  AssertEqual SyntaxOf('foo'), 'nixSimpleString'
+  AssertEqual SyntaxOf('\\n'), 'nixSimpleStringSpecial'
+  AssertEqual SyntaxOf('bar'), 'nixSimpleString'
+  AssertEqual SyntaxOf('\\"'), 'nixSimpleStringSpecial'
+  AssertEqual SyntaxOf('end'), 'nixSimpleString'
+  AssertEqual SyntaxOf('\$'), 'nixSimpleStringSpecial'
+  AssertEqual SyntaxOf('{'), 'nixSimpleString'
+  AssertEqual SyntaxOf('xxx'), 'nixSimpleString'
+  AssertEqual SyntaxOf('}'), 'nixSimpleString'
+  AssertEqual SyntaxAt(1, 22), 'nixStringDelimiter'
+
+Given nix (multiline-string-escape):
+  ''
+    foo'''bar
+    ''${xxx}
+  ''
+
+Execute (syntax):
+  AssertEqual SyntaxOf('foo'), 'nixString'
+  AssertEqual SyntaxOf("'''"), 'nixInterpolationSpecial'
+  AssertEqual SyntaxOf('bar'), 'nixString'
+  AssertEqual SyntaxOf("''\\$"), 'nixInterpolationSpecial'
+  AssertEqual SyntaxOf('{'), 'nixString'
+  AssertEqual SyntaxOf('xxx'), 'nixString'
+  AssertEqual SyntaxOf('}'), 'nixString'
+
+Given nix (lambda-attrs):
+  { # very descriptive comment
+    foo
+    /**/
+    ? # another comment
+    /* yet another comment */
+    # default value here:
+    1
+  , bar ? "xxx"
+  , yyy
+  # last comment
+  , ...
+  }: {
+    result = null;
+  }
+
+Execute (syntax):
+  AssertEqual SyntaxOf('very descriptive comment'), 'nixComment'
+  AssertEqual SyntaxOf('foo'), 'nixArgumentDefinition'
+  AssertEqual SyntaxOf('?'), 'nixOperator'
+  AssertEqual SyntaxOf('/\*\*/'), 'nixComment'
+  AssertEqual SyntaxOf('another comment'), 'nixComment'
+  AssertEqual SyntaxOf('yet another comment'), 'nixComment'
+  AssertEqual SyntaxOf('default value here:'), 'nixComment'
+  AssertEqual SyntaxOf('1'), 'nixInteger'
+  AssertEqual SyntaxOf('bar'), 'nixArgumentDefinition'
+  AssertEqual SyntaxOf('xxx'), 'nixSimpleString'
+  AssertEqual SyntaxOf('yyy'), 'nixArgumentDefinition'
+  AssertEqual SyntaxOf('last comment'), 'nixComment'
+  AssertEqual SyntaxOf('\.\.\.'), 'nixArgumentEllipsis'
+  AssertEqual SyntaxOf('result'), 'nixAttribute'
+  AssertEqual SyntaxOf('null'), 'nixNull'
+
+Given nix (ifexpr):
+  if true then 111 else { a = 222; }
+
+Execute (syntax):
+  AssertEqual SyntaxOf('if'), 'nixIfExprKeyword'
+  AssertEqual SyntaxOf('true'), 'nixBoolean'
+  AssertEqual SyntaxOf('then'), 'nixIfExprKeyword'
+  AssertEqual SyntaxOf('111'), 'nixInteger'
+  AssertEqual SyntaxOf('else'), 'nixIfExprKeyword'
+  AssertEqual SyntaxOf('a'), 'nixAttribute'
+  AssertEqual SyntaxOf('222'), 'nixInteger'
+
+Given nix (with-expr):
+  with foo; withfoo
+
+Execute (syntax):
+  AssertEqual SyntaxOf('with'), 'nixWithExprKeyword'
+  AssertEqual SyntaxOf('foo'), 'nixFunctionCall'
+  AssertEqual SyntaxOf('withfoo'), 'nixFunctionCall'
+
+Given nix (assert-expr):
+  assert true -> false; null
+
+Execute (syntax):
+  AssertEqual SyntaxOf('assert'), 'nixAssertKeyword'
+  AssertEqual SyntaxOf('true'), 'nixBoolean'
+  AssertEqual SyntaxOf('->'), 'nixOperator'
+  AssertEqual SyntaxOf('false'), 'nixBoolean'
+  AssertEqual SyntaxOf('null'), 'nixNull'
+
+Given nix (funarg-let-attrset):
+  { xxx ? null }@yyy:
+
+  bbb@{ ccc, ... }:
+
+  let foo = 11; in let xxx = 22; in {
+    bar = foo + zzz;
+  }
+
+Execute (syntax):
+  AssertEqual SyntaxOf('xxx'), 'nixArgumentDefinition'
+  AssertEqual SyntaxOf('?'), 'nixOperator'
+  AssertEqual SyntaxOf('null'), 'nixNull'
+  AssertEqual SyntaxOf('@'), 'nixArgOperator'
+  AssertEqual SyntaxOf('yyy'), 'nixAttribute'
+  AssertEqual SyntaxOf('bbb'), 'nixAttribute'
+  AssertEqual SyntaxOf('ccc'), 'nixArgumentDefinition'
+  AssertEqual SyntaxOf('let'), 'nixLetExprKeyword'
+  AssertEqual SyntaxOf('bar'), 'nixAttribute'
+
+Given nix (searchpath-versus-lt):
+  {
+    alwaysTrue = 4 < 5;
+    alwaysFalse = 4 > 5;
+    somePath = <foo/bar>;
+    tailTrue = 4 <= 5;
+    tailFalse = 4 >= 5;
+  }
+
+Execute (syntax):
+  AssertEqual SyntaxOf('alwaysTrue.*\zs<'), 'nixOperator'
+  AssertEqual SyntaxOf('alwaysFalse.*\zs>'), 'nixOperator'
+  AssertEqual SyntaxOf('somePath.*\zs<'), 'nixPathDelimiter'
+  AssertEqual SyntaxOf('somePath.*\zs>'), 'nixPathDelimiter'
+  AssertEqual SyntaxOf('tailTrue.*\zs<'), 'nixOperator'
+  AssertEqual SyntaxOf('tailFalse.*\zs>'), 'nixOperator'
diff --git a/vim/.vim/bundle/filetype-nix/test/run-tests.sh b/vim/.vim/bundle/filetype-nix/test/run-tests.sh
new file mode 100755
index 0000000..c68c905
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/test/run-tests.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+cd "$( dirname "${BASH_SOURCE[0]}" )" && vim -Nu vimrc -c 'Vader! *'
diff --git a/vim/.vim/bundle/filetype-nix/test/vimrc b/vim/.vim/bundle/filetype-nix/test/vimrc
new file mode 100644
index 0000000..3fdd6ea
--- /dev/null
+++ b/vim/.vim/bundle/filetype-nix/test/vimrc
@@ -0,0 +1,5 @@
+filetype off
+set rtp+=../vader.vim
+set rtp+=../
+filetype plugin indent on
+syntax enable
diff --git a/vim/.vim/bundle/fugitive/CONTRIBUTING.markdown b/vim/.vim/bundle/fugitive/CONTRIBUTING.markdown
new file mode 100644
index 0000000..e651dca
--- /dev/null
+++ b/vim/.vim/bundle/fugitive/CONTRIBUTING.markdown
@@ -0,0 +1,18 @@
+Before reporting a bug, you should try stripping down your Vim configuration
+and removing other plugins.  The sad truth about VimScript is that it is
+fraught with incompatibilities waiting to happen.  I'm happy to work around
+them where I can, but it's up to you to isolate the conflict.
+
+Fugitive is particularly prone to regressions due to Git version issues,
+platform issues, and interactions with other plugins.  I end up bisecting a
+lot more than other projects, and thus I'm especially meticulous here about
+maintaining a clean, readable, history.  Squash and force push any requested
+changes to a pull request.  And if your [commit message
+sucks](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html),
+I'm not going to accept it.  Period.
+
+Beyond that, don't be shy about asking before patching.  What takes you hours
+might take me minutes simply because I have both domain knowledge and a
+perverse knowledge of VimScript so vast that many would consider it a symptom
+of mental illness.  On the flip side, some ideas I'll reject no matter how
+good the implementation is.  "Send a patch" is an edge case answer in my book.
diff --git a/vim/.vim/bundle/fugitive/README.markdown b/vim/.vim/bundle/fugitive/README.markdown
new file mode 100644
index 0000000..71b8bc4
--- /dev/null
+++ b/vim/.vim/bundle/fugitive/README.markdown
@@ -0,0 +1,118 @@
+# fugitive.vim
+
+I'm not going to lie to you; fugitive.vim may very well be the best
+Git wrapper of all time.  Check out these features:
+
+View any blob, tree, commit, or tag in the repository with `:Gedit` (and
+`:Gsplit`, `:Gvsplit`, `:Gtabedit`, ...).  Edit a file in the index and
+write to it to stage the changes.  Use `:Gdiff` to bring up the staged
+version of the file side by side with the working tree version and use
+Vim's diff handling capabilities to stage a subset of the file's
+changes.
+
+Bring up the output of `git status` with `:Gstatus`.  Press `-` to
+`add`/`reset` a file's changes, or `p` to `add`/`reset` `--patch`.  And guess
+what `:Gcommit` does!
+
+`:Gblame` brings up an interactive vertical split with `git blame`
+output.  Press enter on a line to edit the commit where the line
+changed, or `o` to open it in a split.  When you're done, use `:Gedit`
+in the historic buffer to go back to the work tree version.
+
+`:Gmove` does a `git mv` on a file and simultaneously renames the
+buffer.  `:Gremove` does a `git rm` on a file and simultaneously deletes
+the buffer.
+
+Use `:Ggrep` to search the work tree (or any arbitrary commit) with
+`git grep`, skipping over that which is not tracked in the repository.
+`:Glog` loads all previous revisions of a file into the quickfix list so
+you can iterate over them and watch the file evolve!
+
+`:Gread` is a variant of `git checkout -- filename` that operates on the
+buffer rather than the filename.  This means you can use `u` to undo it
+and you never get any warnings about the file changing outside Vim.
+`:Gwrite` writes to both the work tree and index versions of a file,
+making it like `git add` when called from a work tree file and like
+`git checkout` when called from the index or a blob in history.
+
+Use `:Gbrowse` to open the current file on GitHub, with optional line
+range (try it in visual mode!).  If your current repository isn't on
+GitHub, `git instaweb` will be spun up instead.
+
+Add `%{fugitive#statusline()}` to `'statusline'` to get an indicator
+with the current branch in (surprise!) your statusline.
+
+Last but not least, there's `:Git` for running any arbitrary command,
+and `Git!` to open the output of a command in a temp file.
+
+## Screencasts
+
+* [A complement to command line git](http://vimcasts.org/e/31)
+* [Working with the git index](http://vimcasts.org/e/32)
+* [Resolving merge conflicts with vimdiff](http://vimcasts.org/e/33)
+* [Browsing the git object database](http://vimcasts.org/e/34)
+* [Exploring the history of a git repository](http://vimcasts.org/e/35)
+
+## Installation
+
+If you don't have a preferred installation method, one option is to install
+[pathogen.vim](https://github.com/tpope/vim-pathogen), and then copy
+and paste:
+
+    cd ~/.vim/bundle
+    git clone git://github.com/tpope/vim-fugitive.git
+    vim -u NONE -c "helptags vim-fugitive/doc" -c q
+
+If your Vim version is below 7.2, I recommend also installing
+[vim-git](https://github.com/tpope/vim-git) for syntax highlighting and
+other Git niceties.
+
+## FAQ
+
+> I installed the plugin and started Vim.  Why don't any of the commands
+> exist?
+
+Fugitive cares about the current file, not the current working
+directory.  Edit a file from the repository.
+
+> I opened a new tab.  Why don't any of the commands exist?
+
+Fugitive cares about the current file, not the current working
+directory.  Edit a file from the repository.
+
+> Why is `:Gbrowse` not using the right browser?
+
+`:Gbrowse` delegates to `git web--browse`, which is less than perfect
+when it comes to finding the right browser.  You can tell it the correct
+browser to use with `git config --global web.browser ...`.  On OS X, for
+example, you might want to set this to `open`.  See `git web--browse --help`
+for details.
+
+> Here's a patch that automatically opens the quickfix window after
+> `:Ggrep`.
+
+This is a great example of why I recommend asking before patching.
+There are valid arguments to be made both for and against automatically
+opening the quickfix window.  Whenever I have to make an arbitrary
+decision like this, I ask what Vim would do.  And Vim does not open a
+quickfix window after `:grep`.
+
+Luckily, it's easy to implement the desired behavior without changing
+fugitive.vim.  The following autocommand will cause the quickfix window
+to open after any grep invocation:
+
+    autocmd QuickFixCmdPost *grep* cwindow
+
+## Self-Promotion
+
+Like fugitive.vim? Follow the repository on
+[GitHub](https://github.com/tpope/vim-fugitive) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=2975).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/fugitive/doc/fugitive.txt b/vim/.vim/bundle/fugitive/doc/fugitive.txt
new file mode 100644
index 0000000..51fc591
--- /dev/null
+++ b/vim/.vim/bundle/fugitive/doc/fugitive.txt
@@ -0,0 +1,357 @@
+*fugitive.txt*  A Git wrapper so awesome, it should be illegal
+
+Author:  Tim Pope <http://tpo.pe/>
+License: Same terms as Vim itself (see |license|)
+
+This plugin is only available if 'compatible' is not set.
+
+INTRODUCTION                                    *fugitive*
+
+Whenever you edit a file from a Git repository, a set of commands is defined
+that serve as a gateway to Git.
+
+COMMANDS                                        *fugitive-commands*
+
+These commands are local to the buffers in which they work (generally, buffers
+that are part of Git repositories).
+
+                                                *fugitive-:Git*
+:Git [args]             Run an arbitrary git command. Similar to :!git [args]
+                        but chdir to the repository tree first.
+
+                                                *fugitive-:Git!*
+:Git! [args]            Like |:Git|, but capture the output into a temp file,
+                        and edit that temp file.
+
+                                                *fugitive-:Gcd*
+:Gcd [directory]        |:cd| relative to the repository.
+
+                                                *fugitive-:Glcd*
+:Glcd [directory]       |:lcd| relative to the repository.
+
+                                                *fugitive-:Gstatus*
+:Gstatus                Bring up the output of git-status in the preview
+                        window.  The following maps, which work on the cursor
+                        line file where sensible, are provided:
+
+                        g?    show this help
+                        <C-N> next file
+                        <C-P> previous file
+                        <CR>  |:Gedit|
+                        -     |:Git| add
+                        -     |:Git| reset (staged files)
+                        cA    |:Gcommit| --amend --reuse-message=HEAD
+                        ca    |:Gcommit| --amend
+                        cc    |:Gcommit|
+                        cva   |:Gcommit| --amend --verbose
+                        cvc   |:Gcommit| --verbose
+                        D     |:Gdiff|
+                        ds    |:Gsdiff|
+                        dp    |:Git!| diff (p for patch; use :Gw to apply)
+                        dp    |:Git| add --intent-to-add (untracked files)
+                        dv    |:Gvdiff|
+                        O     |:Gtabedit|
+                        o     |:Gsplit|
+                        p     |:Git| add --patch
+                        p     |:Git| reset --patch (staged files)
+                        q     close status
+                        r     reload status
+                        S     |:Gvsplit|
+                        U     |:Git| checkout
+                        U     |:Git| checkout HEAD (staged files)
+                        U     |:Git| clean (untracked files)
+                        U     |:Git| rm (unmerged files)
+
+                                                *fugitive-:Gcommit*
+:Gcommit [args]         A wrapper around git-commit.  If there is nothing
+                        to commit, |:Gstatus| is called instead.  Unless the
+                        arguments given would skip the invocation of an editor
+                        (e.g., -m), a split window will be used to obtain a
+                        commit message, or a new tab if -v is given.  Write
+                        and close that window (:wq or |:Gwrite|) to finish the
+                        commit.  Unlike when running the actual git-commit
+                        command, it is possible (but unadvisable) to alter the
+                        index with commands like git-add and git-reset while a
+                        commit message is pending.
+
+                                                *fugitive-:Gmerge*
+:Gmerge [args]          Calls git-merge and loads errors and conflicted files
+                        into the quickfix list.  Opens a |:Gcommit| style
+                        split window for the commit message if the merge
+                        succeeds.  If called during a merge conflict, the
+                        conflicted files from the current index are loaded
+                        into the quickfix list.
+
+                                                *fugitive-:Gpull*
+:Gpull [args]           Like |:Gmerge|, but for git-pull.
+
+                                                *fugitive-:Gpush*
+:Gpush [args]           Invoke git-push, load the results into the quickfix
+                        list, and invoke |:cwindow| to reveal any errors.
+                        |:Dispatch| is used if available for asynchronous
+                        invocation.
+
+                                                *fugitive-:Gfetch*
+:Gfetch [args]          Like |:Gpush|, but for git-fetch.
+
+                                                *fugitive-:Ggrep*
+:Ggrep[!] [args]        |:grep|[!] with git-grep as 'grepprg'.
+
+                                                *fugitive-:Glgrep*
+:Glgrep[!] [args]       |:lgrep|[!] with git-grep as 'grepprg'.
+
+                                                *fugitive-:Glog*
+:Glog [args]            Load all previous revisions of the current file into
+                        the quickfix list.  Additional git-log arguments can
+                        be given (for example, --reverse).  If "--" appears as
+                        an argument, no file specific filtering is done, and
+                        previous commits rather than previous file revisions
+                        are loaded.
+
+:{range}Glog [args]     Use git-log -L to load previous revisions of the given
+                        range of the current file into the quickfix list.  The
+                        cursor is positioned on the first line of the first
+                        diff hunk for each commit.
+
+                                                *fugitive-:Gllog*
+:Gllog [args]           Like |:Glog|, but use the location list instead of the
+                        quickfix list.
+
+                                        *fugitive-:Gedit* *fugitive-:Ge*
+:Gedit [revision]       |:edit| a |fugitive-revision|.
+
+                                                *fugitive-:Gsplit*
+:Gsplit [revision]      |:split| a |fugitive-revision|.
+
+                                                *fugitive-:Gvsplit*
+:Gvsplit [revision]     |:vsplit| a |fugitive-revision|.
+
+                                                *fugitive-:Gtabedit*
+:Gtabedit [revision]    |:tabedit| a |fugitive-revision|.
+
+                                                *fugitive-:Gpedit*
+:Gpedit [revision]      |:pedit| a |fugitive-revision|.
+
+:Gsplit! [args]                 *fugitive-:Gsplit!* *fugitive-:Gvsplit!*
+:Gvsplit! [args]                *fugitive-:Gtabedit!* *fugitive-:Gpedit!*
+:Gtabedit! [args]       Like |:Git!|, but open the resulting temp file in a
+:Gpedit! [args]         split, tab, or preview window.
+
+                                                *fugitive-:Gread*
+:Gread [revision]       Empty the buffer and |:read| a |fugitive-revision|.
+                        When the argument is omitted, this is similar to
+                        git-checkout on a work tree file or git-add on a stage
+                        file, but without writing anything to disk.
+
+:{range}Gread [revision]
+                        |:read| in a |fugitive-revision| after {range}.
+
+                                                *fugitive-:Gread!*
+:Gread! [args]          Empty the buffer and |:read| the output of a Git
+                        command.  For example, :Gread! show HEAD:%.
+
+:{range}Gread! [args]  |:read| the output of a Git command after {range}.
+
+                                        *fugitive-:Gw* *fugitive-:Gwrite*
+:Gwrite                 Write to the current file's path and stage the results.
+                        When run in a work tree file, it is effectively git
+                        add.  Elsewhere, it is effectively git-checkout.  A
+                        great deal of effort is expended to behave sensibly
+                        when the work tree or index version of the file is
+                        open in another buffer.
+
+:Gwrite {path}          You can give |:Gwrite| an explicit path of where in
+                        the work tree to write.  You can also give a path like
+                        :0:foo.txt or even :0 to write to just that stage in
+                        the index.
+
+                                                *fugitive-:Gwq*
+:Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
+                        succeeded.
+
+:Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
+                        succeeded.
+
+                                                *fugitive-:Gdiff*
+:Gdiff [revision]       Perform a |vimdiff| against the current file in the
+                        given revision.  With no argument, the version in the
+                        index is used (which means a three-way diff during a
+                        merge conflict, making it a git-mergetool
+                        alternative).  The newer of the two files is placed
+                        to the right or bottom, depending on 'diffopt' and
+                        the width of the window relative to 'textwidth'.  Use
+                        |do| and |dp| and write to the index file to simulate
+                        "git add --patch".
+
+                                                *fugitive-:Gsdiff*
+:Gsdiff [revision]      Like |:Gdiff|, but always split horizontally.
+
+                                                *fugitive-:Gvdiff*
+:Gvdiff [revision]      Like |:Gdiff|, but always split vertically.
+
+                                                *fugitive-:Gmove*
+:Gmove {destination}    Wrapper around git-mv that renames the buffer
+                        afterward.  The destination is relative to the current
+                        directory except when started with a /, in which case
+                        it is relative to the work tree.  Add a ! to pass -f.
+
+                                                *fugitive-:Gremove*
+:Gremove                Wrapper around git-rm that deletes the buffer
+                        afterward.  When invoked in an index file, --cached is
+                        passed.  Add a ! to pass -f and forcefully discard the
+                        buffer.
+
+                                                *fugitive-:Gblame*
+:Gblame [flags]         Run git-blame on the file and open the results in a
+                        scroll bound vertical split.  You can give any of
+                        ltfnsewMC as flags and they will be passed along to
+                        git-blame.  The following maps, which work on the
+                        cursor line commit where sensible, are provided:
+
+                        g?    show this help
+                        A     resize to end of author column
+                        C     resize to end of commit column
+                        D     resize to end of date/time column
+                        q     close blame and return to blamed window
+                        gq    q, then |:Gedit| to return to work tree version
+                        <CR>  q, then open commit
+                        o     open commit in horizontal split
+                        O     open commit in new tab
+                        -     reblame at commit
+                        ~     reblame at [count]th first grandparent
+                        P     reblame at [count]th parent (like HEAD^[count])
+
+:[range]Gblame [flags]  Run git-blame on the given range.
+
+                                                *fugitive-:Gbrowse*
+:Gbrowse                Open the current file, blob, tree, commit, or tag
+                        in your browser at the upstream hosting provider.
+                        If a range is given, it is appropriately appended to
+                        the URL as an anchor.
+
+                        Upstream providers can be added by installing an
+                        appropriate Vim plugin.  For example, GitHub can be
+                        supported by installing rhubarb.vim, available at
+                        <https://github.com/tpope/vim-rhubarb>.  (Native
+                        support for GitHub is currently included, but that is
+                        slated to be removed.)
+
+                        The hosting provider is determined by looking at the
+                        remote for the current or specified branch and falls
+                        back to "origin".  In the special case of a "."
+                        remote, a local instance of git-instaweb will be
+                        started and used.
+
+:Gbrowse {revision}     Like :Gbrowse, but for a given |fugitive-revision|.  A
+                        useful value here is -, which ties the URL to the
+                        latest commit rather than a volatile branch.
+
+:Gbrowse [...]@{remote} Force using the given remote rather than the remote
+                        for the current branch.  The remote is used to
+                        determine which GitHub repository to link to.
+
+:{range}Gbrowse [args]  Appends an anchor to the URL that emphasizes the
+                        selected lines.  You almost certainly want to give a
+                        "-" argument in this case to force the URL to include
+                        an exact revision.
+
+:[range]Gbrowse! [args] Like :Gbrowse, but put the URL on the clipboard rather
+                        than opening it.
+
+MAPPINGS                                        *fugitive-mappings*
+
+These maps are available everywhere.
+
+                                                *fugitive-c_CTRL-R_CTRL-G*
+<C-R><C-G>              On the command line, recall the path to the current
+                        object (that is, a representation of the object
+                        recognized by |:Gedit|).
+
+                                                *fugitive-y_CTRL-G*
+["x]y<C-G>              Yank the commit SHA and path to the current object.
+
+These maps are available in Git objects.
+
+                                                *fugitive-<CR>*
+<CR>                    Jump to the revision under the cursor.
+
+                                                *fugitive-o*
+o                       Jump to the revision under the cursor in a new split.
+
+                                                *fugitive-S*
+S                       Jump to the revision under the cursor in a new
+                        vertical split.
+
+                                                *fugitive-O*
+O                       Jump to the revision under the cursor in a new tab.
+
+                                                *fugitive--*
+-                       Go to the tree containing the current tree or blob.
+
+                                                *fugitive-~*
+~                       Go to the current file in the [count]th first
+                        ancestor.
+
+                                                *fugitive-P*
+P                       Go to the current file in the [count]th parent.
+
+                                                *fugitive-C*
+C                       Go to the commit containing the current file.
+
+                                                *fugitive-.*
+.                       Start a |:| command line with the current revision
+                        prepopulated at the end of the line.
+
+                                                *fugitive-a*
+a                       Show the current tag, commit, or tree in an alternate
+                        format.
+
+SPECIFYING REVISIONS                            *fugitive-revision*
+
+Fugitive revisions are similar to Git revisions as defined in the "SPECIFYING
+REVISIONS" section in the git-rev-parse man page.  For commands that accept an
+optional revision, the default is the file in the index for work tree files
+and the work tree file for everything else.  Example revisions follow.
+
+Revision        Meaning ~
+HEAD            .git/HEAD
+master          .git/refs/heads/master
+HEAD^{}         The commit referenced by HEAD
+HEAD^           The parent of the commit referenced by HEAD
+HEAD:           The tree referenced by HEAD
+/HEAD           The file named HEAD in the work tree
+Makefile        The file named Makefile in the work tree
+HEAD^:Makefile  The file named Makefile in the parent of HEAD
+:Makefile       The file named Makefile in the index (writable)
+-               The current file in HEAD
+^               The current file in the previous commit
+~3              The current file 3 commits ago
+:               .git/index (Same as |:Gstatus|)
+:0              The current file in the index
+:1              The current file's common ancestor during a conflict
+:2              The current file in the target branch during a conflict
+:3              The current file in the merged branch during a conflict
+:/foo           The most recent commit with "foo" in the message
+
+STATUSLINE                                      *fugitive-statusline*
+
+                                                *fugitive#statusline()*
+Add %{fugitive#statusline()} to your statusline to get an indicator including
+the current branch and the currently edited file's commit.  If you don't have
+a statusline, this one matches the default when 'ruler' is set:
+>
+    set statusline=%<%f\ %h%m%r%{fugitive#statusline()}%=%-14.(%l,%c%V%)\ %P
+<
+                                                *fugitive#head(...)*
+Use fugitive#head() to return the name of the current branch. If the current
+HEAD is detached, fugitive#head() will return the empty string, unless the
+optional argument is given, in which case the hash of the current commit will
+be truncated to the given number of characters.
+
+ABOUT                                           *fugitive-about*
+
+Grab the latest version or report a bug on GitHub:
+
+http://github.com/tpope/vim-fugitive
+
+ vim:tw=78:et:ft=help:norl:
diff --git a/vim/.vim/bundle/fugitive/plugin/fugitive.vim b/vim/.vim/bundle/fugitive/plugin/fugitive.vim
new file mode 100644
index 0000000..345ea34
--- /dev/null
+++ b/vim/.vim/bundle/fugitive/plugin/fugitive.vim
@@ -0,0 +1,3096 @@
+" fugitive.vim - A Git wrapper so awesome, it should be illegal
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      2.2
+" GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim
+
+if exists('g:loaded_fugitive') || &cp
+  finish
+endif
+let g:loaded_fugitive = 1
+
+if !exists('g:fugitive_git_executable')
+  let g:fugitive_git_executable = 'git'
+endif
+
+" Section: Utility
+
+function! s:function(name) abort
+  return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),''))
+endfunction
+
+function! s:sub(str,pat,rep) abort
+  return substitute(a:str,'\v\C'.a:pat,a:rep,'')
+endfunction
+
+function! s:gsub(str,pat,rep) abort
+  return substitute(a:str,'\v\C'.a:pat,a:rep,'g')
+endfunction
+
+function! s:winshell() abort
+  return &shell =~? 'cmd' || exists('+shellslash') && !&shellslash
+endfunction
+
+function! s:shellesc(arg) abort
+  if a:arg =~ '^[A-Za-z0-9_/.-]\+$'
+    return a:arg
+  elseif s:winshell()
+    return '"'.s:gsub(s:gsub(a:arg, '"', '""'), '\%', '"%"').'"'
+  else
+    return shellescape(a:arg)
+  endif
+endfunction
+
+function! s:fnameescape(file) abort
+  if exists('*fnameescape')
+    return fnameescape(a:file)
+  else
+    return escape(a:file," \t\n*?[{`$\\%#'\"|!<")
+  endif
+endfunction
+
+function! s:throw(string) abort
+  let v:errmsg = 'fugitive: '.a:string
+  throw v:errmsg
+endfunction
+
+function! s:warn(str) abort
+  echohl WarningMsg
+  echomsg a:str
+  echohl None
+  let v:warningmsg = a:str
+endfunction
+
+function! s:shellslash(path) abort
+  if s:winshell()
+    return s:gsub(a:path,'\\','/')
+  else
+    return a:path
+  endif
+endfunction
+
+let s:git_versions = {}
+
+function! fugitive#git_version(...) abort
+  if !has_key(s:git_versions, g:fugitive_git_executable)
+    let s:git_versions[g:fugitive_git_executable] = matchstr(system(g:fugitive_git_executable.' --version'), "\\S\\+\n")
+  endif
+  return s:git_versions[g:fugitive_git_executable]
+endfunction
+
+function! s:recall() abort
+  let rev = s:sub(s:buffer().rev(), '^/', '')
+  if rev ==# ':'
+    return matchstr(getline('.'),'^#\t\%([[:alpha:] ]\+: *\)\=\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$\|^\d\{6} \x\{40\} \d\t\zs.*')
+  elseif s:buffer().type('tree')
+    let file = matchstr(getline('.'), '\t\zs.*')
+    if empty(file) && line('.') > 2
+      let file = s:sub(getline('.'), '/$', '')
+    endif
+    if !empty(file) && rev !~# ':$'
+      return rev . '/' . file
+    else
+      return rev . file
+    endif
+  endif
+  return rev
+endfunction
+
+function! s:add_methods(namespace, method_names) abort
+  for name in a:method_names
+    let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name)
+  endfor
+endfunction
+
+let s:commands = []
+function! s:command(definition) abort
+  let s:commands += [a:definition]
+endfunction
+
+function! s:define_commands() abort
+  for command in s:commands
+    exe 'command! -buffer '.command
+  endfor
+endfunction
+
+let s:abstract_prototype = {}
+
+" Section: Initialization
+
+function! fugitive#is_git_dir(path) abort
+  let path = s:sub(a:path, '[\/]$', '') . '/'
+  return getfsize(path.'HEAD') > 10 && (
+        \ isdirectory(path.'objects') && isdirectory(path.'refs') ||
+        \ getftype(path.'commondir') ==# 'file')
+endfunction
+
+function! fugitive#extract_git_dir(path) abort
+  if s:shellslash(a:path) =~# '^fugitive://.*//'
+    return matchstr(s:shellslash(a:path), '\C^fugitive://\zs.\{-\}\ze//')
+  endif
+  let root = s:shellslash(simplify(fnamemodify(a:path, ':p:s?[\/]$??')))
+  let previous = ""
+  while root !=# previous
+    if root =~# '\v^//%([^/]+/?)?$'
+      " This is for accessing network shares from Cygwin Vim. There won't be
+      " any git directory called //.git or //serverName/.git so let's avoid
+      " checking for them since such checks are extremely slow.
+      break
+    endif
+    if index(split($GIT_CEILING_DIRECTORIES, ':'), root) >= 0
+      break
+    endif
+    if root ==# $GIT_WORK_TREE && fugitive#is_git_dir($GIT_DIR)
+      return simplify(fnamemodify(expand($GIT_DIR), ':p:s?[\/]$??'))
+    endif
+    if fugitive#is_git_dir($GIT_DIR)
+      " Ensure that we've cached the worktree
+      call s:configured_tree(simplify(fnamemodify(expand($GIT_DIR), ':p:s?[\/]$??')))
+      if has_key(s:dir_for_worktree, root)
+        return s:dir_for_worktree[root]
+      endif
+    endif
+    let dir = s:sub(root, '[\/]$', '') . '/.git'
+    let type = getftype(dir)
+    if type ==# 'dir' && fugitive#is_git_dir(dir)
+      return dir
+    elseif type ==# 'link' && fugitive#is_git_dir(dir)
+      return resolve(dir)
+    elseif type !=# '' && filereadable(dir)
+      let line = get(readfile(dir, '', 1), 0, '')
+      if line =~# '^gitdir: \.' && fugitive#is_git_dir(root.'/'.line[8:-1])
+        return simplify(root.'/'.line[8:-1])
+      elseif line =~# '^gitdir: ' && fugitive#is_git_dir(line[8:-1])
+        return line[8:-1]
+      endif
+    elseif fugitive#is_git_dir(root)
+      return root
+    endif
+    let previous = root
+    let root = fnamemodify(root, ':h')
+  endwhile
+  return ''
+endfunction
+
+function! fugitive#detect(path) abort
+  if exists('b:git_dir') && (b:git_dir ==# '' || b:git_dir =~# '/$')
+    unlet b:git_dir
+  endif
+  if !exists('b:git_dir')
+    let dir = fugitive#extract_git_dir(a:path)
+    if dir !=# ''
+      let b:git_dir = dir
+    endif
+  endif
+  if exists('b:git_dir')
+    if exists('#User#FugitiveBoot')
+      try
+        let [save_mls, &modelines] = [&mls, 0]
+        doautocmd User FugitiveBoot
+      finally
+        let &mls = save_mls
+      endtry
+    endif
+    if !exists('g:fugitive_no_maps')
+      cnoremap <buffer> <expr> <C-R><C-G> fnameescape(<SID>recall())
+      nnoremap <buffer> <silent> y<C-G> :call setreg(v:register, <SID>recall())<CR>
+    endif
+    let buffer = fugitive#buffer()
+    if expand('%:p') =~# '//'
+      call buffer.setvar('&path', s:sub(buffer.getvar('&path'), '^\.%(,|$)', ''))
+    endif
+    if stridx(buffer.getvar('&tags'), escape(b:git_dir, ', ')) == -1
+      if filereadable(b:git_dir.'/tags')
+        call buffer.setvar('&tags', escape(b:git_dir.'/tags', ', ').','.buffer.getvar('&tags'))
+      endif
+      if &filetype !=# '' && filereadable(b:git_dir.'/'.&filetype.'.tags')
+        call buffer.setvar('&tags', escape(b:git_dir.'/'.&filetype.'.tags', ', ').','.buffer.getvar('&tags'))
+      endif
+    endif
+    try
+      let [save_mls, &modelines] = [&mls, 0]
+      call s:define_commands()
+      doautocmd User Fugitive
+    finally
+      let &mls = save_mls
+    endtry
+  endif
+endfunction
+
+augroup fugitive
+  autocmd!
+  autocmd BufNewFile,BufReadPost * call fugitive#detect(expand('%:p'))
+  autocmd FileType           netrw call fugitive#detect(expand('%:p'))
+  autocmd User NERDTreeInit,NERDTreeNewRoot call fugitive#detect(b:NERDTreeRoot.path.str())
+  autocmd VimEnter * if expand('<amatch>')==''|call fugitive#detect(getcwd())|endif
+  autocmd CmdWinEnter * call fugitive#detect(expand('#:p'))
+  autocmd BufWinLeave * execute getwinvar(+bufwinnr(+expand('<abuf>')), 'fugitive_leave')
+augroup END
+
+" Section: Repository
+
+let s:repo_prototype = {}
+let s:repos = {}
+let s:worktree_for_dir = {}
+let s:dir_for_worktree = {}
+
+function! s:repo(...) abort
+  let dir = a:0 ? a:1 : (exists('b:git_dir') && b:git_dir !=# '' ? b:git_dir : fugitive#extract_git_dir(expand('%:p')))
+  if dir !=# ''
+    if has_key(s:repos, dir)
+      let repo = get(s:repos, dir)
+    else
+      let repo = {'git_dir': dir}
+      let s:repos[dir] = repo
+    endif
+    return extend(extend(repo, s:repo_prototype, 'keep'), s:abstract_prototype, 'keep')
+  endif
+  call s:throw('not a git repository: '.expand('%:p'))
+endfunction
+
+function! fugitive#repo(...) abort
+  return call('s:repo', a:000)
+endfunction
+
+function! s:repo_dir(...) dict abort
+  return join([self.git_dir]+a:000,'/')
+endfunction
+
+function! s:configured_tree(git_dir) abort
+  if !has_key(s:worktree_for_dir, a:git_dir)
+    let s:worktree_for_dir[a:git_dir] = ''
+    let config_file = a:git_dir . '/config'
+    if filereadable(config_file)
+      let config = readfile(config_file,'',10)
+      call filter(config,'v:val =~# "^\\s*worktree *="')
+      if len(config) == 1
+        let worktree = matchstr(config[0], '= *\zs.*')
+      endif
+    elseif filereadable(a:git_dir . '/gitdir')
+      let worktree = fnamemodify(readfile(a:git_dir . '/gitdir')[0], ':h')
+      if worktree ==# '.'
+        unlet! worktree
+      endif
+    endif
+    if exists('worktree')
+      let s:worktree_for_dir[a:git_dir] = worktree
+      let s:dir_for_worktree[s:worktree_for_dir[a:git_dir]] = a:git_dir
+    endif
+  endif
+  if s:worktree_for_dir[a:git_dir] =~# '^\.'
+    return simplify(a:git_dir . '/' . s:worktree_for_dir[a:git_dir])
+  else
+    return s:worktree_for_dir[a:git_dir]
+  endif
+endfunction
+
+function! s:repo_tree(...) dict abort
+  if self.dir() =~# '/\.git$'
+    let dir = self.dir()[0:-6]
+  else
+    let dir = s:configured_tree(self.git_dir)
+  endif
+  if dir ==# ''
+    call s:throw('no work tree')
+  else
+    return join([dir]+a:000,'/')
+  endif
+endfunction
+
+function! s:repo_bare() dict abort
+  if self.dir() =~# '/\.git$'
+    return 0
+  else
+    return s:configured_tree(self.git_dir) ==# ''
+  endif
+endfunction
+
+function! s:repo_translate(spec) dict abort
+  let refs = self.dir('refs/')
+  if filereadable(self.dir('commondir'))
+    let refs = simplify(self.dir(get(readfile(self.dir('commondir'), 1), 0, ''))) . '/refs/'
+  endif
+  if a:spec ==# '.' || a:spec ==# '/.'
+    return self.bare() ? self.dir() : self.tree()
+  elseif a:spec =~# '^/\=\.git$' && self.bare()
+    return self.dir()
+  elseif a:spec =~# '^/\=\.git/'
+    return self.dir(s:sub(a:spec, '^/=\.git/', ''))
+  elseif a:spec =~# '^/'
+    return self.tree().a:spec
+  elseif a:spec =~# '^:[0-3]:'
+    return 'fugitive://'.self.dir().'//'.a:spec[1].'/'.a:spec[3:-1]
+  elseif a:spec ==# ':'
+    if $GIT_INDEX_FILE =~# '/[^/]*index[^/]*\.lock$' && fnamemodify($GIT_INDEX_FILE,':p')[0:strlen(self.dir())] ==# self.dir('') && filereadable($GIT_INDEX_FILE)
+      return fnamemodify($GIT_INDEX_FILE,':p')
+    else
+      return self.dir('index')
+    endif
+  elseif a:spec =~# '^:/'
+    let ref = self.rev_parse(matchstr(a:spec,'.[^:]*'))
+    return 'fugitive://'.self.dir().'//'.ref
+  elseif a:spec =~# '^:'
+    return 'fugitive://'.self.dir().'//0/'.a:spec[1:-1]
+  elseif a:spec ==# '@'
+    return self.dir('HEAD')
+  elseif a:spec =~# 'HEAD\|^refs/' && a:spec !~ ':' && filereadable(refs . '../' . a:spec)
+    return simplify(refs . '../' . a:spec)
+  elseif filereadable(refs.a:spec)
+    return refs.a:spec
+  elseif filereadable(refs.'tags/'.a:spec)
+    return refs.'tags/'.a:spec
+  elseif filereadable(refs.'heads/'.a:spec)
+    return refs.'heads/'.a:spec
+  elseif filereadable(refs.'remotes/'.a:spec)
+    return refs.'remotes/'.a:spec
+  elseif filereadable(refs.'remotes/'.a:spec.'/HEAD')
+    return refs.'remotes/'.a:spec.'/HEAD'
+  else
+    try
+      let ref = self.rev_parse(matchstr(a:spec,'[^:]*'))
+      let path = s:sub(matchstr(a:spec,':.*'),'^:','/')
+      return 'fugitive://'.self.dir().'//'.ref.path
+    catch /^fugitive:/
+      return self.tree(a:spec)
+    endtry
+  endif
+endfunction
+
+function! s:repo_head(...) dict abort
+    let head = s:repo().head_ref()
+
+    if head =~# '^ref: '
+      let branch = s:sub(head,'^ref: %(refs/%(heads/|remotes/|tags/)=)=','')
+    elseif head =~# '^\x\{40\}$'
+      " truncate hash to a:1 characters if we're in detached head mode
+      let len = a:0 ? a:1 : 0
+      let branch = len ? head[0:len-1] : ''
+    else
+      return ''
+    endif
+
+    return branch
+endfunction
+
+call s:add_methods('repo',['dir','tree','bare','translate','head'])
+
+function! s:repo_git_command(...) dict abort
+  let git = g:fugitive_git_executable . ' --git-dir='.s:shellesc(self.git_dir)
+  return git.join(map(copy(a:000),'" ".s:shellesc(v:val)'),'')
+endfunction
+
+function! s:repo_git_chomp(...) dict abort
+  return s:sub(system(call(self.git_command,a:000,self)),'\n$','')
+endfunction
+
+function! s:repo_git_chomp_in_tree(...) dict abort
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+  let dir = getcwd()
+  try
+    execute cd.'`=s:repo().tree()`'
+    return call(s:repo().git_chomp, a:000, s:repo())
+  finally
+    execute cd.'`=dir`'
+  endtry
+endfunction
+
+function! s:repo_rev_parse(rev) dict abort
+  let hash = self.git_chomp('rev-parse','--verify',a:rev)
+  if hash =~ '\<\x\{40\}$'
+    return matchstr(hash,'\<\x\{40\}$')
+  endif
+  call s:throw('rev-parse '.a:rev.': '.hash)
+endfunction
+
+call s:add_methods('repo',['git_command','git_chomp','git_chomp_in_tree','rev_parse'])
+
+function! s:repo_dirglob(base) dict abort
+  let base = s:sub(a:base,'^/','')
+  let matches = split(glob(self.tree(s:gsub(base,'/','*&').'*/')),"\n")
+  call map(matches,'v:val[ strlen(self.tree())+(a:base !~ "^/") : -1 ]')
+  return matches
+endfunction
+
+function! s:repo_superglob(base) dict abort
+  if a:base =~# '^/' || a:base !~# ':'
+    let results = []
+    if a:base !~# '^/'
+      let heads = ["HEAD","ORIG_HEAD","FETCH_HEAD","MERGE_HEAD"]
+      let heads += sort(split(s:repo().git_chomp("rev-parse","--symbolic","--branches","--tags","--remotes"),"\n"))
+      " Add any stashes.
+      if filereadable(s:repo().dir('refs/stash'))
+        let heads += ["stash"]
+        let heads += sort(split(s:repo().git_chomp("stash","list","--pretty=format:%gd"),"\n"))
+      endif
+      call filter(heads,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
+      let results += heads
+    endif
+    if !self.bare()
+      let base = s:sub(a:base,'^/','')
+      let matches = split(glob(self.tree(s:gsub(base,'/','*&').'*')),"\n")
+      call map(matches,'s:shellslash(v:val)')
+      call map(matches,'v:val !~ "/$" && isdirectory(v:val) ? v:val."/" : v:val')
+      call map(matches,'v:val[ strlen(self.tree())+(a:base !~ "^/") : -1 ]')
+      let results += matches
+    endif
+    return results
+
+  elseif a:base =~# '^:'
+    let entries = split(self.git_chomp('ls-files','--stage'),"\n")
+    call map(entries,'s:sub(v:val,".*(\\d)\\t(.*)",":\\1:\\2")')
+    if a:base !~# '^:[0-3]\%(:\|$\)'
+      call filter(entries,'v:val[1] == "0"')
+      call map(entries,'v:val[2:-1]')
+    endif
+    call filter(entries,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
+    return entries
+
+  else
+    let tree = matchstr(a:base,'.*[:/]')
+    let entries = split(self.git_chomp('ls-tree',tree),"\n")
+    call map(entries,'s:sub(v:val,"^04.*\\zs$","/")')
+    call map(entries,'tree.s:sub(v:val,".*\t","")')
+    return filter(entries,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
+  endif
+endfunction
+
+call s:add_methods('repo',['dirglob','superglob'])
+
+function! s:repo_config(conf) dict abort
+  return matchstr(system(s:repo().git_command('config').' '.a:conf),"[^\r\n]*")
+endfun
+
+function! s:repo_user() dict abort
+  let username = s:repo().config('user.name')
+  let useremail = s:repo().config('user.email')
+  return username.' <'.useremail.'>'
+endfun
+
+function! s:repo_aliases() dict abort
+  if !has_key(self,'_aliases')
+    let self._aliases = {}
+    for line in split(self.git_chomp('config','--get-regexp','^alias[.]'),"\n")
+      let self._aliases[matchstr(line,'\.\zs\S\+')] = matchstr(line,' \zs.*')
+    endfor
+  endif
+  return self._aliases
+endfunction
+
+call s:add_methods('repo',['config', 'user', 'aliases'])
+
+function! s:repo_keywordprg() dict abort
+  let args = ' --git-dir='.escape(self.dir(),"\\\"' ")
+  if has('gui_running') && !has('win32')
+    return g:fugitive_git_executable . ' --no-pager' . args . ' log -1'
+  else
+    return g:fugitive_git_executable . args . ' show'
+  endif
+endfunction
+
+call s:add_methods('repo',['keywordprg'])
+
+" Section: Buffer
+
+let s:buffer_prototype = {}
+
+function! s:buffer(...) abort
+  let buffer = {'#': bufnr(a:0 ? a:1 : '%')}
+  call extend(extend(buffer,s:buffer_prototype,'keep'),s:abstract_prototype,'keep')
+  if buffer.getvar('git_dir') !=# ''
+    return buffer
+  endif
+  call s:throw('not a git repository: '.expand('%:p'))
+endfunction
+
+function! fugitive#buffer(...) abort
+  return s:buffer(a:0 ? a:1 : '%')
+endfunction
+
+function! s:buffer_getvar(var) dict abort
+  return getbufvar(self['#'],a:var)
+endfunction
+
+function! s:buffer_setvar(var,value) dict abort
+  return setbufvar(self['#'],a:var,a:value)
+endfunction
+
+function! s:buffer_getline(lnum) dict abort
+  return get(getbufline(self['#'], a:lnum), 0, '')
+endfunction
+
+function! s:buffer_repo() dict abort
+  return s:repo(self.getvar('git_dir'))
+endfunction
+
+function! s:buffer_type(...) dict abort
+  if self.getvar('fugitive_type') != ''
+    let type = self.getvar('fugitive_type')
+  elseif fnamemodify(self.spec(),':p') =~# '.\git/refs/\|\.git/\w*HEAD$'
+    let type = 'head'
+  elseif self.getline(1) =~ '^tree \x\{40\}$' && self.getline(2) == ''
+    let type = 'tree'
+  elseif self.getline(1) =~ '^\d\{6\} \w\{4\} \x\{40\}\>\t'
+    let type = 'tree'
+  elseif self.getline(1) =~ '^\d\{6\} \x\{40\}\> \d\t'
+    let type = 'index'
+  elseif isdirectory(self.spec())
+    let type = 'directory'
+  elseif self.spec() == ''
+    let type = 'null'
+  else
+    let type = 'file'
+  endif
+  if a:0
+    return !empty(filter(copy(a:000),'v:val ==# type'))
+  else
+    return type
+  endif
+endfunction
+
+if has('win32')
+
+  function! s:buffer_spec() dict abort
+    let bufname = bufname(self['#'])
+    let retval = ''
+    for i in split(bufname,'[^:]\zs\\')
+      let retval = fnamemodify((retval==''?'':retval.'\').i,':.')
+    endfor
+    return s:shellslash(fnamemodify(retval,':p'))
+  endfunction
+
+else
+
+  function! s:buffer_spec() dict abort
+    let bufname = bufname(self['#'])
+    return s:shellslash(bufname == '' ? '' : fnamemodify(bufname,':p'))
+  endfunction
+
+endif
+
+function! s:buffer_name() dict abort
+  return self.spec()
+endfunction
+
+function! s:buffer_commit() dict abort
+  return matchstr(self.spec(),'^fugitive://.\{-\}//\zs\w*')
+endfunction
+
+function! s:cpath(path) abort
+  if exists('+fileignorecase') && &fileignorecase
+    return tolower(a:path)
+  else
+    return a:path
+  endif
+endfunction
+
+function! s:buffer_path(...) dict abort
+  let rev = matchstr(self.spec(),'^fugitive://.\{-\}//\zs.*')
+  if rev != ''
+    let rev = s:sub(rev,'\w*','')
+  elseif s:cpath(self.spec()[0 : len(self.repo().dir())]) ==#
+        \ s:cpath(self.repo().dir() . '/')
+    let rev = '/.git'.self.spec()[strlen(self.repo().dir()) : -1]
+  elseif !self.repo().bare() &&
+        \ s:cpath(self.spec()[0 : len(self.repo().tree())]) ==#
+        \ s:cpath(self.repo().tree() . '/')
+    let rev = self.spec()[strlen(self.repo().tree()) : -1]
+  endif
+  return s:sub(s:sub(rev,'.\zs/$',''),'^/',a:0 ? a:1 : '')
+endfunction
+
+function! s:buffer_rev() dict abort
+  let rev = matchstr(self.spec(),'^fugitive://.\{-\}//\zs.*')
+  if rev =~ '^\x/'
+    return ':'.rev[0].':'.rev[2:-1]
+  elseif rev =~ '.'
+    return s:sub(rev,'/',':')
+  elseif self.spec() =~ '\.git/index$'
+    return ':'
+  elseif self.spec() =~ '\.git/refs/\|\.git/.*HEAD$'
+    return self.spec()[strlen(self.repo().dir())+1 : -1]
+  else
+    return self.path('/')
+  endif
+endfunction
+
+function! s:buffer_sha1() dict abort
+  if self.spec() =~ '^fugitive://' || self.spec() =~ '\.git/refs/\|\.git/.*HEAD$'
+    return self.repo().rev_parse(self.rev())
+  else
+    return ''
+  endif
+endfunction
+
+function! s:buffer_expand(rev) dict abort
+  if a:rev =~# '^:[0-3]$'
+    let file = a:rev.self.path(':')
+  elseif a:rev =~# '^[-:]/$'
+    let file = '/'.self.path()
+  elseif a:rev =~# '^-'
+    let file = 'HEAD^{}'.a:rev[1:-1].self.path(':')
+  elseif a:rev =~# '^@{'
+    let file = 'HEAD'.a:rev.self.path(':')
+  elseif a:rev =~# '^[~^]'
+    let commit = s:sub(self.commit(),'^\d=$','HEAD')
+    let file = commit.a:rev.self.path(':')
+  else
+    let file = a:rev
+  endif
+  return s:sub(s:sub(file,'\%$',self.path()),'\.\@<=/$','')
+endfunction
+
+function! s:buffer_containing_commit() dict abort
+  if self.commit() =~# '^\d$'
+    return ':'
+  elseif self.commit() =~# '.'
+    return self.commit()
+  else
+    return 'HEAD'
+  endif
+endfunction
+
+function! s:buffer_up(...) dict abort
+  let rev = self.rev()
+  let c = a:0 ? a:1 : 1
+  while c
+    if rev =~# '^[/:]$'
+      let rev = 'HEAD'
+    elseif rev =~# '^:'
+      let rev = ':'
+    elseif rev =~# '^refs/[^^~:]*$\|^[^^~:]*HEAD$'
+      let rev .= '^{}'
+    elseif rev =~# '^/\|:.*/'
+      let rev = s:sub(rev, '.*\zs/.*', '')
+    elseif rev =~# ':.'
+      let rev = matchstr(rev, '^[^:]*:')
+    elseif rev =~# ':$'
+      let rev = rev[0:-2]
+    else
+      return rev.'~'.c
+    endif
+    let c -= 1
+  endwhile
+  return rev
+endfunction
+
+call s:add_methods('buffer',['getvar','setvar','getline','repo','type','spec','name','commit','path','rev','sha1','expand','containing_commit','up'])
+
+" Section: Git
+
+call s:command("-bang -nargs=? -complete=customlist,s:GitComplete Git :execute s:Git(<bang>0,<q-args>)")
+
+function! s:ExecuteInTree(cmd) abort
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+  let dir = getcwd()
+  try
+    execute cd.'`=s:repo().tree()`'
+    execute a:cmd
+  finally
+    execute cd.'`=dir`'
+  endtry
+endfunction
+
+function! s:Git(bang, args) abort
+  if a:bang
+    return s:Edit('edit', 1, a:args)
+  endif
+  let git = g:fugitive_git_executable
+  if has('gui_running') && !has('win32')
+    let git .= ' --no-pager'
+  endif
+  let args = matchstr(a:args,'\v\C.{-}%($|\\@<!%(\\\\)*\|)@=')
+  if exists(':terminal')
+    let dir = s:repo().tree()
+    -tabedit %
+    execute 'lcd' fnameescape(dir)
+    execute 'terminal' git args
+  else
+    call s:ExecuteInTree('!'.git.' '.args)
+    if has('win32')
+      call fugitive#reload_status()
+    endif
+  endif
+  return matchstr(a:args, '\v\C\\@<!%(\\\\)*\|\zs.*')
+endfunction
+
+function! fugitive#git_commands() abort
+  if !exists('s:exec_path')
+    let s:exec_path = s:sub(system(g:fugitive_git_executable.' --exec-path'),'\n$','')
+  endif
+  return map(split(glob(s:exec_path.'/git-*'),"\n"),'s:sub(v:val[strlen(s:exec_path)+5 : -1],"\\.exe$","")')
+endfunction
+
+function! s:GitComplete(A, L, P) abort
+  if strpart(a:L, 0, a:P) !~# ' [[:alnum:]-]\+ '
+    let cmds = fugitive#git_commands()
+    return filter(sort(cmds+keys(s:repo().aliases())), 'strpart(v:val, 0, strlen(a:A)) ==# a:A')
+  else
+    return s:repo().superglob(a:A)
+  endif
+endfunction
+
+" Section: Gcd, Glcd
+
+function! s:DirComplete(A,L,P) abort
+  let matches = s:repo().dirglob(a:A)
+  return matches
+endfunction
+
+call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Gcd  :cd<bang>  `=s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>)`")
+call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Glcd :lcd<bang> `=s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>)`")
+
+" Section: Gstatus
+
+call s:command("-bar Gstatus :execute s:Status()")
+augroup fugitive_status
+  autocmd!
+  if !has('win32')
+    autocmd FocusGained,ShellCmdPost * call fugitive#reload_status()
+    autocmd BufDelete term://* call fugitive#reload_status()
+  endif
+augroup END
+
+function! s:Status() abort
+  try
+    Gpedit :
+    wincmd P
+    setlocal foldmethod=syntax foldlevel=1
+    nnoremap <buffer> <silent> q    :<C-U>bdelete<CR>
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+  return ''
+endfunction
+
+function! fugitive#reload_status() abort
+  if exists('s:reloading_status')
+    return
+  endif
+  try
+    let s:reloading_status = 1
+    let mytab = tabpagenr()
+    for tab in [mytab] + range(1,tabpagenr('$'))
+      for winnr in range(1,tabpagewinnr(tab,'$'))
+        if getbufvar(tabpagebuflist(tab)[winnr-1],'fugitive_type') ==# 'index'
+          execute 'tabnext '.tab
+          if winnr != winnr()
+            execute winnr.'wincmd w'
+            let restorewinnr = 1
+          endif
+          try
+            if !&modified
+              call s:BufReadIndex()
+            endif
+          finally
+            if exists('restorewinnr')
+              wincmd p
+            endif
+            execute 'tabnext '.mytab
+          endtry
+        endif
+      endfor
+    endfor
+  finally
+    unlet! s:reloading_status
+  endtry
+endfunction
+
+function! s:stage_info(lnum) abort
+  let filename = matchstr(getline(a:lnum),'^#\t\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$')
+  let lnum = a:lnum
+  if has('multi_byte_encoding')
+    let colon = '\%(:\|\%uff1a\)'
+  else
+    let colon = ':'
+  endif
+  while lnum && getline(lnum) !~# colon.'$'
+    let lnum -= 1
+  endwhile
+  if !lnum
+    return ['', '']
+  elseif (getline(lnum+1) =~# '^# .*\<git \%(reset\|rm --cached\) ' && getline(lnum+2) ==# '#') || getline(lnum) ==# '# Changes to be committed:'
+    return [matchstr(filename, colon.' *\zs.*'), 'staged']
+  elseif (getline(lnum+1) =~# '^# .*\<git add ' && getline(lnum+2) ==# '#' && getline(lnum+3) !~# colon.'  ') || getline(lnum) ==# '# Untracked files:'
+    return [filename, 'untracked']
+  elseif getline(lnum+2) =~# '^# .*\<git checkout ' || getline(lnum) ==# '# Changes not staged for commit:'
+    return [matchstr(filename, colon.' *\zs.*'), 'unstaged']
+  elseif getline(lnum+2) =~# '^# .*\<git \%(add\|rm\)' || getline(lnum) ==# '# Unmerged paths:'
+    return [matchstr(filename, colon.' *\zs.*'), 'unmerged']
+  else
+    return ['', 'unknown']
+  endif
+endfunction
+
+function! s:StageNext(count) abort
+  for i in range(a:count)
+    call search('^#\t.*','W')
+  endfor
+  return '.'
+endfunction
+
+function! s:StagePrevious(count) abort
+  if line('.') == 1 && exists(':CtrlP') && get(g:, 'ctrl_p_map') =~? '^<c-p>$'
+    return 'CtrlP '.fnameescape(s:repo().tree())
+  else
+    for i in range(a:count)
+      call search('^#\t.*','Wbe')
+    endfor
+    return '.'
+  endif
+endfunction
+
+function! s:StageReloadSeek(target,lnum1,lnum2) abort
+  let jump = a:target
+  let f = matchstr(getline(a:lnum1-1),'^#\t\%([[:alpha:] ]\+: *\|.*\%uff1a *\)\=\zs.*')
+  if f !=# '' | let jump = f | endif
+  let f = matchstr(getline(a:lnum2+1),'^#\t\%([[:alpha:] ]\+: *\|.*\%uff1a *\)\=\zs.*')
+  if f !=# '' | let jump = f | endif
+  silent! edit!
+  1
+  redraw
+  call search('^#\t\%([[:alpha:] ]\+: *\|.*\%uff1a *\)\=\V'.jump.'\%( ([^()[:digit:]]\+)\)\=\$','W')
+endfunction
+
+function! s:StageUndo() abort
+  let [filename, section] = s:stage_info(line('.'))
+  if empty(filename)
+    return ''
+  endif
+  let repo = s:repo()
+  let hash = repo.git_chomp('hash-object', '-w', filename)
+  if !empty(hash)
+    if section ==# 'untracked'
+      call repo.git_chomp_in_tree('clean', '-f', '--', filename)
+    elseif section ==# 'unmerged'
+      call repo.git_chomp_in_tree('rm', '--', filename)
+    elseif section ==# 'unstaged'
+      call repo.git_chomp_in_tree('checkout', '--', filename)
+    else
+      call repo.git_chomp_in_tree('checkout', 'HEAD', '--', filename)
+    endif
+    call s:StageReloadSeek(filename, line('.'), line('.'))
+    let @" = hash
+    return 'checktime|redraw|echomsg ' .
+          \ string('To restore, :Git cat-file blob '.hash[0:6].' > '.filename)
+  endif
+endfunction
+
+function! s:StageDiff(diff) abort
+  let [filename, section] = s:stage_info(line('.'))
+  if filename ==# '' && section ==# 'staged'
+    return 'Git! diff --no-ext-diff --cached'
+  elseif filename ==# ''
+    return 'Git! diff --no-ext-diff'
+  elseif filename =~# ' -> '
+    let [old, new] = split(filename,' -> ')
+    execute 'Gedit '.s:fnameescape(':0:'.new)
+    return a:diff.' HEAD:'.s:fnameescape(old)
+  elseif section ==# 'staged'
+    execute 'Gedit '.s:fnameescape(':0:'.filename)
+    return a:diff.' -'
+  else
+    execute 'Gedit '.s:fnameescape('/'.filename)
+    return a:diff
+  endif
+endfunction
+
+function! s:StageDiffEdit() abort
+  let [filename, section] = s:stage_info(line('.'))
+  let arg = (filename ==# '' ? '.' : filename)
+  if section ==# 'staged'
+    return 'Git! diff --no-ext-diff --cached '.s:shellesc(arg)
+  elseif section ==# 'untracked'
+    let repo = s:repo()
+    call repo.git_chomp_in_tree('add','--intent-to-add',arg)
+    if arg ==# '.'
+      silent! edit!
+      1
+      if !search('^# .*:\n#.*\n# .*"git checkout \|^# Changes not staged for commit:$','W')
+        call search('^# .*:$','W')
+      endif
+    else
+      call s:StageReloadSeek(arg,line('.'),line('.'))
+    endif
+    return ''
+  else
+    return 'Git! diff --no-ext-diff '.s:shellesc(arg)
+  endif
+endfunction
+
+function! s:StageToggle(lnum1,lnum2) abort
+  if a:lnum1 == 1 && a:lnum2 == 1
+    return 'Gedit /.git|call search("^index$", "wc")'
+  endif
+  try
+    let output = ''
+    for lnum in range(a:lnum1,a:lnum2)
+      let [filename, section] = s:stage_info(lnum)
+      let repo = s:repo()
+      if getline('.') =~# '^# .*:$'
+        if section ==# 'staged'
+          call repo.git_chomp_in_tree('reset','-q')
+          silent! edit!
+          1
+          if !search('^# .*:\n# .*"git add .*\n#\n\|^# Untracked files:$','W')
+            call search('^# .*:$','W')
+          endif
+          return ''
+        elseif section ==# 'unstaged'
+          call repo.git_chomp_in_tree('add','-u')
+          silent! edit!
+          1
+          if !search('^# .*:\n# .*"git add .*\n#\n\|^# Untracked files:$','W')
+            call search('^# .*:$','W')
+          endif
+          return ''
+        else
+          call repo.git_chomp_in_tree('add','.')
+          silent! edit!
+          1
+          call search('^# .*:$','W')
+          return ''
+        endif
+      endif
+      if filename ==# ''
+        continue
+      endif
+      execute lnum
+      if filename =~ ' -> '
+        let cmd = ['mv','--'] + reverse(split(filename,' -> '))
+        let filename = cmd[-1]
+      elseif section ==# 'staged'
+        let cmd = ['reset','-q','--',filename]
+      elseif getline(lnum) =~# '^#\tdeleted:'
+        let cmd = ['rm','--',filename]
+      elseif getline(lnum) =~# '^#\tmodified:'
+        let cmd = ['add','--',filename]
+      else
+        let cmd = ['add','-A','--',filename]
+      endif
+      if !exists('first_filename')
+        let first_filename = filename
+      endif
+      let output .= call(repo.git_chomp_in_tree,cmd,s:repo())."\n"
+    endfor
+    if exists('first_filename')
+      call s:StageReloadSeek(first_filename,a:lnum1,a:lnum2)
+    endif
+    echo s:sub(s:gsub(output,'\n+','\n'),'\n$','')
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+  return 'checktime'
+endfunction
+
+function! s:StagePatch(lnum1,lnum2) abort
+  let add = []
+  let reset = []
+
+  for lnum in range(a:lnum1,a:lnum2)
+    let [filename, section] = s:stage_info(lnum)
+    if getline('.') =~# '^# .*:$' && section ==# 'staged'
+      return 'Git reset --patch'
+    elseif getline('.') =~# '^# .*:$' && section ==# 'unstaged'
+      return 'Git add --patch'
+    elseif getline('.') =~# '^# .*:$' && section ==# 'untracked'
+      return 'Git add -N .'
+    elseif filename ==# ''
+      continue
+    endif
+    if !exists('first_filename')
+      let first_filename = filename
+    endif
+    execute lnum
+    if filename =~ ' -> '
+      let reset += [split(filename,' -> ')[1]]
+    elseif section ==# 'staged'
+      let reset += [filename]
+    elseif getline(lnum) !~# '^#\tdeleted:'
+      let add += [filename]
+    endif
+  endfor
+  try
+    if !empty(add)
+      execute "Git add --patch -- ".join(map(add,'s:shellesc(v:val)'))
+    endif
+    if !empty(reset)
+      execute "Git reset --patch -- ".join(map(reset,'s:shellesc(v:val)'))
+    endif
+    if exists('first_filename')
+      silent! edit!
+      1
+      redraw
+      call search('^#\t\%([[:alpha:] ]\+: *\)\=\V'.first_filename.'\%( ([^()[:digit:]]\+)\)\=\$','W')
+    endif
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+  return 'checktime'
+endfunction
+
+" Section: Gcommit
+
+call s:command("-nargs=? -complete=customlist,s:CommitComplete Gcommit :execute s:Commit(<q-args>)")
+
+function! s:Commit(args, ...) abort
+  let repo = a:0 ? a:1 : s:repo()
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+  let dir = getcwd()
+  let msgfile = repo.dir('COMMIT_EDITMSG')
+  let outfile = tempname()
+  let errorfile = tempname()
+  try
+    try
+      execute cd.s:fnameescape(repo.tree())
+      if s:winshell()
+        let command = ''
+        let old_editor = $GIT_EDITOR
+        let $GIT_EDITOR = 'false'
+      else
+        let command = 'env GIT_EDITOR=false '
+      endif
+      let command .= repo.git_command('commit').' '.a:args
+      if &shell =~# 'csh'
+        noautocmd silent execute '!('.command.' > '.outfile.') >& '.errorfile
+      elseif a:args =~# '\%(^\| \)-\%(-interactive\|p\|-patch\)\>'
+        noautocmd execute '!'.command.' 2> '.errorfile
+      else
+        noautocmd silent execute '!'.command.' > '.outfile.' 2> '.errorfile
+      endif
+    finally
+      execute cd.'`=dir`'
+    endtry
+    if !has('gui_running')
+      redraw!
+    endif
+    if !v:shell_error
+      if filereadable(outfile)
+        for line in readfile(outfile)
+          echo line
+        endfor
+      endif
+      return ''
+    else
+      let errors = readfile(errorfile)
+      let error = get(errors,-2,get(errors,-1,'!'))
+      if error =~# 'false''\=\.$'
+        let args = a:args
+        let args = s:gsub(args,'%(%(^| )-- )@<!%(^| )@<=%(-[esp]|--edit|--interactive|--patch|--signoff)%($| )','')
+        let args = s:gsub(args,'%(%(^| )-- )@<!%(^| )@<=%(-c|--reedit-message|--reuse-message|-F|--file|-m|--message)%(\s+|\=)%(''[^'']*''|"%(\\.|[^"])*"|\\.|\S)*','')
+        let args = s:gsub(args,'%(^| )@<=[%#]%(:\w)*','\=expand(submatch(0))')
+        let args = s:sub(args, '\ze -- |$', ' --no-edit --no-interactive --no-signoff')
+        let args = '-F '.s:shellesc(msgfile).' '.args
+        if args !~# '\%(^\| \)--cleanup\>'
+          let args = '--cleanup=strip '.args
+        endif
+        if bufname('%') == '' && line('$') == 1 && getline(1) == '' && !&mod
+          execute 'keepalt edit '.s:fnameescape(msgfile)
+        elseif a:args =~# '\%(^\| \)-\%(-verbose\|\w*v\)\>'
+          execute 'keepalt -tabedit '.s:fnameescape(msgfile)
+        elseif s:buffer().type() ==# 'index'
+          execute 'keepalt edit '.s:fnameescape(msgfile)
+          execute (search('^#','n')+1).'wincmd+'
+          setlocal nopreviewwindow
+        else
+          execute 'keepalt split '.s:fnameescape(msgfile)
+        endif
+        let b:fugitive_commit_arguments = args
+        setlocal bufhidden=wipe filetype=gitcommit
+        return '1'
+      elseif error ==# '!'
+        return s:Status()
+      else
+        call s:throw(error)
+      endif
+    endif
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  finally
+    if exists('old_editor')
+      let $GIT_EDITOR = old_editor
+    endif
+    call delete(outfile)
+    call delete(errorfile)
+    call fugitive#reload_status()
+  endtry
+endfunction
+
+function! s:CommitComplete(A,L,P) abort
+  if a:A =~ '^-' || type(a:A) == type(0) " a:A is 0 on :Gcommit -<Tab>
+    let args = ['-C', '-F', '-a', '-c', '-e', '-i', '-m', '-n', '-o', '-q', '-s', '-t', '-u', '-v', '--all', '--allow-empty', '--amend', '--author=', '--cleanup=', '--dry-run', '--edit', '--file=', '--fixup=', '--include', '--interactive', '--message=', '--no-verify', '--only', '--quiet', '--reedit-message=', '--reuse-message=', '--signoff', '--squash=', '--template=', '--untracked-files', '--verbose']
+    return filter(args,'v:val[0 : strlen(a:A)-1] ==# a:A')
+  else
+    return s:repo().superglob(a:A)
+  endif
+endfunction
+
+function! s:FinishCommit() abort
+  let args = getbufvar(+expand('<abuf>'),'fugitive_commit_arguments')
+  if !empty(args)
+    call setbufvar(+expand('<abuf>'),'fugitive_commit_arguments','')
+    return s:Commit(args, s:repo(getbufvar(+expand('<abuf>'),'git_dir')))
+  endif
+  return ''
+endfunction
+
+" Section: Gmerge, Gpull
+
+call s:command("-nargs=? -bang -complete=custom,s:RevisionComplete Gmerge " .
+      \ "execute s:Merge('merge', <bang>0, <q-args>)")
+call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gpull " .
+      \ "execute s:Merge('pull --progress', <bang>0, <q-args>)")
+
+function! s:RevisionComplete(A, L, P) abort
+  return s:repo().git_chomp('rev-parse', '--symbolic', '--branches', '--tags', '--remotes')
+        \ . "\nHEAD\nFETCH_HEAD\nORIG_HEAD"
+endfunction
+
+function! s:RemoteComplete(A, L, P) abort
+  let remote = matchstr(a:L, ' \zs\S\+\ze ')
+  if !empty(remote)
+    let matches = split(s:repo().git_chomp('ls-remote', remote), "\n")
+    call filter(matches, 'v:val =~# "\t" && v:val !~# "{"')
+    call map(matches, 's:sub(v:val, "^.*\t%(refs/%(heads/|tags/)=)=", "")')
+  else
+    let matches = split(s:repo().git_chomp('remote'), "\n")
+  endif
+  return join(matches, "\n")
+endfunction
+
+function! fugitive#cwindow() abort
+  if &buftype == 'quickfix'
+    cwindow
+  else
+    botright cwindow
+    if &buftype == 'quickfix'
+      wincmd p
+    endif
+  endif
+endfunction
+
+let s:common_efm = ''
+      \ . '%+Egit:%.%#,'
+      \ . '%+Eusage:%.%#,'
+      \ . '%+Eerror:%.%#,'
+      \ . '%+Efatal:%.%#,'
+      \ . '%-G%.%#%\e[K%.%#,'
+      \ . '%-G%.%#%\r%.%\+'
+
+function! s:Merge(cmd, bang, args) abort
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
+  let cwd = getcwd()
+  let [mp, efm] = [&l:mp, &l:efm]
+  let had_merge_msg = filereadable(s:repo().dir('MERGE_MSG'))
+  try
+    let &l:errorformat = ''
+          \ . '%-Gerror:%.%#false''.,'
+          \ . '%-G%.%# ''git commit'' %.%#,'
+          \ . '%+Emerge:%.%#,'
+          \ . s:common_efm . ','
+          \ . '%+ECannot %.%#: You have unstaged changes.,'
+          \ . '%+ECannot %.%#: Your index contains uncommitted changes.,'
+          \ . '%+EThere is no tracking information for the current branch.,'
+          \ . '%+EYou are not currently on a branch. Please specify which,'
+          \ . 'CONFLICT (%m): %f deleted in %.%#,'
+          \ . 'CONFLICT (%m): Merge conflict in %f,'
+          \ . 'CONFLICT (%m): Rename \"%f\"->%.%#,'
+          \ . 'CONFLICT (%m): Rename %.%#->%f %.%#,'
+          \ . 'CONFLICT (%m): There is a directory with name %f in %.%#,'
+          \ . '%+ECONFLICT %.%#,'
+          \ . '%+EKONFLIKT %.%#,'
+          \ . '%+ECONFLIT %.%#,'
+          \ . "%+EXUNG \u0110\u1ed8T %.%#,"
+          \ . "%+E\u51b2\u7a81 %.%#,"
+          \ . 'U%\t%f'
+    if a:cmd =~# '^merge' && empty(a:args) &&
+          \ (had_merge_msg || isdirectory(s:repo().dir('rebase-apply')) ||
+          \  !empty(s:repo().git_chomp('diff-files', '--diff-filter=U')))
+      let &l:makeprg = g:fugitive_git_executable.' diff-files --name-status --diff-filter=U'
+    else
+      let &l:makeprg = s:sub(g:fugitive_git_executable . ' ' . a:cmd .
+            \ (a:args =~# ' \%(--no-edit\|--abort\|-m\)\>' ? '' : ' --edit') .
+            \ ' ' . a:args, ' *$', '')
+    endif
+    if !empty($GIT_EDITOR) || has('win32')
+      let old_editor = $GIT_EDITOR
+      let $GIT_EDITOR = 'false'
+    else
+      let &l:makeprg = 'env GIT_EDITOR=false ' . &l:makeprg
+    endif
+    execute cd fnameescape(s:repo().tree())
+    silent noautocmd make!
+  catch /^Vim\%((\a\+)\)\=:E211/
+    let err = v:exception
+  finally
+    redraw!
+    let [&l:mp, &l:efm] = [mp, efm]
+    if exists('old_editor')
+      let $GIT_EDITOR = old_editor
+    endif
+    execute cd fnameescape(cwd)
+  endtry
+  call fugitive#reload_status()
+  if empty(filter(getqflist(),'v:val.valid'))
+    if !had_merge_msg && filereadable(s:repo().dir('MERGE_MSG'))
+      cclose
+      return 'Gcommit --no-status -n -t '.s:shellesc(s:repo().dir('MERGE_MSG'))
+    endif
+  endif
+  let qflist = getqflist()
+  let found = 0
+  for e in qflist
+    if !empty(e.bufnr)
+      let found = 1
+      let e.pattern = '^<<<<<<<'
+    endif
+  endfor
+  call fugitive#cwindow()
+  if found
+    call setqflist(qflist, 'r')
+    if !a:bang
+      return 'cfirst'
+    endif
+  endif
+  return exists('err') ? 'echoerr '.string(err) : ''
+endfunction
+
+" Section: Ggrep, Glog
+
+if !exists('g:fugitive_summary_format')
+  let g:fugitive_summary_format = '%s'
+endif
+
+call s:command("-bang -nargs=? -complete=customlist,s:EditComplete Ggrep :execute s:Grep('grep',<bang>0,<q-args>)")
+call s:command("-bang -nargs=? -complete=customlist,s:EditComplete Glgrep :execute s:Grep('lgrep',<bang>0,<q-args>)")
+call s:command("-bar -bang -nargs=* -range=0 -complete=customlist,s:EditComplete Glog :call s:Log('grep<bang>',<line1>,<count>,<f-args>)")
+call s:command("-bar -bang -nargs=* -range=0 -complete=customlist,s:EditComplete Gllog :call s:Log('lgrep<bang>',<line1>,<count>,<f-args>)")
+
+function! s:Grep(cmd,bang,arg) abort
+  let grepprg = &grepprg
+  let grepformat = &grepformat
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+  let dir = getcwd()
+  try
+    execute cd.'`=s:repo().tree()`'
+    let &grepprg = s:repo().git_command('--no-pager', 'grep', '-n', '--no-color')
+    let &grepformat = '%f:%l:%m,%m %f match%ts,%f'
+    exe a:cmd.'! '.escape(matchstr(a:arg,'\v\C.{-}%($|[''" ]\@=\|)@='),'|')
+    let list = a:cmd =~# '^l' ? getloclist(0) : getqflist()
+    for entry in list
+      if bufname(entry.bufnr) =~ ':'
+        let entry.filename = s:repo().translate(bufname(entry.bufnr))
+        unlet! entry.bufnr
+        let changed = 1
+      elseif a:arg =~# '\%(^\| \)--cached\>'
+        let entry.filename = s:repo().translate(':0:'.bufname(entry.bufnr))
+        unlet! entry.bufnr
+        let changed = 1
+      endif
+    endfor
+    if a:cmd =~# '^l' && exists('changed')
+      call setloclist(0, list, 'r')
+    elseif exists('changed')
+      call setqflist(list, 'r')
+    endif
+    if !a:bang && !empty(list)
+      return (a:cmd =~# '^l' ? 'l' : 'c').'first'.matchstr(a:arg,'\v\C[''" ]\zs\|.*')
+    else
+      return matchstr(a:arg,'\v\C[''" ]\|\zs.*')
+    endif
+  finally
+    let &grepprg = grepprg
+    let &grepformat = grepformat
+    execute cd.'`=dir`'
+  endtry
+endfunction
+
+function! s:Log(cmd, line1, line2, ...) abort
+  let path = s:buffer().path('/')
+  if path =~# '^/\.git\%(/\|$\)' || index(a:000,'--') != -1
+    let path = ''
+  endif
+  let cmd = ['--no-pager', 'log', '--no-color']
+  let cmd += ['--pretty=format:fugitive://'.s:repo().dir().'//%H'.path.'::'.g:fugitive_summary_format]
+  if empty(filter(a:000[0 : index(a:000,'--')],'v:val !~# "^-"'))
+    if s:buffer().commit() =~# '\x\{40\}'
+      let cmd += [s:buffer().commit()]
+    elseif s:buffer().path() =~# '^\.git/refs/\|^\.git/.*HEAD$'
+      let cmd += [s:buffer().path()[5:-1]]
+    endif
+  end
+  let cmd += map(copy(a:000),'s:sub(v:val,"^\\%(%(:\\w)*)","\\=fnamemodify(s:buffer().path(),submatch(1))")')
+  if path =~# '/.'
+    if a:line2
+      let cmd += ['-L', a:line1 . ',' . a:line2 . ':' . path[1:-1]]
+    else
+      let cmd += ['--', path[1:-1]]
+    endif
+  endif
+  let grepformat = &grepformat
+  let grepprg = &grepprg
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+  let dir = getcwd()
+  try
+    execute cd.'`=s:repo().tree()`'
+    let &grepprg = escape(call(s:repo().git_command,cmd,s:repo()),'%#')
+    let &grepformat = '%Cdiff %.%#,%C--- %.%#,%C+++ %.%#,%Z@@ -%\d%\+\,%\d%\+ +%l\,%\d%\+ @@,%-G-%.%#,%-G+%.%#,%-G %.%#,%A%f::%m,%-G%.%#'
+    exe a:cmd
+  finally
+    let &grepformat = grepformat
+    let &grepprg = grepprg
+    execute cd.'`=dir`'
+  endtry
+endfunction
+
+" Section: Gedit, Gpedit, Gsplit, Gvsplit, Gtabedit, Gread
+
+function! s:Edit(cmd,bang,...) abort
+  let buffer = s:buffer()
+  if a:cmd !~# 'read'
+    if &previewwindow && getbufvar('','fugitive_type') ==# 'index'
+      if winnr('$') == 1
+        let tabs = (&go =~# 'e' || !has('gui_running')) && &stal && (tabpagenr('$') >= &stal)
+        execute 'rightbelow' (&lines - &previewheight - &cmdheight - tabs - 1 - !!&laststatus).'new'
+      elseif winnr('#')
+        wincmd p
+      else
+        wincmd w
+      endif
+      if &diff
+        let mywinnr = winnr()
+        for winnr in range(winnr('$'),1,-1)
+          if winnr != mywinnr && getwinvar(winnr,'&diff')
+            execute winnr.'wincmd w'
+            close
+            if winnr('$') > 1
+              wincmd p
+            endif
+          endif
+        endfor
+      endif
+    endif
+  endif
+
+  if a:bang
+    let arglist = map(copy(a:000), 's:gsub(v:val, ''\\@<!%(\\\\)*\zs[%#]'', ''\=s:buffer().expand(submatch(0))'')')
+    let args = join(arglist, ' ')
+    if a:cmd =~# 'read'
+      let git = buffer.repo().git_command()
+      let last = line('$')
+      silent call s:ExecuteInTree((a:cmd ==# 'read' ? '$read' : a:cmd).'!'.git.' --no-pager '.args)
+      if a:cmd ==# 'read'
+        silent execute '1,'.last.'delete_'
+      endif
+      call fugitive#reload_status()
+      diffupdate
+      return 'redraw|echo '.string(':!'.git.' '.args)
+    else
+      let temp = resolve(tempname())
+      let s:temp_files[s:cpath(temp)] = { 'dir': buffer.repo().dir(), 'args': arglist }
+      silent execute a:cmd.' '.temp
+      if a:cmd =~# 'pedit'
+        wincmd P
+      endif
+      let echo = s:Edit('read',1,args)
+      silent write!
+      setlocal buftype=nowrite nomodified filetype=git foldmarker=<<<<<<<,>>>>>>>
+      if getline(1) !~# '^diff '
+        setlocal readonly nomodifiable
+      endif
+      if a:cmd =~# 'pedit'
+        wincmd p
+      endif
+      return echo
+    endif
+    return ''
+  endif
+
+  if a:0 && a:1 == ''
+    return ''
+  elseif a:0
+    let file = buffer.expand(join(a:000, ' '))
+  elseif expand('%') ==# ''
+    let file = ':'
+  elseif buffer.commit() ==# '' && buffer.path('/') !~# '^/.git\>'
+    let file = buffer.path(':')
+  else
+    let file = buffer.path('/')
+  endif
+  try
+    let file = buffer.repo().translate(file)
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+  if file !~# '^fugitive:'
+    let file = s:sub(file, '/$', '')
+  endif
+  if a:cmd ==# 'read'
+    return 'silent %delete_|read '.s:fnameescape(file).'|silent 1delete_|diffupdate|'.line('.')
+  else
+    return a:cmd.' '.s:fnameescape(file)
+  endif
+endfunction
+
+function! s:EditComplete(A,L,P) abort
+  return map(s:repo().superglob(a:A), 'fnameescape(v:val)')
+endfunction
+
+function! s:EditRunComplete(A,L,P) abort
+  if a:L =~# '^\w\+!'
+    return s:GitComplete(a:A,a:L,a:P)
+  else
+    return s:repo().superglob(a:A)
+  endif
+endfunction
+
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Ge       :execute s:Edit('edit<bang>',0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gedit    :execute s:Edit('edit<bang>',0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gpedit   :execute s:Edit('pedit',<bang>0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gsplit   :execute s:Edit('split',<bang>0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gvsplit  :execute s:Edit('vsplit',<bang>0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gtabedit :execute s:Edit('tabedit',<bang>0,<f-args>)")
+call s:command("-bar -bang -nargs=* -count -complete=customlist,s:EditRunComplete Gread :execute s:Edit((!<count> && <line1> ? '' : <count>).'read',<bang>0,<f-args>)")
+
+" Section: Gwrite, Gwq
+
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gwrite :execute s:Write(<bang>0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gw :execute s:Write(<bang>0,<f-args>)")
+call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gwq :execute s:Wq(<bang>0,<f-args>)")
+
+function! s:Write(force,...) abort
+  if exists('b:fugitive_commit_arguments')
+    return 'write|bdelete'
+  elseif expand('%:t') == 'COMMIT_EDITMSG' && $GIT_INDEX_FILE != ''
+    return 'wq'
+  elseif s:buffer().type() == 'index'
+    return 'Gcommit'
+  elseif s:buffer().path() ==# '' && getline(4) =~# '^+++ '
+    let filename = getline(4)[6:-1]
+    setlocal buftype=
+    silent write
+    setlocal buftype=nowrite
+    if matchstr(getline(2),'index [[:xdigit:]]\+\.\.\zs[[:xdigit:]]\{7\}') ==# s:repo().rev_parse(':0:'.filename)[0:6]
+      let err = s:repo().git_chomp('apply','--cached','--reverse',s:buffer().spec())
+    else
+      let err = s:repo().git_chomp('apply','--cached',s:buffer().spec())
+    endif
+    if err !=# ''
+      let v:errmsg = split(err,"\n")[0]
+      return 'echoerr v:errmsg'
+    elseif a:force
+      return 'bdelete'
+    else
+      return 'Gedit '.fnameescape(filename)
+    endif
+  endif
+  let mytab = tabpagenr()
+  let mybufnr = bufnr('')
+  let path = a:0 ? join(a:000, ' ') : s:buffer().path()
+  if empty(path)
+    return 'echoerr '.string('fugitive: cannot determine file path')
+  endif
+  if path =~# '^:\d\>'
+    return 'write'.(a:force ? '! ' : ' ').s:fnameescape(s:repo().translate(s:buffer().expand(path)))
+  endif
+  let always_permitted = (s:buffer().path() ==# path && s:buffer().commit() =~# '^0\=$')
+  if !always_permitted && !a:force && s:repo().git_chomp_in_tree('diff','--name-status','HEAD','--',path) . s:repo().git_chomp_in_tree('ls-files','--others','--',path) !=# ''
+    let v:errmsg = 'fugitive: file has uncommitted changes (use ! to override)'
+    return 'echoerr v:errmsg'
+  endif
+  let file = s:repo().translate(path)
+  let treebufnr = 0
+  for nr in range(1,bufnr('$'))
+    if fnamemodify(bufname(nr),':p') ==# file
+      let treebufnr = nr
+    endif
+  endfor
+
+  if treebufnr > 0 && treebufnr != bufnr('')
+    let temp = tempname()
+    silent execute '%write '.temp
+    for tab in [mytab] + range(1,tabpagenr('$'))
+      for winnr in range(1,tabpagewinnr(tab,'$'))
+        if tabpagebuflist(tab)[winnr-1] == treebufnr
+          execute 'tabnext '.tab
+          if winnr != winnr()
+            execute winnr.'wincmd w'
+            let restorewinnr = 1
+          endif
+          try
+            let lnum = line('.')
+            let last = line('$')
+            silent execute '$read '.temp
+            silent execute '1,'.last.'delete_'
+            silent write!
+            silent execute lnum
+            let did = 1
+          finally
+            if exists('restorewinnr')
+              wincmd p
+            endif
+            execute 'tabnext '.mytab
+          endtry
+        endif
+      endfor
+    endfor
+    if !exists('did')
+      call writefile(readfile(temp,'b'),file,'b')
+    endif
+  else
+    execute 'write! '.s:fnameescape(s:repo().translate(path))
+  endif
+
+  if a:force
+    let error = s:repo().git_chomp_in_tree('add', '--force', '--', path)
+  else
+    let error = s:repo().git_chomp_in_tree('add', '--', path)
+  endif
+  if v:shell_error
+    let v:errmsg = 'fugitive: '.error
+    return 'echoerr v:errmsg'
+  endif
+  if s:buffer().path() ==# path && s:buffer().commit() =~# '^\d$'
+    set nomodified
+  endif
+
+  let one = s:repo().translate(':1:'.path)
+  let two = s:repo().translate(':2:'.path)
+  let three = s:repo().translate(':3:'.path)
+  for nr in range(1,bufnr('$'))
+    let name = fnamemodify(bufname(nr), ':p')
+    if bufloaded(nr) && !getbufvar(nr,'&modified') && (name ==# one || name ==# two || name ==# three)
+      execute nr.'bdelete'
+    endif
+  endfor
+
+  unlet! restorewinnr
+  let zero = s:repo().translate(':0:'.path)
+  silent execute 'doautocmd BufWritePost' s:fnameescape(zero)
+  for tab in range(1,tabpagenr('$'))
+    for winnr in range(1,tabpagewinnr(tab,'$'))
+      let bufnr = tabpagebuflist(tab)[winnr-1]
+      let bufname = fnamemodify(bufname(bufnr), ':p')
+      if bufname ==# zero && bufnr != mybufnr
+        execute 'tabnext '.tab
+        if winnr != winnr()
+          execute winnr.'wincmd w'
+          let restorewinnr = 1
+        endif
+        try
+          let lnum = line('.')
+          let last = line('$')
+          silent execute '$read '.s:fnameescape(file)
+          silent execute '1,'.last.'delete_'
+          silent execute lnum
+          set nomodified
+          diffupdate
+        finally
+          if exists('restorewinnr')
+            wincmd p
+          endif
+          execute 'tabnext '.mytab
+        endtry
+        break
+      endif
+    endfor
+  endfor
+  call fugitive#reload_status()
+  return 'checktime'
+endfunction
+
+function! s:Wq(force,...) abort
+  let bang = a:force ? '!' : ''
+  if exists('b:fugitive_commit_arguments')
+    return 'wq'.bang
+  endif
+  let result = call(s:function('s:Write'),[a:force]+a:000)
+  if result =~# '^\%(write\|wq\|echoerr\)'
+    return s:sub(result,'^write','wq')
+  else
+    return result.'|quit'.bang
+  endif
+endfunction
+
+augroup fugitive_commit
+  autocmd!
+  autocmd VimLeavePre,BufDelete COMMIT_EDITMSG execute s:sub(s:FinishCommit(), '^echoerr (.*)', 'echohl ErrorMsg|echo \1|echohl NONE')
+augroup END
+
+" Section: Gpush, Gfetch
+
+call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gpush  execute s:Dispatch('<bang>', 'push '.<q-args>)")
+call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gfetch execute s:Dispatch('<bang>', 'fetch '.<q-args>)")
+
+function! s:Dispatch(bang, args)
+  let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
+  let cwd = getcwd()
+  let [mp, efm, cc] = [&l:mp, &l:efm, get(b:, 'current_compiler', '')]
+  try
+    let b:current_compiler = 'git'
+    let &l:errorformat = s:common_efm
+    let &l:makeprg = g:fugitive_git_executable . ' ' . a:args
+    execute cd fnameescape(s:repo().tree())
+    if exists(':Make') == 2
+      noautocmd Make
+    else
+      silent noautocmd make!
+      redraw!
+      return 'call fugitive#cwindow()'
+    endif
+    return ''
+  finally
+    let [&l:mp, &l:efm, b:current_compiler] = [mp, efm, cc]
+    if empty(cc) | unlet! b:current_compiler | endif
+    execute cd fnameescape(cwd)
+  endtry
+endfunction
+
+" Section: Gdiff
+
+call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gdiff :execute s:Diff('',<bang>0,<f-args>)")
+call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gvdiff :execute s:Diff('keepalt vert ',<bang>0,<f-args>)")
+call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gsdiff :execute s:Diff('keepalt ',<bang>0,<f-args>)")
+
+augroup fugitive_diff
+  autocmd!
+  autocmd BufWinLeave *
+        \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 2 |
+        \   call s:diffoff_all(getbufvar(+expand('<abuf>'), 'git_dir')) |
+        \ endif
+  autocmd BufWinEnter *
+        \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 1 |
+        \   call s:diffoff() |
+        \ endif
+augroup END
+
+function! s:can_diffoff(buf) abort
+  return getwinvar(bufwinnr(a:buf), '&diff') &&
+        \ !empty(getbufvar(a:buf, 'git_dir')) &&
+        \ !empty(getwinvar(bufwinnr(a:buf), 'fugitive_diff_restore'))
+endfunction
+
+function! fugitive#can_diffoff(buf) abort
+  return s:can_diffoff(a:buf)
+endfunction
+
+function! s:diff_modifier(count) abort
+  let fdc = matchstr(&diffopt, 'foldcolumn:\zs\d\+')
+  if &diffopt =~# 'horizontal' && &diffopt !~# 'vertical'
+    return 'keepalt '
+  elseif &diffopt =~# 'vertical'
+    return 'keepalt vert '
+  elseif winwidth(0) <= a:count * ((&tw ? &tw : 80) + (empty(fdc) ? 2 : fdc))
+    return 'keepalt '
+  else
+    return 'keepalt vert '
+  endif
+endfunction
+
+function! s:diff_window_count() abort
+  let c = 0
+  for nr in range(1,winnr('$'))
+    let c += getwinvar(nr,'&diff')
+  endfor
+  return c
+endfunction
+
+function! s:diff_restore() abort
+  let restore = 'setlocal nodiff noscrollbind'
+        \ . ' scrollopt=' . &l:scrollopt
+        \ . (&l:wrap ? ' wrap' : ' nowrap')
+        \ . ' foldlevel=999'
+        \ . ' foldmethod=' . &l:foldmethod
+        \ . ' foldcolumn=' . &l:foldcolumn
+        \ . ' foldlevel=' . &l:foldlevel
+        \ . (&l:foldenable ? ' foldenable' : ' nofoldenable')
+  if has('cursorbind')
+    let restore .= (&l:cursorbind ? ' ' : ' no') . 'cursorbind'
+  endif
+  return restore
+endfunction
+
+function! s:diffthis() abort
+  if !&diff
+    let w:fugitive_diff_restore = s:diff_restore()
+    diffthis
+  endif
+endfunction
+
+function! s:diffoff() abort
+  if exists('w:fugitive_diff_restore')
+    execute w:fugitive_diff_restore
+    unlet w:fugitive_diff_restore
+  else
+    diffoff
+  endif
+endfunction
+
+function! s:diffoff_all(dir) abort
+  let curwin = winnr()
+  for nr in range(1,winnr('$'))
+    if getwinvar(nr,'&diff')
+      if nr != winnr()
+        execute nr.'wincmd w'
+        let restorewinnr = 1
+      endif
+      if exists('b:git_dir') && b:git_dir ==# a:dir
+        call s:diffoff()
+      endif
+    endif
+  endfor
+  execute curwin.'wincmd w'
+endfunction
+
+function! s:buffer_compare_age(commit) dict abort
+  let scores = {':0': 1, ':1': 2, ':2': 3, ':': 4, ':3': 5}
+  let my_score    = get(scores,':'.self.commit(),0)
+  let their_score = get(scores,':'.a:commit,0)
+  if my_score || their_score
+    return my_score < their_score ? -1 : my_score != their_score
+  elseif self.commit() ==# a:commit
+    return 0
+  endif
+  let base = self.repo().git_chomp('merge-base',self.commit(),a:commit)
+  if base ==# self.commit()
+    return -1
+  elseif base ==# a:commit
+    return 1
+  endif
+  let my_time    = +self.repo().git_chomp('log','--max-count=1','--pretty=format:%at',self.commit())
+  let their_time = +self.repo().git_chomp('log','--max-count=1','--pretty=format:%at',a:commit)
+  return my_time < their_time ? -1 : my_time != their_time
+endfunction
+
+call s:add_methods('buffer',['compare_age'])
+
+function! s:Diff(vert,keepfocus,...) abort
+  let args = copy(a:000)
+  let post = ''
+  if get(args, 0) =~# '^+'
+    let post = remove(args, 0)[1:-1]
+  endif
+  let vert = empty(a:vert) ? s:diff_modifier(2) : a:vert
+  if exists(':DiffGitCached')
+    return 'DiffGitCached'
+  elseif (empty(args) || args[0] == ':') && s:buffer().commit() =~# '^[0-1]\=$' && s:repo().git_chomp_in_tree('ls-files', '--unmerged', '--', s:buffer().path()) !=# ''
+    let vert = empty(a:vert) ? s:diff_modifier(3) : a:vert
+    let nr = bufnr('')
+    execute 'leftabove '.vert.'split `=fugitive#buffer().repo().translate(s:buffer().expand('':2''))`'
+    execute 'nnoremap <buffer> <silent> dp :diffput '.nr.'<Bar>diffupdate<CR>'
+    call s:diffthis()
+    wincmd p
+    execute 'rightbelow '.vert.'split `=fugitive#buffer().repo().translate(s:buffer().expand('':3''))`'
+    execute 'nnoremap <buffer> <silent> dp :diffput '.nr.'<Bar>diffupdate<CR>'
+    call s:diffthis()
+    wincmd p
+    call s:diffthis()
+    return post
+  elseif len(args)
+    let arg = join(args, ' ')
+    if arg ==# ''
+      return post
+    elseif arg ==# '/'
+      let file = s:buffer().path('/')
+    elseif arg ==# ':'
+      let file = s:buffer().path(':0:')
+    elseif arg =~# '^:/.'
+      try
+        let file = s:repo().rev_parse(arg).s:buffer().path(':')
+      catch /^fugitive:/
+        return 'echoerr v:errmsg'
+      endtry
+    else
+      let file = s:buffer().expand(arg)
+    endif
+    if file !~# ':' && file !~# '^/' && s:repo().git_chomp('cat-file','-t',file) =~# '^\%(tag\|commit\)$'
+      let file = file.s:buffer().path(':')
+    endif
+  else
+    let file = s:buffer().path(s:buffer().commit() == '' ? ':0:' : '/')
+  endif
+  try
+    let spec = s:repo().translate(file)
+    let commit = matchstr(spec,'\C[^:/]//\zs\x\+')
+    let restore = s:diff_restore()
+    if exists('+cursorbind')
+      setlocal cursorbind
+    endif
+    let w:fugitive_diff_restore = restore
+    if s:buffer().compare_age(commit) < 0
+      execute 'rightbelow '.vert.'diffsplit '.s:fnameescape(spec)
+    else
+      execute 'leftabove '.vert.'diffsplit '.s:fnameescape(spec)
+    endif
+    let &l:readonly = &l:readonly
+    redraw
+    let w:fugitive_diff_restore = restore
+    let winnr = winnr()
+    if getwinvar('#', '&diff')
+      wincmd p
+      if !a:keepfocus
+        call feedkeys(winnr."\<C-W>w", 'n')
+      endif
+    endif
+    return post
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+" Section: Gmove, Gremove
+
+function! s:Move(force,destination) abort
+  if a:destination =~# '^/'
+    let destination = a:destination[1:-1]
+  else
+    let destination = s:shellslash(fnamemodify(s:sub(a:destination,'[%#]%(:\w)*','\=expand(submatch(0))'),':p'))
+    if destination[0:strlen(s:repo().tree())] ==# s:repo().tree('')
+      let destination = destination[strlen(s:repo().tree('')):-1]
+    endif
+  endif
+  if isdirectory(s:buffer().spec())
+    " Work around Vim parser idiosyncrasy
+    let discarded = s:buffer().setvar('&swapfile',0)
+  endif
+  let message = call(s:repo().git_chomp_in_tree,['mv']+(a:force ? ['-f'] : [])+['--', s:buffer().path(), destination], s:repo())
+  if v:shell_error
+    let v:errmsg = 'fugitive: '.message
+    return 'echoerr v:errmsg'
+  endif
+  let destination = s:repo().tree(destination)
+  if isdirectory(destination)
+    let destination = fnamemodify(s:sub(destination,'/$','').'/'.expand('%:t'),':.')
+  endif
+  call fugitive#reload_status()
+  if s:buffer().commit() == ''
+    if isdirectory(destination)
+      return 'keepalt edit '.s:fnameescape(destination)
+    else
+      return 'keepalt saveas! '.s:fnameescape(destination)
+    endif
+  else
+    return 'file '.s:fnameescape(s:repo().translate(':0:'.destination))
+  endif
+endfunction
+
+function! s:MoveComplete(A,L,P) abort
+  if a:A =~ '^/'
+    return s:repo().superglob(a:A)
+  else
+    let matches = split(glob(a:A.'*'),"\n")
+    call map(matches,'v:val !~ "/$" && isdirectory(v:val) ? v:val."/" : v:val')
+    return matches
+  endif
+endfunction
+
+function! s:Remove(force) abort
+  if s:buffer().commit() ==# ''
+    let cmd = ['rm']
+  elseif s:buffer().commit() ==# '0'
+    let cmd = ['rm','--cached']
+  else
+    let v:errmsg = 'fugitive: rm not supported here'
+    return 'echoerr v:errmsg'
+  endif
+  if a:force
+    let cmd += ['--force']
+  endif
+  let message = call(s:repo().git_chomp_in_tree,cmd+['--',s:buffer().path()],s:repo())
+  if v:shell_error
+    let v:errmsg = 'fugitive: '.s:sub(message,'error:.*\zs\n\(.*-f.*',' (add ! to force)')
+    return 'echoerr '.string(v:errmsg)
+  else
+    call fugitive#reload_status()
+    return 'edit'.(a:force ? '!' : '')
+  endif
+endfunction
+
+augroup fugitive_remove
+  autocmd!
+  autocmd User Fugitive if s:buffer().commit() =~# '^0\=$' |
+        \ exe "command! -buffer -bar -bang -nargs=1 -complete=customlist,s:MoveComplete Gmove :execute s:Move(<bang>0,<q-args>)" |
+        \ exe "command! -buffer -bar -bang Gremove :execute s:Remove(<bang>0)" |
+        \ endif
+augroup END
+
+" Section: Gblame
+
+augroup fugitive_blame
+  autocmd!
+  autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame
+  autocmd FileType fugitiveblame setlocal nomodeline | if exists('b:git_dir') | let &l:keywordprg = s:repo().keywordprg() | endif
+  autocmd Syntax fugitiveblame call s:BlameSyntax()
+  autocmd User Fugitive if s:buffer().type('file', 'blob') | exe "command! -buffer -bar -bang -range=0 -nargs=* Gblame :execute s:Blame(<bang>0,<line1>,<line2>,<count>,[<f-args>])" | endif
+  autocmd ColorScheme,GUIEnter * call s:RehighlightBlame()
+augroup END
+
+function! s:linechars(pattern) abort
+  let chars = strlen(s:gsub(matchstr(getline('.'), a:pattern), '.', '.'))
+  if exists('*synconcealed') && &conceallevel > 1
+    for col in range(1, chars)
+      let chars -= synconcealed(line('.'), col)[0]
+    endfor
+  endif
+  return chars
+endfunction
+
+function! s:Blame(bang,line1,line2,count,args) abort
+  if exists('b:fugitive_blamed_bufnr')
+    return 'bdelete'
+  endif
+  try
+    if s:buffer().path() == ''
+      call s:throw('file or blob required')
+    endif
+    if filter(copy(a:args),'v:val !~# "^\\%(--root\|--show-name\\|-\\=\\%([ltfnsew]\\|[MC]\\d*\\)\\+\\)$"') != []
+      call s:throw('unsupported option')
+    endif
+    call map(a:args,'s:sub(v:val,"^\\ze[^-]","-")')
+    let cmd = ['--no-pager', 'blame', '--show-number'] + a:args
+    if s:buffer().commit() =~# '\D\|..'
+      let cmd += [s:buffer().commit()]
+    else
+      let cmd += ['--contents', '-']
+    endif
+    let cmd += ['--', s:buffer().path()]
+    let basecmd = escape(call(s:repo().git_command,cmd,s:repo()),'!')
+    try
+      let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+      if !s:repo().bare()
+        let dir = getcwd()
+        execute cd.'`=s:repo().tree()`'
+      endif
+      if a:count
+        execute 'write !'.substitute(basecmd,' blame ',' blame -L '.a:line1.','.a:line2.' ','g')
+      else
+        let error = resolve(tempname())
+        let temp = error.'.fugitiveblame'
+        if &shell =~# 'csh'
+          silent! execute '%write !('.basecmd.' > '.temp.') >& '.error
+        else
+          silent! execute '%write !'.basecmd.' > '.temp.' 2> '.error
+        endif
+        if exists('l:dir')
+          execute cd.'`=dir`'
+          unlet dir
+        endif
+        if v:shell_error
+          call s:throw(join(readfile(error),"\n"))
+        endif
+        for winnr in range(winnr('$'),1,-1)
+          call setwinvar(winnr, '&scrollbind', 0)
+          if exists('+cursorbind')
+            call setwinvar(winnr, '&cursorbind', 0)
+          endif
+          if getbufvar(winbufnr(winnr), 'fugitive_blamed_bufnr')
+            execute winbufnr(winnr).'bdelete'
+          endif
+        endfor
+        let bufnr = bufnr('')
+        let restore = 'call setwinvar(bufwinnr('.bufnr.'),"&scrollbind",0)'
+        if exists('+cursorbind')
+          let restore .= '|call setwinvar(bufwinnr('.bufnr.'),"&cursorbind",0)'
+        endif
+        if &l:wrap
+          let restore .= '|call setwinvar(bufwinnr('.bufnr.'),"&wrap",1)'
+        endif
+        if &l:foldenable
+          let restore .= '|call setwinvar(bufwinnr('.bufnr.'),"&foldenable",1)'
+        endif
+        setlocal scrollbind nowrap nofoldenable
+        if exists('+cursorbind')
+          setlocal cursorbind
+        endif
+        let top = line('w0') + &scrolloff
+        let current = line('.')
+        let s:temp_files[s:cpath(temp)] = { 'dir': s:repo().dir(), 'args': cmd }
+        exe 'keepalt leftabove vsplit '.temp
+        let b:fugitive_blamed_bufnr = bufnr
+        let w:fugitive_leave = restore
+        let b:fugitive_blame_arguments = join(a:args,' ')
+        execute top
+        normal! zt
+        execute current
+        if exists('+cursorbind')
+          setlocal cursorbind
+        endif
+        setlocal nomodified nomodifiable nonumber scrollbind nowrap foldcolumn=0 nofoldenable winfixwidth filetype=fugitiveblame
+        if exists('+concealcursor')
+          setlocal concealcursor=nc conceallevel=2
+        endif
+        if exists('+relativenumber')
+          setlocal norelativenumber
+        endif
+        execute "vertical resize ".(s:linechars('.\{-\}\ze\s\+\d\+)')+1)
+        nnoremap <buffer> <silent> <F1> :help fugitive-:Gblame<CR>
+        nnoremap <buffer> <silent> g?   :help fugitive-:Gblame<CR>
+        nnoremap <buffer> <silent> q    :exe substitute(bufwinnr(b:fugitive_blamed_bufnr).' wincmd w<Bar>'.bufnr('').'bdelete','^-1','','')<CR>
+        nnoremap <buffer> <silent> gq   :exe substitute(bufwinnr(b:fugitive_blamed_bufnr).' wincmd w<Bar>'.bufnr('').'bdelete<Bar>if expand("%:p") =~# "^fugitive:[\\/][\\/]"<Bar>Gedit<Bar>endif','^-1','','')<CR>
+        nnoremap <buffer> <silent> <CR> :<C-U>exe <SID>BlameCommit("exe 'norm q'<Bar>edit")<CR>
+        nnoremap <buffer> <silent> -    :<C-U>exe <SID>BlameJump('')<CR>
+        nnoremap <buffer> <silent> P    :<C-U>exe <SID>BlameJump('^'.v:count1)<CR>
+        nnoremap <buffer> <silent> ~    :<C-U>exe <SID>BlameJump('~'.v:count1)<CR>
+        nnoremap <buffer> <silent> i    :<C-U>exe <SID>BlameCommit("exe 'norm q'<Bar>edit")<CR>
+        nnoremap <buffer> <silent> o    :<C-U>exe <SID>BlameCommit((&splitbelow ? "botright" : "topleft")." split")<CR>
+        nnoremap <buffer> <silent> O    :<C-U>exe <SID>BlameCommit("tabedit")<CR>
+        nnoremap <buffer> <silent> A    :<C-u>exe "vertical resize ".(<SID>linechars('.\{-\}\ze [0-9:/+-][0-9:/+ -]* \d\+)')+1+v:count)<CR>
+        nnoremap <buffer> <silent> C    :<C-u>exe "vertical resize ".(<SID>linechars('^\S\+')+1+v:count)<CR>
+        nnoremap <buffer> <silent> D    :<C-u>exe "vertical resize ".(<SID>linechars('.\{-\}\ze\d\ze\s\+\d\+)')+1-v:count)<CR>
+        redraw
+        syncbind
+      endif
+    finally
+      if exists('l:dir')
+        execute cd.'`=dir`'
+      endif
+    endtry
+    return ''
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+function! s:BlameCommit(cmd) abort
+  let cmd = s:Edit(a:cmd, 0, matchstr(getline('.'),'\x\+'))
+  if cmd =~# '^echoerr'
+    return cmd
+  endif
+  let lnum = matchstr(getline('.'),' \zs\d\+\ze\s\+[([:digit:]]')
+  let path = matchstr(getline('.'),'^\^\=\x\+\s\+\zs.\{-\}\ze\s*\d\+ ')
+  if path ==# ''
+    let path = s:buffer(b:fugitive_blamed_bufnr).path()
+  endif
+  execute cmd
+  if search('^diff .* b/\M'.escape(path,'\').'$','W')
+    call search('^+++')
+    let head = line('.')
+    while search('^@@ \|^diff ') && getline('.') =~# '^@@ '
+      let top = +matchstr(getline('.'),' +\zs\d\+')
+      let len = +matchstr(getline('.'),' +\d\+,\zs\d\+')
+      if lnum >= top && lnum <= top + len
+        let offset = lnum - top
+        if &scrolloff
+          +
+          normal! zt
+        else
+          normal! zt
+          +
+        endif
+        while offset > 0 && line('.') < line('$')
+          +
+          if getline('.') =~# '^[ +]'
+            let offset -= 1
+          endif
+        endwhile
+        return 'normal! zv'
+      endif
+    endwhile
+    execute head
+    normal! zt
+  endif
+  return ''
+endfunction
+
+function! s:BlameJump(suffix) abort
+  let commit = matchstr(getline('.'),'^\^\=\zs\x\+')
+  if commit =~# '^0\+$'
+    let commit = ':0'
+  endif
+  let lnum = matchstr(getline('.'),' \zs\d\+\ze\s\+[([:digit:]]')
+  let path = matchstr(getline('.'),'^\^\=\x\+\s\+\zs.\{-\}\ze\s*\d\+ ')
+  if path ==# ''
+    let path = s:buffer(b:fugitive_blamed_bufnr).path()
+  endif
+  let args = b:fugitive_blame_arguments
+  let offset = line('.') - line('w0')
+  let bufnr = bufnr('%')
+  let winnr = bufwinnr(b:fugitive_blamed_bufnr)
+  if winnr > 0
+    exe winnr.'wincmd w'
+  endif
+  execute s:Edit('edit', 0, commit.a:suffix.':'.path)
+  execute lnum
+  if winnr > 0
+    exe bufnr.'bdelete'
+  endif
+  if exists(':Gblame')
+    execute 'Gblame '.args
+    execute lnum
+    let delta = line('.') - line('w0') - offset
+    if delta > 0
+      execute 'normal! '.delta."\<C-E>"
+    elseif delta < 0
+      execute 'normal! '.(-delta)."\<C-Y>"
+    endif
+    syncbind
+  endif
+  return ''
+endfunction
+
+let s:hash_colors = {}
+
+function! s:BlameSyntax() abort
+  let b:current_syntax = 'fugitiveblame'
+  let conceal = has('conceal') ? ' conceal' : ''
+  let arg = exists('b:fugitive_blame_arguments') ? b:fugitive_blame_arguments : ''
+  syn match FugitiveblameBoundary "^\^"
+  syn match FugitiveblameBlank                      "^\s\+\s\@=" nextgroup=FugitiveblameAnnotation,fugitiveblameOriginalFile,FugitiveblameOriginalLineNumber skipwhite
+  syn match FugitiveblameHash       "\%(^\^\=\)\@<=\x\{7,40\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite
+  syn match FugitiveblameUncommitted "\%(^\^\=\)\@<=0\{7,40\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite
+  syn region FugitiveblameAnnotation matchgroup=FugitiveblameDelimiter start="(" end="\%( \d\+\)\@<=)" contained keepend oneline
+  syn match FugitiveblameTime "[0-9:/+-][0-9:/+ -]*[0-9:/+-]\%( \+\d\+)\)\@=" contained containedin=FugitiveblameAnnotation
+  exec 'syn match FugitiveblameLineNumber         " *\d\+)\@=" contained containedin=FugitiveblameAnnotation'.conceal
+  exec 'syn match FugitiveblameOriginalFile       " \%(\f\+\D\@<=\|\D\@=\f\+\)\%(\%(\s\+\d\+\)\=\s\%((\|\s*\d\+)\)\)\@=" contained nextgroup=FugitiveblameOriginalLineNumber,FugitiveblameAnnotation skipwhite'.(arg =~# 'f' ? '' : conceal)
+  exec 'syn match FugitiveblameOriginalLineNumber " *\d\+\%(\s(\)\@=" contained nextgroup=FugitiveblameAnnotation skipwhite'.(arg =~# 'n' ? '' : conceal)
+  exec 'syn match FugitiveblameOriginalLineNumber " *\d\+\%(\s\+\d\+)\)\@=" contained nextgroup=FugitiveblameShort skipwhite'.(arg =~# 'n' ? '' : conceal)
+  syn match FugitiveblameShort              " \d\+)" contained contains=FugitiveblameLineNumber
+  syn match FugitiveblameNotCommittedYet "(\@<=Not Committed Yet\>" contained containedin=FugitiveblameAnnotation
+  hi def link FugitiveblameBoundary           Keyword
+  hi def link FugitiveblameHash               Identifier
+  hi def link FugitiveblameUncommitted        Ignore
+  hi def link FugitiveblameTime               PreProc
+  hi def link FugitiveblameLineNumber         Number
+  hi def link FugitiveblameOriginalFile       String
+  hi def link FugitiveblameOriginalLineNumber Float
+  hi def link FugitiveblameShort              FugitiveblameDelimiter
+  hi def link FugitiveblameDelimiter          Delimiter
+  hi def link FugitiveblameNotCommittedYet    Comment
+  let seen = {}
+  for lnum in range(1, line('$'))
+    let hash = matchstr(getline(lnum), '^\^\=\zs\x\{6\}')
+    if hash ==# '' || hash ==# '000000' || has_key(seen, hash)
+      continue
+    endif
+    let seen[hash] = 1
+    if &t_Co > 16 && exists('g:CSApprox_loaded')
+          \ && empty(get(s:hash_colors, hash))
+      let [s, r, g, b; __] = map(matchlist(hash, '\(\x\x\)\(\x\x\)\(\x\x\)'), 'str2nr(v:val,16)')
+      let color = csapprox#per_component#Approximate(r, g, b)
+      if color == 16 && &background ==# 'dark'
+        let color = 8
+      endif
+      let s:hash_colors[hash] = ' ctermfg='.color
+    else
+      let s:hash_colors[hash] = ''
+    endif
+    exe 'syn match FugitiveblameHash'.hash.'       "\%(^\^\=\)\@<='.hash.'\x\{1,34\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite'
+  endfor
+  call s:RehighlightBlame()
+endfunction
+
+function! s:RehighlightBlame() abort
+  for [hash, cterm] in items(s:hash_colors)
+    if !empty(cterm) || has('gui_running')
+      exe 'hi FugitiveblameHash'.hash.' guifg=#'.hash.get(s:hash_colors, hash, '')
+    else
+      exe 'hi link FugitiveblameHash'.hash.' Identifier'
+    endif
+  endfor
+endfunction
+
+" Section: Gbrowse
+
+call s:command("-bar -bang -range=0 -nargs=* -complete=customlist,s:EditComplete Gbrowse :execute s:Browse(<bang>0,<line1>,<count>,<f-args>)")
+
+function! s:Browse(bang,line1,count,...) abort
+  try
+    let validremote = '\.\|\.\=/.*\|[[:alnum:]_-]\+\%(://.\{-\}\)\='
+    if a:0
+      let remote = matchstr(join(a:000, ' '),'@\zs\%('.validremote.'\)$')
+      let rev = substitute(join(a:000, ' '),'@\%('.validremote.'\)$','','')
+    else
+      let remote = ''
+      let rev = ''
+    endif
+    if rev ==# ''
+      let expanded = s:buffer().rev()
+    elseif rev ==# ':'
+      let expanded = s:buffer().path('/')
+    else
+      let expanded = s:buffer().expand(rev)
+    endif
+    let full = s:repo().translate(expanded)
+    let commit = ''
+    if full =~# '^fugitive://'
+      let commit = matchstr(full,'://.*//\zs\w\w\+')
+      let path = matchstr(full,'://.*//\w\+\zs/.*')
+      if commit =~ '..'
+        let type = s:repo().git_chomp('cat-file','-t',commit.s:sub(path,'^/',':'))
+        let branch = matchstr(expanded, '^[^:]*')
+      else
+        let type = 'blob'
+      endif
+      let path = path[1:-1]
+    elseif s:repo().bare()
+      let path = '.git/' . full[strlen(s:repo().dir())+1:-1]
+      let type = ''
+    else
+      let path = full[strlen(s:repo().tree())+1:-1]
+      if path =~# '^\.git/'
+        let type = ''
+      elseif isdirectory(full)
+        let type = 'tree'
+      else
+        let type = 'blob'
+      endif
+    endif
+    if type ==# 'tree' && !empty(path)
+      let path = s:sub(path, '/\=$', '/')
+    endif
+    if path =~# '^\.git/.*HEAD' && filereadable(s:repo().dir(path[5:-1]))
+      let body = readfile(s:repo().dir(path[5:-1]))[0]
+      if body =~# '^\x\{40\}$'
+        let commit = body
+        let type = 'commit'
+        let path = ''
+      elseif body =~# '^ref: refs/'
+        let path = '.git/' . matchstr(body,'ref: \zs.*')
+      endif
+    endif
+
+    let merge = ''
+    if path =~# '^\.git/refs/remotes/.'
+      if empty(remote)
+        let remote = matchstr(path, '^\.git/refs/remotes/\zs[^/]\+')
+      endif
+      let merge = matchstr(path, '^\.git/refs/remotes/[^/]\+/\zs.\+')
+      let branch = ''
+      let path = '.git/refs/heads/'.merge
+    elseif path =~# '^\.git/refs/heads/.'
+      let branch = path[16:-1]
+    elseif !exists('branch')
+      let branch = s:repo().head()
+    endif
+    if !empty(branch)
+      let r = s:repo().git_chomp('config','branch.'.branch.'.remote')
+      let m = s:repo().git_chomp('config','branch.'.branch.'.merge')[11:-1]
+      if r ==# '.' && !empty(m)
+        let r2 = s:repo().git_chomp('config','branch.'.m.'.remote')
+        if r2 !~# '^\.\=$'
+          let r = r2
+          let m = s:repo().git_chomp('config','branch.'.m.'.merge')[11:-1]
+        endif
+      endif
+      if empty(remote)
+        let remote = r
+      endif
+      if r ==# '.' || r ==# remote
+        let merge = m
+        if path =~# '^\.git/refs/heads/.'
+          let path = '.git/refs/heads/'.merge
+        endif
+      endif
+    endif
+
+    if empty(commit) && path !~# '^\.git/'
+      if a:line1 && !a:count && !empty(merge)
+        let commit = merge
+      else
+        let commit = s:repo().rev_parse('HEAD')
+      endif
+    endif
+
+    if empty(remote)
+      let remote = '.'
+      let raw = s:repo().git_chomp('config','remote.origin.url')
+    else
+      let raw = s:repo().git_chomp('config','remote.'.remote.'.url')
+    endif
+    if raw ==# ''
+      let raw = remote
+    endif
+
+    for Handler in g:fugitive_browse_handlers
+      let url = call(Handler, [{
+            \ 'repo': s:repo(),
+            \ 'remote': raw,
+            \ 'revision': 'No longer provided',
+            \ 'commit': commit,
+            \ 'path': path,
+            \ 'type': type,
+            \ 'line1': a:count > 0 ? a:line1 : 0,
+            \ 'line2': a:count > 0 ? a:count : 0}])
+      if !empty(url)
+        break
+      endif
+    endfor
+
+    if empty(url) && raw ==# '.'
+      call s:throw("Instaweb failed to start")
+    elseif empty(url)
+      call s:throw('"'.remote."' is not a supported remote")
+    endif
+
+    let url = s:gsub(url, '[ <>]', '\="%".printf("%02X",char2nr(submatch(0)))')
+    if a:bang
+      if has('clipboard')
+        let @+ = url
+      endif
+      return 'echomsg '.string(url)
+    elseif exists(':Browse') == 2
+      return 'echomsg '.string(url).'|Browse '.url
+    else
+      if !exists('g:loaded_netrw')
+        runtime! autoload/netrw.vim
+      endif
+      if exists('*netrw#BrowseX')
+        return 'echomsg '.string(url).'|call netrw#BrowseX('.string(url).', 0)'
+      else
+        return 'echomsg '.string(url).'|call netrw#NetrwBrowseX('.string(url).', 0)'
+      endif
+    endif
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+function! s:github_url(opts, ...) abort
+  if a:0 || type(a:opts) != type({})
+    return ''
+  endif
+  let domain_pattern = 'github\.com'
+  let domains = exists('g:fugitive_github_domains') ? g:fugitive_github_domains : []
+  for domain in domains
+    let domain_pattern .= '\|' . escape(split(domain, '://')[-1], '.')
+  endfor
+  let repo = matchstr(get(a:opts, 'remote'), '^\%(https\=://\|git://\|git@\)\=\zs\('.domain_pattern.'\)[/:].\{-\}\ze\%(\.git\)\=$')
+  if repo ==# ''
+    return ''
+  endif
+  let path = substitute(a:opts.path, '^/', '', '')
+  if index(domains, 'http://' . matchstr(repo, '^[^:/]*')) >= 0
+    let root = 'http://' . s:sub(repo,':','/')
+  else
+    let root = 'https://' . s:sub(repo,':','/')
+  endif
+  if path =~# '^\.git/refs/heads/'
+    let branch = a:opts.repo.git_chomp('config','branch.'.path[16:-1].'.merge')[11:-1]
+    if branch ==# ''
+      return root . '/commits/' . path[16:-1]
+    else
+      return root . '/commits/' . branch
+    endif
+  elseif path =~# '^\.git/refs/tags/'
+    return root . '/releases/tag/' . path[15:-1]
+  elseif path =~# '^\.git/refs/remotes/[^/]\+/.'
+    return root . '/commits/' . matchstr(path,'remotes/[^/]\+/\zs.*')
+  elseif path =~# '.git/\%(config$\|hooks\>\)'
+    return root . '/admin'
+  elseif path =~# '^\.git\>'
+    return root
+  endif
+  if a:opts.commit =~# '^\d\=$'
+    let commit = a:opts.repo.rev_parse('HEAD')
+  else
+    let commit = a:opts.commit
+  endif
+  if get(a:opts, 'type', '') ==# 'tree' || a:opts.path =~# '/$'
+    let url = substitute(root . '/tree/' . commit . '/' . path, '/$', '', 'g')
+  elseif get(a:opts, 'type', '') ==# 'blob' || a:opts.path =~# '[^/]$'
+    let url = root . '/blob/' . commit . '/' . path
+    if get(a:opts, 'line2') && a:opts.line1 == a:opts.line2
+      let url .= '#L' . a:opts.line1
+    elseif get(a:opts, 'line2')
+      let url .= '#L' . a:opts.line1 . '-L' . a:opts.line2
+    endif
+  else
+    let url = root . '/commit/' . commit
+  endif
+  return url
+endfunction
+
+function! s:instaweb_url(opts) abort
+  if a:opts.remote !=# '.'
+    return ''
+  endif
+  let output = a:opts.repo.git_chomp('instaweb','-b','unknown')
+  if output =~# 'http://'
+    let root = matchstr(output,'http://.*').'/?p='.fnamemodify(a:opts.repo.dir(),':t')
+  else
+    return ''
+  endif
+  if a:opts.path =~# '^\.git/refs/.'
+    return root . ';a=shortlog;h=' . matchstr(a:opts.path,'^\.git/\zs.*')
+  elseif a:opts.path =~# '^\.git\>'
+    return root
+  endif
+  let url = root
+  if a:opts.commit =~# '^\x\{40\}$'
+    if a:opts.type ==# 'commit'
+      let url .= ';a=commit'
+    endif
+    let url .= ';h=' . a:opts.repo.rev_parse(a:opts.commit . (a:opts.path == '' ? '' : ':' . a:opts.path))
+  else
+    if a:opts.type ==# 'blob' && empty(a:opts.commit)
+      let url .= ';h='.a:opts.repo.git_chomp('hash-object', '-w', a:opts.path)
+    else
+      try
+        let url .= ';h=' . a:opts.repo.rev_parse((a:opts.commit == '' ? 'HEAD' : ':' . a:opts.commit) . ':' . a:opts.path)
+      catch /^fugitive:/
+        call s:throw('fugitive: cannot browse uncommitted file')
+      endtry
+    endif
+    let root .= ';hb=' . matchstr(a:opts.repo.head_ref(),'[^ ]\+$')
+  endif
+  if a:opts.path !=# ''
+    let url .= ';f=' . a:opts.path
+  endif
+  if get(a:opts, 'line1')
+    let url .= '#l' . a:opts.line1
+  endif
+  return url
+endfunction
+
+if !exists('g:fugitive_browse_handlers')
+  let g:fugitive_browse_handlers = []
+endif
+
+call extend(g:fugitive_browse_handlers,
+      \ [s:function('s:github_url'), s:function('s:instaweb_url')])
+
+" Section: File access
+
+function! s:ReplaceCmd(cmd,...) abort
+  let fn = expand('%:p')
+  let tmp = tempname()
+  let prefix = ''
+  try
+    if a:0 && a:1 != ''
+      if s:winshell()
+        let old_index = $GIT_INDEX_FILE
+        let $GIT_INDEX_FILE = a:1
+      else
+        let prefix = 'env GIT_INDEX_FILE='.s:shellesc(a:1).' '
+      endif
+    endif
+    let redir = ' > '.tmp
+    if &shellpipe =~ '2>&1'
+      let redir .= ' 2>&1'
+    endif
+    if s:winshell()
+      let cmd_escape_char = &shellxquote == '(' ?  '^' : '^^^'
+      call system('cmd /c "'.prefix.s:gsub(a:cmd,'[<>]', cmd_escape_char.'&').redir.'"')
+    elseif &shell =~# 'fish'
+      call system(' begin;'.prefix.a:cmd.redir.';end ')
+    else
+      call system(' ('.prefix.a:cmd.redir.') ')
+    endif
+  finally
+    if exists('old_index')
+      let $GIT_INDEX_FILE = old_index
+    endif
+  endtry
+  silent exe 'keepalt file '.tmp
+  try
+    silent edit!
+  finally
+    try
+      silent exe 'keepalt file '.s:fnameescape(fn)
+    catch /^Vim\%((\a\+)\)\=:E302/
+    endtry
+    call delete(tmp)
+    if fnamemodify(bufname('$'), ':p') ==# tmp
+      silent execute 'bwipeout '.bufnr('$')
+    endif
+    silent exe 'doau BufReadPost '.s:fnameescape(fn)
+  endtry
+endfunction
+
+function! s:BufReadIndex() abort
+  if !exists('b:fugitive_display_format')
+    let b:fugitive_display_format = filereadable(expand('%').'.lock')
+  endif
+  let b:fugitive_display_format = b:fugitive_display_format % 2
+  let b:fugitive_type = 'index'
+  try
+    let b:git_dir = s:repo().dir()
+    setlocal noro ma nomodeline
+    if fnamemodify($GIT_INDEX_FILE !=# '' ? $GIT_INDEX_FILE : b:git_dir . '/index', ':p') ==# expand('%:p')
+      let index = ''
+    else
+      let index = expand('%:p')
+    endif
+    if b:fugitive_display_format
+      call s:ReplaceCmd(s:repo().git_command('ls-files','--stage'),index)
+      set ft=git nospell
+    else
+      let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+      let dir = getcwd()
+      if fugitive#git_version() =~# '^0\|^1\.[1-7]\.'
+        let cmd = s:repo().git_command('status')
+      else
+        let cmd = s:repo().git_command(
+              \ '-c', 'status.displayCommentPrefix=true',
+              \ '-c', 'color.status=false',
+              \ '-c', 'status.short=false',
+              \ 'status')
+      endif
+      try
+        execute cd.'`=s:repo().tree()`'
+        call s:ReplaceCmd(cmd, index)
+      finally
+        execute cd.'`=dir`'
+      endtry
+      set ft=gitcommit
+      set foldtext=fugitive#foldtext()
+    endif
+    setlocal ro noma nomod noswapfile
+    if &bufhidden ==# ''
+      setlocal bufhidden=delete
+    endif
+    call s:JumpInit()
+    nunmap   <buffer>          P
+    nunmap   <buffer>          ~
+    nnoremap <buffer> <silent> <C-N> :<C-U>execute <SID>StageNext(v:count1)<CR>
+    nnoremap <buffer> <silent> <C-P> :<C-U>execute <SID>StagePrevious(v:count1)<CR>
+    nnoremap <buffer> <silent> - :<C-U>silent execute <SID>StageToggle(line('.'),line('.')+v:count1-1)<CR>
+    xnoremap <buffer> <silent> - :<C-U>silent execute <SID>StageToggle(line("'<"),line("'>"))<CR>
+    nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += 1<Bar>exe <SID>BufReadIndex()<CR>
+    nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= 1<Bar>exe <SID>BufReadIndex()<CR>
+    nnoremap <buffer> <silent> C :<C-U>Gcommit<CR>
+    nnoremap <buffer> <silent> cA :<C-U>Gcommit --amend --reuse-message=HEAD<CR>
+    nnoremap <buffer> <silent> ca :<C-U>Gcommit --amend<CR>
+    nnoremap <buffer> <silent> cc :<C-U>Gcommit<CR>
+    nnoremap <buffer> <silent> cva :<C-U>Gcommit --amend --verbose<CR>
+    nnoremap <buffer> <silent> cvc :<C-U>Gcommit --verbose<CR>
+    nnoremap <buffer> <silent> D :<C-U>execute <SID>StageDiff('Gdiff')<CR>
+    nnoremap <buffer> <silent> dd :<C-U>execute <SID>StageDiff('Gdiff')<CR>
+    nnoremap <buffer> <silent> dh :<C-U>execute <SID>StageDiff('Gsdiff')<CR>
+    nnoremap <buffer> <silent> ds :<C-U>execute <SID>StageDiff('Gsdiff')<CR>
+    nnoremap <buffer> <silent> dp :<C-U>execute <SID>StageDiffEdit()<CR>
+    nnoremap <buffer> <silent> dv :<C-U>execute <SID>StageDiff('Gvdiff')<CR>
+    nnoremap <buffer> <silent> p :<C-U>execute <SID>StagePatch(line('.'),line('.')+v:count1-1)<CR>
+    xnoremap <buffer> <silent> p :<C-U>execute <SID>StagePatch(line("'<"),line("'>"))<CR>
+    nnoremap <buffer> <silent> P :<C-U>execute <SID>StagePatch(line('.'),line('.')+v:count1-1)<CR>
+    xnoremap <buffer> <silent> P :<C-U>execute <SID>StagePatch(line("'<"),line("'>"))<CR>
+    nnoremap <buffer> <silent> q :<C-U>if bufnr('$') == 1<Bar>quit<Bar>else<Bar>bdelete<Bar>endif<CR>
+    nnoremap <buffer> <silent> r :<C-U>edit<CR>
+    nnoremap <buffer> <silent> R :<C-U>edit<CR>
+    nnoremap <buffer> <silent> U :<C-U>execute <SID>StageUndo()<CR>
+    nnoremap <buffer> <silent> g?   :help fugitive-:Gstatus<CR>
+    nnoremap <buffer> <silent> <F1> :help fugitive-:Gstatus<CR>
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+function! s:FileRead() abort
+  try
+    let repo = s:repo(fugitive#extract_git_dir(expand('<amatch>')))
+    let path = s:sub(s:sub(matchstr(expand('<amatch>'),'fugitive://.\{-\}//\zs.*'),'/',':'),'^\d:',':&')
+    let hash = repo.rev_parse(path)
+    if path =~ '^:'
+      let type = 'blob'
+    else
+      let type = repo.git_chomp('cat-file','-t',hash)
+    endif
+    " TODO: use count, if possible
+    return "read !".escape(repo.git_command('cat-file',type,hash),'%#\')
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+function! s:BufReadIndexFile() abort
+  try
+    let b:fugitive_type = 'blob'
+    let b:git_dir = s:repo().dir()
+    try
+      call s:ReplaceCmd(s:repo().git_command('cat-file','blob',s:buffer().sha1()))
+    finally
+      if &bufhidden ==# ''
+        setlocal bufhidden=delete
+      endif
+      setlocal noswapfile
+    endtry
+    return ''
+  catch /^fugitive: rev-parse/
+    silent exe 'doau BufNewFile '.s:fnameescape(expand('%:p'))
+    return ''
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+function! s:BufWriteIndexFile() abort
+  let tmp = tempname()
+  try
+    let path = matchstr(expand('<amatch>'),'//\d/\zs.*')
+    let stage = matchstr(expand('<amatch>'),'//\zs\d')
+    silent execute 'write !'.s:repo().git_command('hash-object','-w','--stdin').' > '.tmp
+    let sha1 = readfile(tmp)[0]
+    let old_mode = matchstr(s:repo().git_chomp('ls-files','--stage',path),'^\d\+')
+    if old_mode == ''
+      let old_mode = executable(s:repo().tree(path)) ? '100755' : '100644'
+    endif
+    let info = old_mode.' '.sha1.' '.stage."\t".path
+    call writefile([info],tmp)
+    if s:winshell()
+      let error = system('type '.s:gsub(tmp,'/','\\').'|'.s:repo().git_command('update-index','--index-info'))
+    else
+      let error = system(s:repo().git_command('update-index','--index-info').' < '.tmp)
+    endif
+    if v:shell_error == 0
+      setlocal nomodified
+      if exists('#BufWritePost')
+        execute 'doautocmd BufWritePost '.s:fnameescape(expand('%:p'))
+      endif
+      call fugitive#reload_status()
+      return ''
+    else
+      return 'echoerr '.string('fugitive: '.error)
+    endif
+  finally
+    call delete(tmp)
+  endtry
+endfunction
+
+function! s:BufReadObject() abort
+  try
+    setlocal noro ma
+    let b:git_dir = s:repo().dir()
+    let hash = s:buffer().sha1()
+    if !exists("b:fugitive_type")
+      let b:fugitive_type = s:repo().git_chomp('cat-file','-t',hash)
+    endif
+    if b:fugitive_type !~# '^\%(tag\|commit\|tree\|blob\)$'
+      return "echoerr 'fugitive: unrecognized git type'"
+    endif
+    let firstline = getline('.')
+    if !exists('b:fugitive_display_format') && b:fugitive_type != 'blob'
+      let b:fugitive_display_format = +getbufvar('#','fugitive_display_format')
+    endif
+
+    if b:fugitive_type !=# 'blob'
+      setlocal nomodeline
+    endif
+
+    let pos = getpos('.')
+    silent keepjumps %delete_
+    setlocal endofline
+
+    try
+      if b:fugitive_type ==# 'tree'
+        let b:fugitive_display_format = b:fugitive_display_format % 2
+        if b:fugitive_display_format
+          call s:ReplaceCmd(s:repo().git_command('ls-tree',hash))
+        else
+          call s:ReplaceCmd(s:repo().git_command('show','--no-color',hash))
+        endif
+      elseif b:fugitive_type ==# 'tag'
+        let b:fugitive_display_format = b:fugitive_display_format % 2
+        if b:fugitive_display_format
+          call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
+        else
+          call s:ReplaceCmd(s:repo().git_command('cat-file','-p',hash))
+        endif
+      elseif b:fugitive_type ==# 'commit'
+        let b:fugitive_display_format = b:fugitive_display_format % 2
+        if b:fugitive_display_format
+          call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
+        else
+          call s:ReplaceCmd(s:repo().git_command('show','--no-color','--pretty=format:tree%x20%T%nparent%x20%P%nauthor%x20%an%x20<%ae>%x20%ad%ncommitter%x20%cn%x20<%ce>%x20%cd%nencoding%x20%e%n%n%s%n%n%b',hash))
+          keepjumps call search('^parent ')
+          if getline('.') ==# 'parent '
+            silent keepjumps delete_
+          else
+            silent keepjumps s/\%(^parent\)\@<! /\rparent /ge
+          endif
+          keepjumps let lnum = search('^encoding \%(<unknown>\)\=$','W',line('.')+3)
+          if lnum
+            silent keepjumps delete_
+          end
+          keepjumps 1
+        endif
+      elseif b:fugitive_type ==# 'blob'
+        call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
+        setlocal nomodeline
+      endif
+    finally
+      keepjumps call setpos('.',pos)
+      setlocal ro noma nomod noswapfile
+      if &bufhidden ==# ''
+        setlocal bufhidden=delete
+      endif
+      if b:fugitive_type !=# 'blob'
+        setlocal filetype=git foldmethod=syntax
+        nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += v:count1<Bar>exe <SID>BufReadObject()<CR>
+        nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= v:count1<Bar>exe <SID>BufReadObject()<CR>
+      else
+        call s:JumpInit()
+      endif
+    endtry
+
+    return ''
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+endfunction
+
+augroup fugitive_files
+  autocmd!
+  autocmd BufReadCmd  index{,.lock}
+        \ if fugitive#is_git_dir(expand('<amatch>:p:h')) |
+        \   exe s:BufReadIndex() |
+        \ elseif filereadable(expand('<amatch>')) |
+        \   read <amatch> |
+        \   1delete |
+        \ endif
+  autocmd FileReadCmd fugitive://**//[0-3]/**          exe s:FileRead()
+  autocmd BufReadCmd  fugitive://**//[0-3]/**          exe s:BufReadIndexFile()
+  autocmd BufWriteCmd fugitive://**//[0-3]/**          exe s:BufWriteIndexFile()
+  autocmd BufReadCmd  fugitive://**//[0-9a-f][0-9a-f]* exe s:BufReadObject()
+  autocmd FileReadCmd fugitive://**//[0-9a-f][0-9a-f]* exe s:FileRead()
+  autocmd FileType git
+        \ if exists('b:git_dir') |
+        \  call s:JumpInit() |
+        \ endif
+  autocmd FileType git,gitcommit,gitrebase
+        \ if exists('b:git_dir') |
+        \   call s:GFInit() |
+        \ endif
+augroup END
+
+" Section: Temp files
+
+if !exists('s:temp_files')
+  let s:temp_files = {}
+endif
+
+augroup fugitive_temp
+  autocmd!
+  autocmd BufNewFile,BufReadPost *
+        \ if has_key(s:temp_files,s:cpath(expand('<afile>:p'))) |
+        \   let b:git_dir = s:temp_files[s:cpath(expand('<afile>:p'))].dir |
+        \   let b:git_type = 'temp' |
+        \   let b:git_args = s:temp_files[s:cpath(expand('<afile>:p'))].args |
+        \   call fugitive#detect(expand('<afile>:p')) |
+        \   setlocal bufhidden=delete nobuflisted |
+        \   nnoremap <buffer> <silent> q    :<C-U>bdelete<CR>|
+        \ endif
+augroup END
+
+" Section: Go to file
+
+nnoremap <SID>: :<C-U><C-R>=v:count ? v:count : ''<CR>
+function! s:GFInit(...) abort
+  cnoremap <buffer> <expr> <Plug><cfile> fugitive#cfile()
+  if !exists('g:fugitive_no_maps') && empty(mapcheck('gf', 'n'))
+    nmap <buffer> <silent> gf          <SID>:find <Plug><cfile><CR>
+    nmap <buffer> <silent> <C-W>f     <SID>:sfind <Plug><cfile><CR>
+    nmap <buffer> <silent> <C-W><C-F> <SID>:sfind <Plug><cfile><CR>
+    nmap <buffer> <silent> <C-W>gf  <SID>:tabfind <Plug><cfile><CR>
+  endif
+endfunction
+
+function! s:JumpInit(...) abort
+  nnoremap <buffer> <silent> <CR>    :<C-U>exe <SID>GF("edit")<CR>
+  if !&modifiable
+    nnoremap <buffer> <silent> o     :<C-U>exe <SID>GF("split")<CR>
+    nnoremap <buffer> <silent> S     :<C-U>exe <SID>GF("vsplit")<CR>
+    nnoremap <buffer> <silent> O     :<C-U>exe <SID>GF("tabedit")<CR>
+    nnoremap <buffer> <silent> -     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().up(v:count1))<Bar> if fugitive#buffer().type('tree')<Bar>call search('^'.escape(expand('#:t'),'.*[]~\').'/\=$','wc')<Bar>endif<CR>
+    nnoremap <buffer> <silent> P     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().commit().'^'.v:count1.<SID>buffer().path(':'))<CR>
+    nnoremap <buffer> <silent> ~     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().commit().'~'.v:count1.<SID>buffer().path(':'))<CR>
+    nnoremap <buffer> <silent> C     :<C-U>exe <SID>Edit('edit',0,<SID>buffer().containing_commit())<CR>
+    nnoremap <buffer> <silent> cc    :<C-U>exe <SID>Edit('edit',0,<SID>buffer().containing_commit())<CR>
+    nnoremap <buffer> <silent> co    :<C-U>exe <SID>Edit('split',0,<SID>buffer().containing_commit())<CR>
+    nnoremap <buffer> <silent> cS    :<C-U>exe <SID>Edit('vsplit',0,<SID>buffer().containing_commit())<CR>
+    nnoremap <buffer> <silent> cO    :<C-U>exe <SID>Edit('tabedit',0,<SID>buffer().containing_commit())<CR>
+    nnoremap <buffer> <silent> cP    :<C-U>exe <SID>Edit('pedit',0,<SID>buffer().containing_commit())<CR>
+    nnoremap <buffer>          .     : <C-R>=fnameescape(<SID>recall())<CR><Home>
+  endif
+endfunction
+
+function! s:cfile() abort
+  try
+    let buffer = s:buffer()
+    let myhash = buffer.sha1()
+    if myhash ==# '' && getline(1) =~# '^\%(commit\|tag\) \w'
+      let myhash = matchstr(getline(1),'^\w\+ \zs\S\+')
+    endif
+
+    if buffer.type('tree')
+      let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
+      if showtree && line('.') > 2
+        return [buffer.commit().':'.s:buffer().path().(buffer.path() =~# '^$\|/$' ? '' : '/').s:sub(getline('.'),'/$','')]
+      elseif getline('.') =~# '^\d\{6\} \l\{3,8\} \x\{40\}\t'
+        return [buffer.commit().':'.s:buffer().path().(buffer.path() =~# '^$\|/$' ? '' : '/').s:sub(matchstr(getline('.'),'\t\zs.*'),'/$','')]
+      endif
+
+    elseif buffer.type('blob')
+      let ref = expand("<cfile>")
+      try
+        let sha1 = buffer.repo().rev_parse(ref)
+      catch /^fugitive:/
+      endtry
+      if exists('sha1')
+        return [ref]
+      endif
+
+    else
+
+      let dcmds = []
+
+      " Index
+      if getline('.') =~# '^\d\{6\} \x\{40\} \d\t'
+        let ref = matchstr(getline('.'),'\x\{40\}')
+        let file = ':'.s:sub(matchstr(getline('.'),'\d\t.*'),'\t',':')
+        return [file]
+
+      elseif getline('.') =~# '^#\trenamed:.* -> '
+        let file = '/'.matchstr(getline('.'),' -> \zs.*')
+        return [file]
+      elseif getline('.') =~# '^#\t\(\k\| \)\+\p\?: *.'
+        let file = '/'.matchstr(getline('.'),': *\zs.\{-\}\ze\%( ([^()[:digit:]]\+)\)\=$')
+        return [file]
+      elseif getline('.') =~# '^#\t.'
+        let file = '/'.matchstr(getline('.'),'#\t\zs.*')
+        return [file]
+      elseif getline('.') =~# ': needs merge$'
+        let file = '/'.matchstr(getline('.'),'.*\ze: needs merge$')
+        return [file, 'Gdiff!']
+
+      elseif getline('.') ==# '# Not currently on any branch.'
+        return ['HEAD']
+      elseif getline('.') =~# '^# On branch '
+        let file = 'refs/heads/'.getline('.')[12:]
+        return [file]
+      elseif getline('.') =~# "^# Your branch .*'"
+        let file = matchstr(getline('.'),"'\\zs\\S\\+\\ze'")
+        return [file]
+      endif
+
+      let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
+
+      if getline('.') =~# '^ref: '
+        let ref = strpart(getline('.'),5)
+
+      elseif getline('.') =~# '^commit \x\{40\}\>'
+        let ref = matchstr(getline('.'),'\x\{40\}')
+        return [ref]
+
+      elseif getline('.') =~# '^parent \x\{40\}\>'
+        let ref = matchstr(getline('.'),'\x\{40\}')
+        let line = line('.')
+        let parent = 0
+        while getline(line) =~# '^parent '
+          let parent += 1
+          let line -= 1
+        endwhile
+        return [ref]
+
+      elseif getline('.') =~ '^tree \x\{40\}$'
+        let ref = matchstr(getline('.'),'\x\{40\}')
+        if s:repo().rev_parse(myhash.':') == ref
+          let ref = myhash.':'
+        endif
+        return [ref]
+
+      elseif getline('.') =~# '^object \x\{40\}$' && getline(line('.')+1) =~ '^type \%(commit\|tree\|blob\)$'
+        let ref = matchstr(getline('.'),'\x\{40\}')
+        let type = matchstr(getline(line('.')+1),'type \zs.*')
+
+      elseif getline('.') =~# '^\l\{3,8\} '.myhash.'$'
+        let ref = buffer.rev()
+
+      elseif getline('.') =~# '^\l\{3,8\} \x\{40\}\>'
+        let ref = matchstr(getline('.'),'\x\{40\}')
+        echoerr "warning: unknown context ".matchstr(getline('.'),'^\l*')
+
+      elseif getline('.') =~# '^[+-]\{3\} [ab/]'
+        let ref = getline('.')[4:]
+
+      elseif getline('.') =~# '^[+-]' && search('^@@ -\d\+,\d\+ +\d\+,','bnW')
+        let type = getline('.')[0]
+        let lnum = line('.') - 1
+        let offset = 0
+        while getline(lnum) !~# '^@@ -\d\+,\d\+ +\d\+,'
+          if getline(lnum) =~# '^[ '.type.']'
+            let offset += 1
+          endif
+          let lnum -= 1
+        endwhile
+        let offset += matchstr(getline(lnum), type.'\zs\d\+')
+        let ref = getline(search('^'.type.'\{3\} [ab]/','bnW'))[4:-1]
+        let dcmds = [offset, 'normal!zv']
+
+      elseif getline('.') =~# '^rename from '
+        let ref = 'a/'.getline('.')[12:]
+      elseif getline('.') =~# '^rename to '
+        let ref = 'b/'.getline('.')[10:]
+
+      elseif getline('.') =~# '^@@ -\d\+,\d\+ +\d\+,'
+        let diff = getline(search('^diff --git \%(a/.*\|/dev/null\) \%(b/.*\|/dev/null\)', 'bcnW'))
+        let offset = matchstr(getline('.'), '+\zs\d\+')
+
+        let dref = matchstr(diff, '\Cdiff --git \zs\%(a/.*\|/dev/null\)\ze \%(b/.*\|/dev/null\)')
+        let ref = matchstr(diff, '\Cdiff --git \%(a/.*\|/dev/null\) \zs\%(b/.*\|/dev/null\)')
+        let dcmd = 'Gdiff! +'.offset
+
+      elseif getline('.') =~# '^diff --git \%(a/.*\|/dev/null\) \%(b/.*\|/dev/null\)'
+        let dref = matchstr(getline('.'),'\Cdiff --git \zs\%(a/.*\|/dev/null\)\ze \%(b/.*\|/dev/null\)')
+        let ref = matchstr(getline('.'),'\Cdiff --git \%(a/.*\|/dev/null\) \zs\%(b/.*\|/dev/null\)')
+        let dcmd = 'Gdiff!'
+
+      elseif getline('.') =~# '^index ' && getline(line('.')-1) =~# '^diff --git \%(a/.*\|/dev/null\) \%(b/.*\|/dev/null\)'
+        let line = getline(line('.')-1)
+        let dref = matchstr(line,'\Cdiff --git \zs\%(a/.*\|/dev/null\)\ze \%(b/.*\|/dev/null\)')
+        let ref = matchstr(line,'\Cdiff --git \%(a/.*\|/dev/null\) \zs\%(b/.*\|/dev/null\)')
+        let dcmd = 'Gdiff!'
+
+      elseif line('$') == 1 && getline('.') =~ '^\x\{40\}$'
+        let ref = getline('.')
+
+      elseif expand('<cword>') =~# '^\x\{7,40\}\>'
+        return [expand('<cword>')]
+
+      else
+        let ref = ''
+      endif
+
+      if myhash ==# ''
+        let ref = s:sub(ref,'^a/','HEAD:')
+        let ref = s:sub(ref,'^b/',':0:')
+        if exists('dref')
+          let dref = s:sub(dref,'^a/','HEAD:')
+        endif
+      else
+        let ref = s:sub(ref,'^a/',myhash.'^:')
+        let ref = s:sub(ref,'^b/',myhash.':')
+        if exists('dref')
+          let dref = s:sub(dref,'^a/',myhash.'^:')
+        endif
+      endif
+
+      if ref ==# '/dev/null'
+        " Empty blob
+        let ref = 'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391'
+      endif
+
+      if exists('dref')
+        return [ref, dcmd . ' ' . s:fnameescape(dref)] + dcmds
+      elseif ref != ""
+        return [ref] + dcmds
+      endif
+
+    endif
+    return []
+  endtry
+endfunction
+
+function! s:GF(mode) abort
+  try
+    let results = s:cfile()
+  catch /^fugitive:/
+    return 'echoerr v:errmsg'
+  endtry
+  if len(results)
+    return s:Edit(a:mode, 0, results[0]).join(map(results[1:-1], '"|".v:val'), '')
+  else
+    return ''
+  endif
+endfunction
+
+function! fugitive#cfile() abort
+  let pre = ''
+  let results = s:cfile()
+  if empty(results)
+    let cfile = expand('<cfile>')
+    if &includeexpr =~# '\<v:fname\>'
+      sandbox let cfile = eval(substitute(&includeexpr, '\C\<v:fname\>', '\=string(cfile)', 'g'))
+    endif
+    return cfile
+  elseif len(results) > 1
+    let pre = '+' . join(map(results[1:-1], 'escape(v:val, " ")'), '\|') . ' '
+  endif
+  return pre . s:fnameescape(fugitive#repo().translate(results[0]))
+endfunction
+
+" Section: Statusline
+
+function! s:repo_head_ref() dict abort
+  if !filereadable(self.dir('HEAD'))
+    return ''
+  endif
+  return readfile(self.dir('HEAD'))[0]
+endfunction
+
+call s:add_methods('repo',['head_ref'])
+
+function! fugitive#statusline(...) abort
+  if !exists('b:git_dir')
+    return ''
+  endif
+  let status = ''
+  if s:buffer().commit() != ''
+    let status .= ':' . s:buffer().commit()[0:7]
+  endif
+  let status .= '('.fugitive#head(7).')'
+  if &statusline =~# '%[MRHWY]' && &statusline !~# '%[mrhwy]'
+    return ',GIT'.status
+  else
+    return '[Git'.status.']'
+  endif
+endfunction
+
+function! fugitive#head(...) abort
+  if !exists('b:git_dir')
+    return ''
+  endif
+
+  return s:repo().head(a:0 ? a:1 : 0)
+endfunction
+
+augroup fugitive_statusline
+  autocmd!
+  autocmd User Flags call Hoist('buffer', function('fugitive#statusline'))
+augroup END
+
+" Section: Folding
+
+function! fugitive#foldtext() abort
+  if &foldmethod !=# 'syntax'
+    return foldtext()
+  elseif getline(v:foldstart) =~# '^diff '
+    let [add, remove] = [-1, -1]
+    let filename = ''
+    for lnum in range(v:foldstart, v:foldend)
+      if filename ==# '' && getline(lnum) =~# '^[+-]\{3\} [abciow12]/'
+        let filename = getline(lnum)[6:-1]
+      endif
+      if getline(lnum) =~# '^+'
+        let add += 1
+      elseif getline(lnum) =~# '^-'
+        let remove += 1
+      elseif getline(lnum) =~# '^Binary '
+        let binary = 1
+      endif
+    endfor
+    if filename ==# ''
+      let filename = matchstr(getline(v:foldstart), '^diff .\{-\} a/\zs.*\ze b/')
+    endif
+    if filename ==# ''
+      let filename = getline(v:foldstart)[5:-1]
+    endif
+    if exists('binary')
+      return 'Binary: '.filename
+    else
+      return (add<10&&remove<100?' ':'') . add . '+ ' . (remove<10&&add<100?' ':'') . remove . '- ' . filename
+    endif
+  elseif getline(v:foldstart) =~# '^# .*:$'
+    let lines = getline(v:foldstart, v:foldend)
+    call filter(lines, 'v:val =~# "^#\t"')
+    cal map(lines,'s:sub(v:val, "^#\t%(modified: +|renamed: +)=", "")')
+    cal map(lines,'s:sub(v:val, "^([[:alpha:] ]+): +(.*)", "\\2 (\\1)")')
+    return getline(v:foldstart).' '.join(lines, ', ')
+  endif
+  return foldtext()
+endfunction
+
+augroup fugitive_foldtext
+  autocmd!
+  autocmd User Fugitive
+        \ if &filetype =~# '^git\%(commit\)\=$' && &foldtext ==# 'foldtext()' |
+        \    set foldtext=fugitive#foldtext() |
+        \ endif
+augroup END
diff --git a/vim/.vim/bundle/pathogen/CONTRIBUTING.markdown b/vim/.vim/bundle/pathogen/CONTRIBUTING.markdown
new file mode 100644
index 0000000..f5a62ca
--- /dev/null
+++ b/vim/.vim/bundle/pathogen/CONTRIBUTING.markdown
@@ -0,0 +1,14 @@
+If your [commit message sucks](http://stopwritingramblingcommitmessages.com/),
+I'm not going to accept your pull request.  I've explained very politely
+dozens of times that
+[my general guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+are absolute rules on my own repositories, so I may lack the energy to
+explain it to you yet another time.  And please, if I ask you to change
+something, `git commit --amend`.
+
+Beyond that, don't be shy about asking before patching.  What takes you
+hours might take me minutes simply because I have both domain knowledge
+and a perverse knowledge of Vim script so vast that many would consider
+it a symptom of mental illness.  On the flip side, some ideas I'll
+reject no matter how good the implementation is.  "Send a patch" is an
+edge case answer in my book.
diff --git a/vim/.vim/bundle/pathogen/README.markdown b/vim/.vim/bundle/pathogen/README.markdown
new file mode 100644
index 0000000..00c2878
--- /dev/null
+++ b/vim/.vim/bundle/pathogen/README.markdown
@@ -0,0 +1,141 @@
+# pathogen.vim
+
+Manage your `'runtimepath'` with ease.  In practical terms, pathogen.vim
+makes it super easy to install plugins and runtime files in their own
+private directories.
+
+## Installation
+
+Install to `~/.vim/autoload/pathogen.vim`.  Or copy and paste:
+
+    mkdir -p ~/.vim/autoload ~/.vim/bundle && \
+    curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
+
+If you're using Windows, change all occurrences of `~/.vim` to `~\vimfiles`.
+
+## Runtime Path Manipulation
+
+Add this to your vimrc:
+
+    execute pathogen#infect()
+
+If you're brand new to Vim and lacking a vimrc, `vim ~/.vimrc` and paste
+in the following super-minimal example:
+
+    execute pathogen#infect()
+    syntax on
+    filetype plugin indent on
+
+Now any plugins you wish to install can be extracted to a subdirectory
+under `~/.vim/bundle`, and they will be added to the `'runtimepath'`.
+Observe:
+
+    cd ~/.vim/bundle && \
+    git clone git://github.com/tpope/vim-sensible.git
+
+Now [sensible.vim](https://github.com/tpope/vim-sensible) is installed.
+If you really want to get crazy, you could set it up as a submodule in
+whatever repository you keep your dot files in.  I don't like to get
+crazy.
+
+If you don't like the directory name `bundle`, you can pass a runtime relative
+glob as an argument:
+
+    execute pathogen#infect('stuff/{}')
+
+The `{}` indicates where the expansion should occur.
+
+You can also pass an absolute path instead.  I keep the plugins I maintain under `~/src`, and this is how I add them:
+
+    execute pathogen#infect('bundle/{}', '~/src/vim/bundle/{}')
+
+Normally to generate documentation, Vim expects you to run `:helptags`
+on each directory with documentation (e.g., `:helptags ~/.vim/doc`).
+Provided with pathogen.vim is a `:Helptags` command that does this on
+every directory in your `'runtimepath'`.  If you really want to get
+crazy, you could even invoke `Helptags` in your vimrc.  I don't like to
+get crazy.
+
+Finally, pathogen.vim has a rich API that can manipulate `'runtimepath'`
+and other comma-delimited path options in ways most people will never
+need to do.  If you're one of those edge cases, look at the source.
+It's well documented.
+
+## Runtime File Editing
+
+`:Vopen`, `:Vedit`, `:Vsplit`, `:Vvsplit`, `:Vtabedit`, `:Vpedit`, and
+`:Vread` have all moved to [scriptease.vim][].
+
+[scriptease.vim]: https://github.com/tpope/vim-scriptease
+
+## FAQ
+
+> Can I put pathogen.vim in a submodule like all my other plugins?
+
+Sure, stick it under `~/.vim/bundle`, and prepend the following to your
+vimrc:
+
+    runtime bundle/vim-pathogen/autoload/pathogen.vim
+
+Or if your bundles are somewhere other than `~/.vim` (say, `~/src/vim`):
+
+    source ~/src/vim/bundle/vim-pathogen/autoload/pathogen.vim
+
+> Will you accept these 14 pull requests adding a `.gitignore` for
+> `tags` so I don't see untracked changes in my dot files repository?
+
+No, but I'll teach you how to ignore `tags` globally:
+
+    git config --global core.excludesfile '~/.cvsignore'
+    echo tags >> ~/.cvsignore
+
+While any filename will work, I've chosen to follow the ancient
+tradition of `.cvsignore` because utilities like rsync use it, too.
+Clever, huh?
+
+> What about Vimballs?
+
+If you really must use one:
+
+    :e name.vba
+    :!mkdir ~/.vim/bundle/name
+    :UseVimball ~/.vim/bundle/name
+
+> Why don't my plugins load when I use Vim sessions?
+
+Vim sessions default to capturing all global options, which includes the
+`'runtimepath'` that pathogen.vim manipulates.  This can cause other problems
+too, so I recommend turning that behavior off:
+
+    set sessionoptions-=options
+
+## Contributing
+
+If your [commit message sucks](http://stopwritingramblingcommitmessages.com/),
+I'm not going to accept your pull request.  I've explained very politely
+dozens of times that
+[my general guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+are absolute rules on my own repositories, so I may lack the energy to
+explain it to you yet another time.  And please, if I ask you to change
+something, `git commit --amend`.
+
+Beyond that, don't be shy about asking before patching.  What takes you
+hours might take me minutes simply because I have both domain knowledge
+and a perverse knowledge of Vim script so vast that many would consider
+it a symptom of mental illness.  On the flip side, some ideas I'll
+reject no matter how good the implementation is.  "Send a patch" is an
+edge case answer in my book.
+
+## Self-Promotion
+
+Like pathogen.vim?  Follow the repository on
+[GitHub](https://github.com/tpope/vim-pathogen) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=2332).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/pathogen/autoload/pathogen.vim b/vim/.vim/bundle/pathogen/autoload/pathogen.vim
new file mode 100644
index 0000000..59a75c1
--- /dev/null
+++ b/vim/.vim/bundle/pathogen/autoload/pathogen.vim
@@ -0,0 +1,353 @@
+" pathogen.vim - path option manipulation
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      2.4
+
+" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
+"
+" For management of individually installed plugins in ~/.vim/bundle (or
+" ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
+" .vimrc is the only other setup necessary.
+"
+" The API is documented inline below.
+
+if exists("g:loaded_pathogen") || &cp
+  finish
+endif
+let g:loaded_pathogen = 1
+
+" Point of entry for basic default usage.  Give a relative path to invoke
+" pathogen#interpose() (defaults to "bundle/{}"), or an absolute path to invoke
+" pathogen#surround().  Curly braces are expanded with pathogen#expand():
+" "bundle/{}" finds all subdirectories inside "bundle" inside all directories
+" in the runtime path.
+function! pathogen#infect(...) abort
+  for path in a:0 ? filter(reverse(copy(a:000)), 'type(v:val) == type("")') : ['bundle/{}']
+    if path =~# '^\%({\=[$~\\/]\|{\=\w:[\\/]\).*[{}*]'
+      call pathogen#surround(path)
+    elseif path =~# '^\%([$~\\/]\|\w:[\\/]\)'
+      call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
+      call pathogen#surround(path . '/{}')
+    elseif path =~# '[{}*]'
+      call pathogen#interpose(path)
+    else
+      call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
+      call pathogen#interpose(path . '/{}')
+    endif
+  endfor
+  call pathogen#cycle_filetype()
+  if pathogen#is_disabled($MYVIMRC)
+    return 'finish'
+  endif
+  return ''
+endfunction
+
+" Split a path into a list.
+function! pathogen#split(path) abort
+  if type(a:path) == type([]) | return a:path | endif
+  if empty(a:path) | return [] | endif
+  let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
+  return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
+endfunction
+
+" Convert a list to a path.
+function! pathogen#join(...) abort
+  if type(a:1) == type(1) && a:1
+    let i = 1
+    let space = ' '
+  else
+    let i = 0
+    let space = ''
+  endif
+  let path = ""
+  while i < a:0
+    if type(a:000[i]) == type([])
+      let list = a:000[i]
+      let j = 0
+      while j < len(list)
+        let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
+        let path .= ',' . escaped
+        let j += 1
+      endwhile
+    else
+      let path .= "," . a:000[i]
+    endif
+    let i += 1
+  endwhile
+  return substitute(path,'^,','','')
+endfunction
+
+" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
+function! pathogen#legacyjoin(...) abort
+  return call('pathogen#join',[1] + a:000)
+endfunction
+
+" Turn filetype detection off and back on again if it was already enabled.
+function! pathogen#cycle_filetype() abort
+  if exists('g:did_load_filetypes')
+    filetype off
+    filetype on
+  endif
+endfunction
+
+" Check if a bundle is disabled.  A bundle is considered disabled if its
+" basename or full name is included in the list g:pathogen_blacklist or the
+" comma delimited environment variable $VIMBLACKLIST.
+function! pathogen#is_disabled(path) abort
+  if a:path =~# '\~$'
+    return 1
+  endif
+  let sep = pathogen#slash()
+  let blacklist =
+        \ get(g:, 'pathogen_blacklist', get(g:, 'pathogen_disabled', [])) +
+        \ pathogen#split($VIMBLACKLIST)
+  if !empty(blacklist)
+    call map(blacklist, 'substitute(v:val, "[\\/]$", "", "")')
+  endif
+  return index(blacklist, fnamemodify(a:path, ':t')) != -1 || index(blacklist, a:path) != -1
+endfunction
+
+" Prepend the given directory to the runtime path and append its corresponding
+" after directory.  Curly braces are expanded with pathogen#expand().
+function! pathogen#surround(path) abort
+  let sep = pathogen#slash()
+  let rtp = pathogen#split(&rtp)
+  let path = fnamemodify(a:path, ':s?[\\/]\=$??')
+  let before = filter(pathogen#expand(path), '!pathogen#is_disabled(v:val)')
+  let after = filter(reverse(pathogen#expand(path, sep.'after')), '!pathogen#is_disabled(v:val[0:-7])')
+  call filter(rtp, 'index(before + after, v:val) == -1')
+  let &rtp = pathogen#join(before, rtp, after)
+  return &rtp
+endfunction
+
+" For each directory in the runtime path, add a second entry with the given
+" argument appended.  Curly braces are expanded with pathogen#expand().
+function! pathogen#interpose(name) abort
+  let sep = pathogen#slash()
+  let name = a:name
+  if has_key(s:done_bundles, name)
+    return ""
+  endif
+  let s:done_bundles[name] = 1
+  let list = []
+  for dir in pathogen#split(&rtp)
+    if dir =~# '\<after$'
+      let list += reverse(filter(pathogen#expand(dir[0:-6].name, sep.'after'), '!pathogen#is_disabled(v:val[0:-7])')) + [dir]
+    else
+      let list += [dir] + filter(pathogen#expand(dir.sep.name), '!pathogen#is_disabled(v:val)')
+    endif
+  endfor
+  let &rtp = pathogen#join(pathogen#uniq(list))
+  return 1
+endfunction
+
+let s:done_bundles = {}
+
+" Invoke :helptags on all non-$VIM doc directories in runtimepath.
+function! pathogen#helptags() abort
+  let sep = pathogen#slash()
+  for glob in pathogen#split(&rtp)
+    for dir in map(split(glob(glob), "\n"), 'v:val.sep."/doc/".sep')
+      if (dir)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir) == 2 && !empty(split(glob(dir.'*.txt'))) && (!filereadable(dir.'tags') || filewritable(dir.'tags'))
+        silent! execute 'helptags' pathogen#fnameescape(dir)
+      endif
+    endfor
+  endfor
+endfunction
+
+command! -bar Helptags :call pathogen#helptags()
+
+" Execute the given command.  This is basically a backdoor for --remote-expr.
+function! pathogen#execute(...) abort
+  for command in a:000
+    execute command
+  endfor
+  return ''
+endfunction
+
+" Section: Unofficial
+
+function! pathogen#is_absolute(path) abort
+  return a:path =~# (has('win32') ? '^\%([\\/]\|\w:\)[\\/]\|^[~$]' : '^[/~$]')
+endfunction
+
+" Given a string, returns all possible permutations of comma delimited braced
+" alternatives of that string.  pathogen#expand('/{a,b}/{c,d}') yields
+" ['/a/c', '/a/d', '/b/c', '/b/d'].  Empty braces are treated as a wildcard
+" and globbed.  Actual globs are preserved.
+function! pathogen#expand(pattern, ...) abort
+  let after = a:0 ? a:1 : ''
+  if a:pattern =~# '{[^{}]\+}'
+    let [pre, pat, post] = split(substitute(a:pattern, '\(.\{-\}\){\([^{}]\+\)}\(.*\)', "\\1\001\\2\001\\3", ''), "\001", 1)
+    let found = map(split(pat, ',', 1), 'pre.v:val.post')
+    let results = []
+    for pattern in found
+      call extend(results, pathogen#expand(pattern))
+    endfor
+  elseif a:pattern =~# '{}'
+    let pat = matchstr(a:pattern, '^.*{}[^*]*\%($\|[\\/]\)')
+    let post = a:pattern[strlen(pat) : -1]
+    let results = map(split(glob(substitute(pat, '{}', '*', 'g')), "\n"), 'v:val.post')
+  else
+    let results = [a:pattern]
+  endif
+  let vf = pathogen#slash() . 'vimfiles'
+  call map(results, 'v:val =~# "\\*" ? v:val.after : isdirectory(v:val.vf.after) ? v:val.vf.after : isdirectory(v:val.after) ? v:val.after : ""')
+  return filter(results, '!empty(v:val)')
+endfunction
+
+" \ on Windows unless shellslash is set, / everywhere else.
+function! pathogen#slash() abort
+  return !exists("+shellslash") || &shellslash ? '/' : '\'
+endfunction
+
+function! pathogen#separator() abort
+  return pathogen#slash()
+endfunction
+
+" Convenience wrapper around glob() which returns a list.
+function! pathogen#glob(pattern) abort
+  let files = split(glob(a:pattern),"\n")
+  return map(files,'substitute(v:val,"[".pathogen#slash()."/]$","","")')
+endfunction
+
+" Like pathogen#glob(), only limit the results to directories.
+function! pathogen#glob_directories(pattern) abort
+  return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
+endfunction
+
+" Remove duplicates from a list.
+function! pathogen#uniq(list) abort
+  let i = 0
+  let seen = {}
+  while i < len(a:list)
+    if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
+      call remove(a:list,i)
+    elseif a:list[i] ==# ''
+      let i += 1
+      let empty = 1
+    else
+      let seen[a:list[i]] = 1
+      let i += 1
+    endif
+  endwhile
+  return a:list
+endfunction
+
+" Backport of fnameescape().
+function! pathogen#fnameescape(string) abort
+  if exists('*fnameescape')
+    return fnameescape(a:string)
+  elseif a:string ==# '-'
+    return '\-'
+  else
+    return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
+  endif
+endfunction
+
+" Like findfile(), but hardcoded to use the runtimepath.
+function! pathogen#runtime_findfile(file,count) abort
+  let rtp = pathogen#join(1,pathogen#split(&rtp))
+  let file = findfile(a:file,rtp,a:count)
+  if file ==# ''
+    return ''
+  else
+    return fnamemodify(file,':p')
+  endif
+endfunction
+
+" Section: Deprecated
+
+function! s:warn(msg) abort
+  echohl WarningMsg
+  echomsg a:msg
+  echohl NONE
+endfunction
+
+" Prepend all subdirectories of path to the rtp, and append all 'after'
+" directories in those subdirectories.  Deprecated.
+function! pathogen#runtime_prepend_subdirectories(path) abort
+  call s:warn('Change pathogen#runtime_prepend_subdirectories('.string(a:path).') to pathogen#infect('.string(a:path.'/{}').')')
+  return pathogen#surround(a:path . pathogen#slash() . '{}')
+endfunction
+
+function! pathogen#incubate(...) abort
+  let name = a:0 ? a:1 : 'bundle/{}'
+  call s:warn('Change pathogen#incubate('.(a:0 ? string(a:1) : '').') to pathogen#infect('.string(name).')')
+  return pathogen#interpose(name)
+endfunction
+
+" Deprecated alias for pathogen#interpose().
+function! pathogen#runtime_append_all_bundles(...) abort
+  if a:0
+    call s:warn('Change pathogen#runtime_append_all_bundles('.string(a:1).') to pathogen#infect('.string(a:1.'/{}').')')
+  else
+    call s:warn('Change pathogen#runtime_append_all_bundles() to pathogen#infect()')
+  endif
+  return pathogen#interpose(a:0 ? a:1 . '/{}' : 'bundle/{}')
+endfunction
+
+if exists(':Vedit')
+  finish
+endif
+
+let s:vopen_warning = 0
+
+function! s:find(count,cmd,file,lcd)
+  let rtp = pathogen#join(1,pathogen#split(&runtimepath))
+  let file = pathogen#runtime_findfile(a:file,a:count)
+  if file ==# ''
+    return "echoerr 'E345: Can''t find file \"".a:file."\" in runtimepath'"
+  endif
+  if !s:vopen_warning
+    let s:vopen_warning = 1
+    let warning = '|echohl WarningMsg|echo "Install scriptease.vim to continue using :V'.a:cmd.'"|echohl NONE'
+  else
+    let warning = ''
+  endif
+  if a:lcd
+    let path = file[0:-strlen(a:file)-2]
+    execute 'lcd `=path`'
+    return a:cmd.' '.pathogen#fnameescape(a:file) . warning
+  else
+    return a:cmd.' '.pathogen#fnameescape(file) . warning
+  endif
+endfunction
+
+function! s:Findcomplete(A,L,P)
+  let sep = pathogen#slash()
+  let cheats = {
+        \'a': 'autoload',
+        \'d': 'doc',
+        \'f': 'ftplugin',
+        \'i': 'indent',
+        \'p': 'plugin',
+        \'s': 'syntax'}
+  if a:A =~# '^\w[\\/]' && has_key(cheats,a:A[0])
+    let request = cheats[a:A[0]].a:A[1:-1]
+  else
+    let request = a:A
+  endif
+  let pattern = substitute(request,'/\|\'.sep,'*'.sep,'g').'*'
+  let found = {}
+  for path in pathogen#split(&runtimepath)
+    let path = expand(path, ':p')
+    let matches = split(glob(path.sep.pattern),"\n")
+    call map(matches,'isdirectory(v:val) ? v:val.sep : v:val')
+    call map(matches,'expand(v:val, ":p")[strlen(path)+1:-1]')
+    for match in matches
+      let found[match] = 1
+    endfor
+  endfor
+  return sort(keys(found))
+endfunction
+
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve       :execute s:find(<count>,'edit<bang>',<q-args>,0)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit    :execute s:find(<count>,'edit<bang>',<q-args>,0)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen    :execute s:find(<count>,'edit<bang>',<q-args>,1)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit   :execute s:find(<count>,'split',<q-args>,<bang>1)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit  :execute s:find(<count>,'vsplit',<q-args>,<bang>1)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(<count>,'tabedit',<q-args>,<bang>1)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit   :execute s:find(<count>,'pedit',<q-args>,<bang>1)
+command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread    :execute s:find(<count>,'read',<q-args>,<bang>1)
+
+" vim:set et sw=2 foldmethod=expr foldexpr=getline(v\:lnum)=~'^\"\ Section\:'?'>1'\:getline(v\:lnum)=~#'^fu'?'a1'\:getline(v\:lnum)=~#'^endf'?'s1'\:'=':
diff --git a/vim/.vim/bundle/pencil/LICENSE b/vim/.vim/bundle/pencil/LICENSE
new file mode 100644
index 0000000..44fe50a
--- /dev/null
+++ b/vim/.vim/bundle/pencil/LICENSE
@@ -0,0 +1,23 @@
+License:     The MIT License (MIT)
+
+Copyright (c) 2013,2014 Reed Esau
+
+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.
+
+<!-- vim: set tw=74 :-->
diff --git a/vim/.vim/bundle/pencil/README.markdown b/vim/.vim/bundle/pencil/README.markdown
new file mode 100644
index 0000000..0fc4309
--- /dev/null
+++ b/vim/.vim/bundle/pencil/README.markdown
@@ -0,0 +1,696 @@
+# vim-pencil
+
+> Rethinking Vim as a tool for writers
+
+<br/>
+
+- - -
+![demo](http://i.imgur.com/0KYl5vU.gif)
+- - -
+
+# Features
+
+The _pencil_ plugin aspires to make Vim as powerful a tool for writers as
+it is for coders by focusing narrowly on the handful of tweaks needed to
+smooth the path to writing prose.
+
+* For editing prose-oriented file types such as _text_, _markdown_,
+  _mail_, _rst_, _tex_, _textile_, and _asciidoc_
+* Agnostic on soft line wrap _versus_ hard line breaks, supporting both
+* Auto-detects wrap mode via `modeline` and sampling
+* Adjusts navigation key mappings to suit the wrap mode
+* Creates undo points on common punctuation during Insert mode, including
+  deletion via line `<C-U>` and word `<C-W>`
+* Buffer-scoped configuration (with a few minor exceptions, _pencil_ preserves
+  your global settings)
+* Support for Vim’s Conceal feature to hide markup defined by Syntax plugins
+  (e.g., `_` and `*` markup for styled text in \_*Markdown*\_)
+* Support for display of mode indicator (`␍` and `⤸`, e.g.) in the status line
+* Pure Vimscript with no dependencies
+
+In addition, when using hard line break mode:
+
+* Makes use of Vim’s powerful autoformat while inserting text, except for
+  tables and code blocks where you won’t want it.
+* *NEW* Optional key mapping to suspend autoformat for the Insert.
+
+Need spell-check, distraction-free editing, and other features? Vim is about
+customization. To complete your editing environment, learn to configure Vim and
+draw upon its rich ecosystem of plugins.
+
+# Why use Vim for writing?
+
+With plenty of word processing applications available, including those
+that specifically cater to writers, why use a modal editor like Vim?
+Several reasons have been offered:
+
+* Your hands can rest in a neutral ‘home’ position, only rarely straying
+  to reach for mouse, track pad, or arrow keys
+* Minimal chording, with many mnemonic-friendly commands
+* Sophisticated capabilities for navigating and manipulating text
+* Highly configurable, enabling you to build a workflow that suits your
+  needs, with many great plugins available
+* No proprietary format lock-in
+
+But while such reasons might be sound, they remain scant justification to
+switch away from the familiar word processor. Instead, you need
+a compelling reason—one that can appeal to a writer’s love for language
+and the tools of writing.
+
+You can find that reason in Vim's mysterious command sequences. Take `cas`
+for instance. You might see it as a mnemonic for _Change Around Sentence_
+to replace an existing sentence. But dig a bit deeper to discover that
+such commands have a grammar of their own, comprised of nouns, verbs, and
+modifiers. Think of them as the composable building blocks of a _domain
+specific language_ for manipulating text, one that can become a powerful
+tool in expressing yourself. For more details on vi-style editing, see...
+
+* [Learn to speak vim – verbs, nouns, and modifiers!][ls] (December 2011)
+* [Your problem with Vim is that you don't grok vi][gv] (December 2011)
+* [Intro to Vim's Grammar][ig] (January 2013)
+* [Why Atom Can’t Replace Vim, Learning the lesson of vi][wa] (March 2014)
+* [Language of Vim/Neovim][lovn] (January 2015)
+
+[ls]: http://yanpritzker.com/2011/12/16/learn-to-speak-vim-verbs-nouns-and-modifiers/
+[gv]: http://stackoverflow.com/questions/1218390/what-is-your-most-productive-shortcut-with-vim/1220118#1220118
+[ig]: http://takac.github.io/2013/01/30/vim-grammar/
+[wa]: https://medium.com/p/433852f4b4d1
+[lovn]: http://allsyed.com/language-of-vim-neovim/
+
+# Installation
+
+_pencil_ is best installed using a Vim package manager, such as
+[Vundle][vnd], [Plug][plg], [NeoBundle][nbn], or [Pathogen][pth].
+
+_For those new to Vim: before installing this plugin, consider getting
+comfortable with the basics of Vim by working through one of the many
+tutorials available._
+
+[vnd]: https://github.com/gmarik/Vundle.vim
+[plg]: https://github.com/junegunn/vim-plug
+[nbn]: https://github.com/Shougo/neobundle.vim
+[pth]: https://github.com/tpope/vim-pathogen
+
+#### Vundle
+
+Add to your `.vimrc` and save:
+
+```vim
+Plugin 'reedes/vim-pencil'
+```
+
+…then run the following in Vim:
+
+```vim
+:source %
+:PluginInstall
+```
+
+#### Plug
+
+Add to your `.vimrc` and save:
+
+```vim
+Plug 'reedes/vim-pencil'
+```
+
+…then run the following in Vim:
+
+```vim
+:source %
+:PlugInstall
+```
+
+#### NeoBundle
+
+Add to your `.vimrc` and save:
+
+```vim
+NeoBundle 'reedes/vim-pencil'
+```
+
+…then run the following in Vim:
+
+```vim
+:source %
+:NeoBundleInstall
+```
+
+#### Pathogen
+
+Run the following in a terminal:
+
+```bash
+cd ~/.vim/bundle
+git clone https://github.com/reedes/vim-pencil
+```
+
+# Configuration
+
+## Initializing by command
+
+You can manually enable, disable, and toggle _pencil_ as a command:
+
+* `Pencil` - initialize _pencil_ with auto-detect for the current buffer
+* `NoPencil` (or `PencilOff`) - removes navigation mappings and restores buffer to global settings
+* `TogglePencil` (or `PencilToggle`) - if on, turns off; if off, initializes with auto-detect
+
+Because auto-detect might not work as intended, you can invoke a command
+to set the behavior for the current buffer:
+
+* `SoftPencil` (or `PencilSoft`) - initialize _pencil_ with soft line wrap mode
+* `HardPencil` (or `PencilHard`) - initialize _pencil_ with hard line break mode (and Vim’s autoformat)
+
+## Initializing by file type
+
+Initializing _pencil_ by file type is _optional_, though doing so will
+automatically set up your buffers for editing prose.
+
+Add support for your desired file types to your `.vimrc`:
+
+```vim
+set nocompatible
+filetype plugin on       " may already be in your .vimrc
+
+augroup pencil
+  autocmd!
+  autocmd FileType markdown,mkd call pencil#init()
+  autocmd FileType text         call pencil#init()
+augroup END
+```
+
+You can initialize several prose-oriented plugins together:
+
+```vim
+augroup pencil
+  autocmd!
+  autocmd FileType markdown,mkd call pencil#init()
+                            \ | call lexical#init()
+                            \ | call litecorrect#init()
+                            \ | call textobj#quote#init()
+                            \ | call textobj#sentence#init()
+augroup END
+```
+
+For a list of other prose-oriented plugins, consult the [See
+also](#see-also) section below.
+
+## Hard line breaks or soft line wrap?
+
+Coders will have the most experience with the former, and writers the
+latter. But whatever your background, chances are that you must contend
+with both conventions. This plugin doesn't force you to choose a side—you
+can configure each buffer independently.
+
+In most cases you can set a default to suit your preference and let
+auto-detection figure out what to do.
+
+```vim
+let g:pencil#wrapModeDefault = 'soft'   " default is 'hard'
+
+augroup pencil
+  autocmd!
+  autocmd FileType markdown,mkd call pencil#init()
+  autocmd FileType text         call pencil#init({'wrap': 'hard'})
+augroup END
+```
+
+In the example above, for buffers of type `markdown` this plugin will
+auto-detect the line wrap approach, with soft line wrap as the default.
+
+For buffers of type `text`, it will initialize with hard line breaks,
+even if auto-detect might suggest soft line wrap.
+
+## Automatic formatting
+
+_The ‘autoformat’ feature affects *HardPencil* (hard line break) mode
+only._
+
+When inserting text while in *HardPencil* mode, Vim’s powerful autoformat
+feature will be _enabled_ by default and can offer many of the same
+benefits as soft line wrap.
+
+To set the default behavior in your `.vimrc`:
+
+```vim
+let g:pencil#autoformat = 1      " 0=disable, 1=enable (def)
+```
+
+You can override this default during initialization, as in:
+
+```vim
+augroup pencil
+  autocmd!
+  autocmd FileType markdown call pencil#init({'wrap': 'hard', 'autoformat': 1})
+  autocmd FileType text     call pencil#init({'wrap': 'hard', 'autoformat': 0})
+  ...
+augroup END
+```
+
+...where buffers of type `markdown` and `text` will use hard line breaks,
+but `text` buffers will have autoformat disabled.
+
+## Suspend automatic formatting for the Insert
+
+There are two useful exceptions where autoformat (when enabled for the
+buffer) will be _temporarily disabled_ for the current Insert:
+
+First is _pencil’s_ 'blacklisting' feature: if used with popular
+prose-oriented syntax plugins, _pencil_ will suspend autoformat when you
+enter Insert mode from inside a code block or table.
+
+[**NEW**] Second, where blacklisting falls short, you can optionally map
+a buffer-scoped ‘modifier’ key to suspend autoformat during the next
+Insert:
+
+```vim
+let g:pencil#map#suspend_af = 'K'   " default is no mapping
+```
+
+Using the above mapping, with `Ko` you’ll enter Insert mode with the
+cursor on a new line, but autoformat will suspend for that Insert. Using
+`o` by itself will retain autoformat.
+
+(See the advanced section below for details on how blacklisting is
+implemented and configured).
+
+## Manual formatting
+
+Note that you need not rely on Vim’s autoformat exclusively and can
+manually reformat paragraphs with standard Vim commands:
+
+* `gqap` - format current paragraph (see `:help gq` for details)
+* `vapJgqap` - merge two paragraphs (current and next) and format
+* `ggVGgq` or `:g/^/norm gqq` - format all paragraphs in buffer
+
+Optionally, you can map these operations to underutilized keys in your
+`.vimrc`:
+
+```vim
+nnoremap <silent> Q gqap
+xnoremap <silent> Q gq
+nnoremap <silent> <leader>Q vapJgqap
+```
+
+Or you may wish to ‘unformat’, (i.e., remove hard line breaks) when using
+soft line wrap.
+
+* `vipJ` - join all lines in current paragraph
+* `:%norm vipJ` - unformat all paragraphs in buffer
+
+## Default textwidth
+
+You can configure the textwidth to be used in **Hard Pencil** mode when no
+textwidth is set globally, locally, or available via modeling. It
+defaults to `74`, but you can change that value in your `.vimrc`:
+
+```vim
+let g:pencil#textwidth = 74
+```
+
+## Sentence spacing
+
+By default, when formatting text (through `gwip`, e.g.) only one space
+will be inserted after a period(`.`), exclamation point(`!`), or question
+mark(`?`). You can change this default:
+
+```vim
+let g:pencil#joinspaces = 0     " 0=one_space (def), 1=two_spaces
+```
+
+## Cursor wrap
+
+By default, `h`/`l` and the left/right cursor keys will move to the
+previous/next line after reaching first/last character in a line with
+a hard break. If you wish to retain the default Vim behavior, set the
+`cursorwrap` value to `0` in your `.vimrc`:
+
+```vim
+let g:pencil#cursorwrap = 1     " 0=disable, 1=enable (def)
+```
+
+## Concealing \_\_markup\_\_
+
+_pencil_ enables Vim's powerful Conceal feature, although support among
+Syntax and Colorscheme plugins is currently spotty.
+
+You can change _pencil’s_ default settings for conceal in your `.vimrc`:
+
+```vim
+let g:pencil#conceallevel = 3     " 0=disable, 1=one char, 2=hide char, 3=hide all (def)
+let g:pencil#concealcursor = 'c'  " n=normal, v=visual, i=insert, c=command (def)
+```
+
+For more details on Vim’s Conceal feature, see:
+
+```vim
+:help conceallevel
+:help concealcursor
+```
+
+### Concealing styled text in Markdown
+
+Syntax plugins such as [tpope/vim-markdown][tm] support concealing the
+markup characters when displaying \_*italic*\_, \*\*__bold__\*\*, and
+\*\*\*___bold italic___\*\*\* styled text.
+
+To use Vim’s Conceal feature with Markdown, you will need to install:
+
+1. [tpope/vim-markdown][tm] as it’s currently the only Markdown syntax
+   plugin that supports conceal.
+
+2. A monospaced font (such as [Cousine][co]) featuring the _italic_,
+   **bold**, and ***bold italic*** style variant for styled text.
+
+3. A colorscheme (such as [reedes/vim-colors-pencil][cp]) which supports
+   the Markdown-specific highlight groups for styled text.
+
+You should then only see the `_` and `*` markup for the cursor line and in
+visual selections.
+
+**Terminal users:** consult your terminal’s documentation to configure your
+terminal to support **bold** and _italic_ styles.
+
+[co]: http://www.google.com/fonts/specimen/Cousine
+[tm]: http://github.com/tpope/vim-markdown
+
+## Status line indicator
+
+Your status line can reflect the wrap mode for _pencil_ buffers. For
+example, `␍` to represent `HardPencil` (hard line break) mode.  To
+configure your status line and ruler, add to your `.vimrc`:
+
+```vim
+set statusline=%<%f\ %h%m%r%w\ \ %{PencilMode()}\ %=\ col\ %c%V\ \ line\ %l\,%L\ %P
+set rulerformat=%-12.(%l,%c%V%)%{PencilMode()}\ %P
+```
+
+or if using [bling/vim-airline][va]:
+
+```vim
+let g:airline_section_x = '%{PencilMode()}'
+```
+
+The default indicators now include ‘auto’ for when Vim’s autoformat is
+active in hard line break mode. (If autoformat is suspended for the
+Insert, it’ll show the ‘hard’ indicator.)
+
+```vim
+let g:pencil#mode_indicators = {'hard': 'H', 'auto': 'A', 'soft': 'S', 'off': '',}
+```
+
+If Unicode is detected, the default indicators are:
+
+```vim
+let g:pencil#mode_indicators = {'hard': '␍', 'auto': 'ª', 'soft': '⤸', 'off': '',}
+```
+
+If you don’t like the default indicators, you can specify your own in
+your `.vimrc`.
+
+Note that `PencilMode()` will return blank for buffers in which _pencil_
+has not been initialized.
+
+[va]: http://github.com/bling/vim-airline
+
+## Advanced pencil
+
+### Advanced initialization
+
+You may want to refactor initialization statements into a function in
+your `.vimrc` to set up a buffer for writing:
+
+```vim
+function! Prose()
+  call pencil#init()
+  call lexical#init()
+  call litecorrect#init()
+  call textobj#quote#init()
+  call textobj#sentence#init()
+
+  " manual reformatting shortcuts
+  nnoremap <buffer> <silent> Q gqap
+  xnoremap <buffer> <silent> Q gq
+  nnoremap <buffer> <silent> <leader>Q vapJgqap
+
+  " force top correction on most recent misspelling
+  nnoremap <buffer> <c-s> [s1z=<c-o>
+  inoremap <buffer> <c-s> <c-g>u<Esc>[s1z=`]A<c-g>u
+
+  " replace common punctuation
+  iabbrev <buffer> -- –
+  iabbrev <buffer> --- —
+  iabbrev <buffer> << «
+  iabbrev <buffer> >> »
+
+  " open most folds
+  setlocal foldlevel=6
+endfunction
+
+" automatically initialize buffer by file type
+autocmd FileType markdown,mkd,text call Prose()
+
+" invoke manually by command for other file types
+command! -nargs=0 Prose call Prose()
+```
+
+For highly-granular control, you can override _pencil_ and other configuration
+settings when initializing buffers by file type:
+
+```vim
+augroup pencil
+  autocmd!
+  autocmd FileType markdown,mkd call pencil#init()
+                            \ | call litecorrect#init()
+                            \ | setl spell spl=en_us fdl=4 noru nonu nornu
+                            \ | setl fdo+=search
+  autocmd Filetype git,gitsendemail,*commit*,*COMMIT*
+                            \   call pencil#init({'wrap': 'hard', 'textwidth': 72})
+                            \ | call litecorrect#init()
+                            \ | setl spell spl=en_us et sw=2 ts=2 noai
+  autocmd Filetype mail         call pencil#init({'wrap': 'hard', 'textwidth': 60})
+                            \ | call litecorrect#init()
+                            \ | setl spell spl=en_us et sw=2 ts=2 noai nonu nornu
+  autocmd Filetype html,xml     call pencil#init({'wrap': 'soft'})
+                            \ | call litecorrect#init()
+                            \ | setl spell spl=en_us et sw=2 ts=2
+augroup END
+```
+
+Configurable options for `pencil#init()` include: `autoformat`,
+`concealcursor`, `conceallevel`, `cursorwrap`, `joinspaces`, `textwidth`,
+and `wrap`. These are detailed above.
+
+### Autoformat manual control
+
+_The ‘autoformat’ feature affects *HardPencil* (hard line break) mode
+only._
+
+To suspend autoformat for the next Insert, see above.
+
+When you need to manually enable/disable autoformat for the current
+buffer, you can do so with a command:
+
+* `PFormat` - enable autoformat for buffer (can still be disabled via blacklisting)
+* `PFormatOff` - disable autoformat for buffer
+* `PFormatToggle` - toggle to enable if disabled, etc.
+
+You can map a key in your `.vimrc` to toggle Vim's autoformat:
+
+```vim
+noremap <silent> <F7> :<C-u>PFormatToggle<cr>
+inoremap <silent> <F7> <C-o>:PFormatToggle<cr>
+```
+
+### Autoformat blacklisting (and whitelisting)
+
+_The ‘autoformat’ feature affects *HardPencil* (hard line break) mode
+only._
+
+When editing formatted text, such as a table or code block, Vim’s
+autoformat will wreak havoc with the formatting. In these cases you will
+want autoformat suspended for the duration of the Insert.
+
+When entering Insert mode, _pencil_ will determine the highlight group at
+the cursor position. If that group has been blacklisted, _pencil_ will
+suspend autoformat for the Insert. For example, if editing a buffer of
+type ‘markdown’, autoformat will be suspended if you invoke Insert mode
+from inside a `markdownFencedCodeBlock` highlight group.
+
+Blacklists are now declared by file type. The default blacklists (and
+whitelists) are declared in the `plugin/pencil.vim` module. Here’s an
+excerpt showing the configuration for the ‘markdown’ file type:
+
+```vim
+  let g:pencil#autoformat_config = {
+        \   'markdown': {
+        \     'black': [
+        \       'htmlH[0-9]',
+        \       'markdown(Code|H[0-9]|Url|IdDeclaration|Link|Rule|Highlight[A-Za-z0-9]+)',
+        \       'markdown(FencedCodeBlock|InlineCode)',
+        \       'mkd(Code|Rule|Delimiter|Link|ListItem|IndentCode)',
+        \       'mmdTable[A-Za-z0-9]*',
+        \     ],
+        \     'white': [
+        \      'markdown(Code|Link)',
+        \     ],
+        \   },
+        [snip]
+        \ }
+```
+
+The whitelist will override the blacklist and enable Vim’s autoformat if
+text that would normally be blacklisted doesn’t dominate the entire line.
+This allows autoformat to work with `inline` code and links.
+
+### Auto-detecting wrap mode
+
+If you didn't explicitly specify a wrap mode during initialization,
+_pencil_ will attempt to detect it.
+
+It will first look for a `textwidth` (or `tw`) specified in a modeline.
+Failing that, _pencil_ will then sample lines from the start of the
+buffer.
+
+#### Detect via modeline
+
+Will the wrap mode be detected accurately? Maybe. But you can improve its
+chances by giving _pencil_ an explicit hint.
+
+At the bottom of this document is a odd-looking code:
+
+```html
+<!-- vim: set tw=73 :-->
+```
+
+This is an **optional** ‘modeline’ that tells Vim to run the following
+command upon loading the file into a buffer:
+
+```vim
+:set textwidth=73
+```
+
+It tells _pencil_ to assume hard line breaks, regardless of whether or
+not soft line wrap is the default editing mode for buffers of type
+‘markdown’.
+
+You explicitly specify soft wrap mode by specifying a textwidth of `0`:
+
+```html
+<!-- vim: set tw=0 :-->
+```
+
+Note that if the modelines feature is disabled (such as for security
+reasons) the textwidth will still be set by this plugin.
+
+#### Detect via sampling
+
+If no modeline with a textwidth is found, _pencil_ will sample the
+initial lines from the buffer, looking for those excessively-long.
+
+There are two settings you can add to your `.vimrc` to tweak this behavior.
+
+The maximum number of lines to sample from the start of the buffer:
+
+```vim
+let g:pencil#softDetectSample = 20
+```
+
+Set that value to `0` to disable detection via line sampling.
+
+When the number of bytes on a sampled line per exceeds this next value,
+then _pencil_ assumes soft line wrap.
+
+```vim
+let g:pencil#softDetectThreshold = 130
+```
+
+If no such lines found, _pencil_ falls back to the default wrap mode.
+
+# See also
+
+* [To Vim][tv] - Writer and psychologist Ian Hocking on using Vim for writing
+* [Vim Training Class - Basic motions and commands][tc] - video tutorial by Shawn Biddle
+* [Vim for Writers][vw] - guide to the basics geared to writers
+
+Bloggers and developers discuss _pencil_ and its brethern:
+
+* [Reed Esau's growing list of Vim plugins for writers][regl] (2014) - by @pengwynn
+* [Distraction Free Writing in Vim][dfwiv] (2014) - by @tlattimore
+* [Safari Blog: Turning vim into an IDE through vim plugins][tviai] (2014) - by @jameydeorio
+* [Quick tops for writing prose with Vim][qtfwp] (2014) - by @benoliver999
+* [UseVim: Reed Esau's Writing Plugins][rewp] (2015) - by @alexyoung
+* [Tomasino Labs: Vim in Context][vic] (2015) - by @jamestomasino
+* [Writing with Vim][wwv] (2015) - by Pat Ambrosio
+
+Other plugins of specific interest to writers:
+
+* [danielbmarques/vim-ditto][vd] - highlight repeated words
+* [tpope/vim-abolish][ab] - search for, substitute, and abbr. multiple variants of a word
+* [tommcdo/vim-exchange][ex] - easy text exchange operator for Vim
+* [junegunn/limelight.vim][jl] - focus mode that brightens current paragraph
+* [junegunn/goyo.vim][jg] - distraction-free editing mode
+
+[vd]: https://github.com/danielbmarques/vim-ditto
+[qtfwp]: http://benoliver999.com/technology/2014/12/06/vimforprose/
+[wwv]: https://lilii.co/aardvark/writing-with-vim
+[vic]: https://labs.tomasino.org/vim-in-context.html
+[rewp]: http://usevim.com/2015/05/27/reedes/
+[tviai]: https://www.safaribooksonline.com/blog/2014/11/23/way-vim-ide/
+[regl]: http://wynnnetherland.com/journal/reed-esau-s-growing-list-of-vim-plugins-for-writers/
+[dfwiv]: http://tlattimore.com/blog/distraction-free-writing-in-vim/
+[ab]: http://github.com/tpope/vim-abolish
+[ex]: http://github.com/tommcdo/vim-exchange
+[jl]: http://github.com/junegunn/limelight.vim
+[jg]: http://github.com/junegunn/goyo.vim
+
+Markdown syntax plugins
+
+* [tpope/vim-markdown][tvm] - the latest version of the syntax plugin that ships with Vim
+* [plasticboy/vim-markdown][pvm]
+* [gabrielelana/vim-markdown][gvm]
+* [mattly/vim-markdown-enhancements][mvme] - highlighting for tables and footnotes
+
+[tvm]: http://github.com/tpope/vim-markdown
+[pvm]: http://github.com/plasticboy/vim-markdown
+[gvm]: http://github.com/gabrielelana/vim-markdown
+[mvme]: http://github.com/mattly/vim-markdown-enhancements
+
+If you find the _pencil_ plugin useful, check out these others by [@reedes][re]:
+
+* [vim-colors-pencil][cp] - color scheme for Vim inspired by IA Writer
+* [vim-lexical][lx] - building on Vim’s spell-check and thesaurus/dictionary completion
+* [vim-litecorrect][lc] - lightweight auto-correction for Vim
+* [vim-one][vo] - make use of Vim’s _+clientserver_ capabilities
+* [vim-textobj-quote][qu] - extends Vim to support typographic (‘curly’) quotes
+* [vim-textobj-sentence][ts] - improving on Vim's native sentence motion command
+* [vim-thematic][th] - modify Vim’s appearance to suit your task and environment
+* [vim-wheel][wh] - screen-anchored cursor movement for Vim
+* [vim-wordy][wo] - uncovering usage problems in writing
+
+Unimpressed by _pencil_? [vim-pandoc][vp] offers prose-oriented features
+with its own Markdown variant.
+
+[cp]: http://github.com/reedes/vim-colors-pencil
+[lc]: http://github.com/reedes/vim-litecorrect
+[lx]: http://github.com/reedes/vim-lexical
+[qu]: http://github.com/reedes/vim-textobj-quote
+[re]: http://github.com/reedes
+[tc]: https://www.youtube.com/watch?v=Nim4_f5QUxA
+[th]: http://github.com/reedes/vim-thematic
+[ts]: http://github.com/reedes/vim-textobj-sentence
+[tv]: http://ianhocking.com/2013/11/17/to-vim/
+[vo]: http://github.com/reedes/vim-one
+[vw]: http://therandymon.com/woodnotes/vim-for-writers/vimforwriters.html
+[wh]: http://github.com/reedes/vim-wheel
+[wo]: http://github.com/reedes/vim-wordy
+[vp]: http://github.com/vim-pandoc/vim-pandoc
+
+# Future development
+
+If you’ve spotted a problem or have an idea on improving _pencil_, please
+report it as an issue, or better yet submit a pull request.
+
+```
+<!-- vim: set tw=73 :-->
+```
diff --git a/vim/.vim/bundle/pencil/autoload/pencil.vim b/vim/.vim/bundle/pencil/autoload/pencil.vim
new file mode 100644
index 0000000..bf5beda
--- /dev/null
+++ b/vim/.vim/bundle/pencil/autoload/pencil.vim
@@ -0,0 +1,514 @@
+" ============================================================================
+" File:        pencil.vim
+" Description: autoload functions for vim-pencil plugin
+" Maintainer:  Reed Esau <github.com/reedes>
+" Created:     December 28, 2013
+" License:     The MIT License (MIT)
+" ============================================================================
+if exists("autoloaded_pencil") | fini | en
+let autoloaded_pencil = 1
+
+let s:WRAP_MODE_DEFAULT = -1
+let s:WRAP_MODE_OFF     = 0
+let s:WRAP_MODE_HARD    = 1
+let s:WRAP_MODE_SOFT    = 2
+
+" Wrap-mode detector
+" Scan lines at end and beginning of file to determine the wrap mode.
+" Modelines has priority over long lines found.
+fun! s:detect_wrap_mode() abort
+
+  let b:max_textwidth = -1      " assume no relevant modeline
+  call s:doModelines()
+
+  if b:max_textwidth > 0
+    " modelines(s) found with positive textwidth, so hard line breaks
+    return s:WRAP_MODE_HARD
+  en
+
+  if b:max_textwidth ==# 0 || g:pencil#wrapModeDefault ==# 'soft'
+    " modeline(s) found only with zero textwidth, so it's soft line wrap
+    " or, the user wants to default to soft line wrap
+    return s:WRAP_MODE_SOFT
+  en
+
+  " attempt to rule out soft line wrap
+  " scan initial lines in an attempt to detect long lines
+  for l:line in getline(1, g:pencil#softDetectSample)
+    if len(l:line) > g:pencil#softDetectThreshold
+      return s:WRAP_MODE_SOFT
+    en
+  endfo
+
+  " punt
+  return s:WRAP_MODE_DEFAULT
+endf
+
+fun! s:imap(preserve_completion, key, icmd) abort
+  if a:preserve_completion
+    exe ":ino <buffer> <silent> <expr> " . a:key . " pumvisible() ? \"" . a:key . "\" : \"" . a:icmd . "\""
+  el
+    exe ":ino <buffer> <silent> " . a:key . " " . a:icmd
+  en
+endf
+
+fun! s:maybe_enable_autoformat() abort
+  " don't enable autoformat if in a blacklisted code block or table,
+  " allowing for reprieve via whitelist in certain cases
+
+  " a flag to suspend autoformat for the Insert
+  if b:pencil_suspend_af
+    let b:pencil_suspend_af = 0   " clear the flag
+    return
+  en
+
+  let l:ft = get(g:pencil#autoformat_aliases, &ft, &ft)
+  let l:af_cfg = get(g:pencil#autoformat_config, l:ft, {})
+  let l:black = get(l:af_cfg, 'black', [])
+  let l:white = get(l:af_cfg, 'white', [])
+  let l:has_black_re = len(l:black) > 0
+  let l:has_white_re = len(l:white) > 0
+  let l:black_re = l:has_black_re ? '\v(' . join( l:black, '|') . ')' : ''
+  let l:white_re = l:has_white_re ? '\v(' . join( l:white, '|') . ')' : ''
+  let l:enforce_previous_line = get(l:af_cfg, 'enforce-previous-line', 0)
+
+  let l:okay_to_enable = 1
+  let l:line = line('.')
+  let l:col = col('.')
+  let l:last_col = col('$')
+  let l:stack = []
+  let l:found_empty = 0
+  " at end of line there may be no synstack, so scan back
+  while l:col > 0
+    let l:stack = synstack(l:line, l:col)
+    if l:stack != []
+      break
+    en
+    " the last column will always be empty, so ignore it
+    if l:col < l:last_col
+      let l:found_empty = 1
+    en
+    let l:col -= 1
+  endw
+  " if needed, scan towards end of line looking for highlight groups
+  if l:stack == []
+    let l:col = col('.') + 1
+    while l:col <= l:last_col
+      let l:stack = synstack(l:line, l:col)
+      if l:stack != []
+        break
+      en
+      " the last column will always be empty, so ignore it
+      if l:col < l:last_col
+        let l:found_empty = 1
+      en
+      let l:col += 1
+    endw
+  en
+  " enforce blacklist by scanning for syntax matches
+  if l:has_black_re
+    for l:sid in l:stack
+      if match(synIDattr(l:sid, 'name'), l:black_re) >= 0
+        let l:okay_to_enable = 0
+        "echohl WarningMsg
+        "echo 'hit blacklist line=' . l:line . ' col=' . l:col .
+        "      \ ' name=' . synIDattr(l:sid, 'name')
+        "echohl NONE
+        break
+      en
+    endfo
+  en
+  " enforce whitelist by detecting inline `markup` for which we DO want
+  " autoformat to be enabled (e.g., tpope's markdownCode)
+  if l:has_white_re && !l:okay_to_enable
+    " one final check for an empty stack at the start and end of line,
+    " either of which greenlights a whitelist check
+    if !l:found_empty
+      if synstack(l:line, 1) == [] ||
+        \ (l:last_col > 1 && synstack(l:line, l:last_col-1) == [])
+        let l:found_empty = 1
+      en
+    en
+    if l:found_empty
+      for l:sid in l:stack
+        if match(synIDattr(l:sid, 'name'), l:white_re) >= 0
+          let l:okay_to_enable = 1
+          break
+        en
+      endfo
+    en
+  en
+  " disallow enable if start of previous line is in blacklist,
+  if l:has_black_re && l:enforce_previous_line && l:okay_to_enable && l:line > 1
+    let l:prev_stack = synstack(l:line - 1, 1)
+    for l:sid in l:prev_stack
+      if len(l:sid) > 0 &&
+              \ match(synIDattr(l:sid, 'name'), l:black_re) >= 0
+        let l:okay_to_enable = 0
+        break
+      en
+    endfo
+  en
+  if l:okay_to_enable
+    set formatoptions+=a
+  en
+endf
+
+fun! pencil#setAutoFormat(af) abort
+  " 1=enable, 0=disable, -1=toggle
+  if !exists('b:last_autoformat')
+    let b:last_autoformat = 0
+  en
+  let l:nu_af = a:af ==# -1 ? !b:last_autoformat : a:af
+  let l:is_hard =
+     \ exists('b:pencil_wrap_mode') &&
+     \ b:pencil_wrap_mode ==# s:WRAP_MODE_HARD
+  if l:nu_af && l:is_hard
+    aug pencil_autoformat
+      au InsertEnter <buffer> call s:maybe_enable_autoformat()
+      au InsertLeave <buffer> set formatoptions-=a
+    aug END
+  el
+    sil! au! pencil_autoformat * <buffer>
+    if l:nu_af && !l:is_hard
+      echohl WarningMsg
+      echo "autoformat can only be enabled in hard line break mode"
+      echohl NONE
+      return
+    en
+  en
+  let b:last_autoformat = l:nu_af
+endf
+
+" Create mappings for word processing
+" args:
+"   'wrap': 'detect|off|hard|soft|toggle'
+fun! pencil#init(...) abort
+  let l:args = a:0 ? a:1 : {}
+
+  " flag to suspend autoformat for the next Insert
+  let b:pencil_suspend_af = 0
+
+  if !exists('b:pencil_wrap_mode')
+    let b:pencil_wrap_mode = s:WRAP_MODE_OFF
+  en
+  if !exists("b:max_textwidth")
+    let b:max_textwidth = -1
+  en
+
+  " If user explicitly requested wrap_mode thru args, go with that.
+  let l:wrap_arg = get(l:args, 'wrap', 'detect')
+
+  if (b:pencil_wrap_mode && l:wrap_arg ==# 'toggle') ||
+   \ l:wrap_arg =~# '^\(0\|off\|disable\|false\)$'
+    let b:pencil_wrap_mode = s:WRAP_MODE_OFF
+  elsei l:wrap_arg ==# 'hard'
+    let b:pencil_wrap_mode = s:WRAP_MODE_HARD
+  elsei l:wrap_arg ==# 'soft'
+    let b:pencil_wrap_mode = s:WRAP_MODE_SOFT
+  elsei l:wrap_arg ==# 'default'
+    let b:pencil_wrap_mode = s:WRAP_MODE_DEFAULT
+  el
+    " this can return s:WRAP_MODE_ for soft, hard or default
+    let b:pencil_wrap_mode = s:detect_wrap_mode()
+  en
+
+  " translate default(-1) to soft(1) or hard(2) or off(0)
+  if b:pencil_wrap_mode ==# s:WRAP_MODE_DEFAULT
+    if g:pencil#wrapModeDefault =~# '^\(0\|off\|disable\|false\)$'
+      let b:pencil_wrap_mode = s:WRAP_MODE_OFF
+    elsei g:pencil#wrapModeDefault ==# 'soft'
+      let b:pencil_wrap_mode = s:WRAP_MODE_SOFT
+    el
+      let b:pencil_wrap_mode = s:WRAP_MODE_HARD
+    en
+  en
+
+  " autoformat is only used in Hard mode, and then only during
+  " Insert mode
+  call pencil#setAutoFormat(
+        \ b:pencil_wrap_mode ==# s:WRAP_MODE_HARD &&
+        \ get(l:args, 'autoformat', g:pencil#autoformat))
+
+  if b:pencil_wrap_mode ==# s:WRAP_MODE_HARD
+    if &modeline ==# 0 && b:max_textwidth > 0
+      " Compensate for disabled modeline
+      exe 'setl textwidth=' . b:max_textwidth
+    elsei &textwidth ==# 0
+      exe 'setl textwidth=' .
+        \ get(l:args, 'textwidth', g:pencil#textwidth)
+    el
+      setl textwidth<
+    en
+    setl nowrap
+
+    " flag to suspend autoformat for next Insert
+    " optional user-defined mapping
+    if exists('g:pencil#map#suspend_af') &&
+     \ g:pencil#map#suspend_af != ''
+      exe 'no <buffer> <silent> ' . g:pencil#map#suspend_af . ' :let b:pencil_suspend_af=1<CR>'
+    en
+
+  elsei b:pencil_wrap_mode ==# s:WRAP_MODE_SOFT
+    setl textwidth=0
+    setl wrap
+
+    if has('linebreak')
+      setl linebreak
+      " TODO breakat not working yet with n and m-dash
+      setl breakat-=*         " avoid breaking footnote*
+      setl breakat-=@         " avoid breaking at email addresses
+    en
+
+    if exists('&colorcolumn')
+      setl colorcolumn=0      " doesn't align as expected
+    en
+  el
+    setl textwidth<
+    setl wrap< nowrap<
+
+    if has('linebreak')
+      setl linebreak< nolinebreak<
+      setl breakat<
+    en
+
+    if exists('&colorcolumn')
+      setl colorcolumn<
+    en
+  en
+
+  if (  v:version > 704 ||
+   \   (v:version ==# 704 && has('patch-7.4.338')))
+    if b:pencil_wrap_mode ==# s:WRAP_MODE_SOFT
+      setl breakindent
+    el
+      setl breakindent<
+    en
+  en
+
+  " global settings
+  if b:pencil_wrap_mode
+    set display+=lastline
+    set backspace=indent,eol,start
+    if get(l:args, 'joinspaces', g:pencil#joinspaces)
+      set joinspaces         " two spaces after .!?
+    el
+      set nojoinspaces       " only one space after a .!? (default)
+    en
+  en
+
+  " because ve=onemore is relatively rare and could break
+  " other plugins, restrict its presence to buffer
+  " Better: restore ve to original setting
+  if has('virtualedit')
+    if b:pencil_wrap_mode && get(l:args, 'cursorwrap', g:pencil#cursorwrap)
+      set whichwrap+=<,>,b,s,h,l,[,]
+      aug pencil_cursorwrap
+        au BufEnter <buffer> set virtualedit+=onemore
+        au BufLeave <buffer> set virtualedit-=onemore
+      aug END
+    el
+      sil! au! pencil_cursorwrap * <buffer>
+    en
+  en
+
+  " Because syntax for fenced code blocks will mess with the
+  " definition of a word (via iskeyword) we'll impose a prose-
+  " oriented definition.
+  " e.g., let g:markdown_fenced_languages = ['sh',]  " adds '.'
+  "
+  " Support $20 30% D&D #40 highest-rated O'Toole Mary's
+  " TODO how to separate quote from apostrophe use?
+  if b:pencil_wrap_mode
+    aug pencil_iskeyword
+      au BufEnter <buffer> setl isk& | setl isk-=_ | setl isk+=$,%,&,#,-,',+
+    aug END
+  el
+    sil! au! pencil_iskeyword * <buffer>
+  en
+
+  " window/buffer settings
+  if b:pencil_wrap_mode
+    setl nolist
+    setl wrapmargin=0
+    setl autoindent         " needed by formatoptions=n
+    setl indentexpr=
+    if has('smartindent')
+      setl nosmartindent      " avoid c-style indents in prose
+    en
+    if has('cindent')
+      setl nocindent          " avoid c-style indents in prose
+    en
+
+    setl formatoptions+=n   " recognize numbered lists
+    setl formatoptions+=1   " don't break line before 1 letter word
+    setl formatoptions+=t   " autoformat of text (vim default)
+    "setl formatoptions+=2   " preserve indent based on 2nd line for rest of paragraph
+
+    " clean out stuff we likely don't want
+    setl formatoptions-=v   " only break line at blank entered during insert
+    setl formatoptions-=w   " avoid erratic behavior if mixed spaces
+    setl formatoptions-=a   " autoformat will turn on with Insert in HardPencil mode
+    setl formatoptions-=2   " doesn't work with with fo+=n, says docs
+
+    " plasticboy/vim-markdown sets these to handle bullet points
+    " as comments. Not changing for now.
+    "setl formatoptions-=o   " don't insert comment leader
+    "setl formatoptions-=c   " no autoformat of comments
+    "setl formatoptions+=r   " don't insert comment leader
+
+    if has('conceal') && v:version >= 703
+      exe ':setl conceallevel=' .
+        \ get(l:args, 'conceallevel',  g:pencil#conceallevel)
+      exe ':setl concealcursor=' .
+        \ get(l:args, 'concealcursor', g:pencil#concealcursor)
+    en
+  el
+    if has('smartindent')
+      setl smartindent< nosmartindent<
+    en
+    if has('cindent')
+      setl cindent< nocindent<
+    en
+    if has('conceal')
+      setl conceallevel<
+      setl concealcursor<
+    en
+
+    setl indentexpr<
+    setl autoindent< noautoindent<
+    setl list< nolist<
+    setl wrapmargin<
+    setl formatoptions<
+  en
+
+  if b:pencil_wrap_mode ==# s:WRAP_MODE_SOFT
+    nn <buffer> <silent> $ g$
+    nn <buffer> <silent> 0 g0
+    vn <buffer> <silent> $ g$
+    vn <buffer> <silent> 0 g0
+    no <buffer> <silent> <Home> g<Home>
+    no <buffer> <silent> <End>  g<End>
+
+    " preserve behavior of home/end keys in popups
+    call s:imap(1, '<Home>', '<C-o>g<Home>')
+    call s:imap(1, '<End>' , '<C-o>g<End>' )
+  el
+    sil! nun <buffer> $
+    sil! nun <buffer> 0
+    sil! vu  <buffer> $
+    sil! vu  <buffer> 0
+    sil! nun <buffer> <Home>
+    sil! nun <buffer> <End>
+    sil! iu  <buffer> <Home>
+    sil! iu  <buffer> <End>
+  en
+
+  if b:pencil_wrap_mode
+    nn <buffer> <silent> j gj
+    nn <buffer> <silent> k gk
+    vn <buffer> <silent> j gj
+    vn <buffer> <silent> k gk
+    no <buffer> <silent> <Up>   gk
+    no <buffer> <silent> <Down> gj
+
+    " preserve behavior of up/down keys in popups
+    call s:imap(1, '<Up>'  , '<C-o>g<Up>'  )
+    call s:imap(1, '<Down>', '<C-o>g<Down>')
+  el
+    sil! nun <buffer> j
+    sil! nun <buffer> k
+    sil! vu  <buffer> j
+    sil! vu  <buffer> k
+    sil! unm <buffer> <Up>
+    sil! unm <buffer> <Down>
+
+    sil! iu <buffer> <Up>
+    sil! iu <buffer> <Down>
+  en
+
+  " set undo points around common punctuation,
+  " line <c-u> and word <c-w> deletions
+  if b:pencil_wrap_mode
+    ino <buffer> . .<c-g>u
+    ino <buffer> ! !<c-g>u
+    ino <buffer> ? ?<c-g>u
+    ino <buffer> , ,<c-g>u
+    ino <buffer> ; ;<c-g>u
+    ino <buffer> : :<c-g>u
+    ino <buffer> <c-u> <c-g>u<c-u>
+    ino <buffer> <c-w> <c-g>u<c-w>
+
+    " map <cr> only if not already mapped
+    if empty(maparg('<cr>', 'i'))
+      ino <buffer> <cr> <c-g>u<cr>
+      let b:pencil_cr_mapped = 1
+    el
+      let b:pencil_cr_mapped = 0
+    en
+  el
+    sil! iu <buffer> .
+    sil! iu <buffer> !
+    sil! iu <buffer> ?
+    sil! iu <buffer> ,
+    sil! iu <buffer> ;
+    sil! iu <buffer> :
+    sil! iu <buffer> <c-u>
+    sil! iu <buffer> <c-w>
+
+    " unmap <cr> only if we mapped it ourselves
+    if exists('b:pencil_cr_mapped') && b:pencil_cr_mapped
+      sil! iu <buffer> <cr>
+    en
+  en
+endf
+
+" attempt to find a non-zero textwidth, etc.
+fun! s:doOne(item) abort
+  let l:matches = matchlist(a:item, '^\([a-z]\+\)=\([a-zA-Z0-9_\-.]\+\)$')
+  if len(l:matches) > 1
+    if l:matches[1] =~ 'textwidth\|tw'
+      let l:tw = str2nr(l:matches[2])
+      if l:tw > b:max_textwidth
+        let b:max_textwidth = l:tw
+      en
+    en
+  en
+endf
+
+" attempt to find a non-zero textwidth, etc.
+fun! s:doModeline(line) abort
+  let l:matches = matchlist(a:line, '\%(\S\@<!\%(vi\|vim\([<>=]\?\)\([0-9]\+\)\?\)\|\sex\):\s*\%(set\s\+\)\?\([^:]\+\):\S\@!')
+  if len(l:matches) > 0
+    for l:item in split(l:matches[3])
+      call s:doOne(l:item)
+    endfo
+  en
+  let l:matches = matchlist(a:line, '\%(\S\@<!\%(vi\|vim\([<>=]\?\)\([0-9]\+\)\?\)\|\sex\):\(.\+\)')
+  if len(l:matches) > 0
+    for l:item in split(l:matches[3], '[ \t:]')
+      call s:doOne(l:item)
+    endfo
+  en
+endf
+
+" sample lines for detection, capturing both
+" modeline(s) and max line length
+" Hat tip to https://github.com/ciaranm/securemodelines
+fun! s:doModelines() abort
+  if line("$") > &modelines
+    let l:lines={ }
+    call map(filter(getline(1, &modelines) +
+          \ getline(line("$") - &modelines, "$"),
+          \ 'v:val =~ ":"'), 'extend(l:lines, { v:val : 0 } )')
+    for l:line in keys(l:lines)
+      call s:doModeline(l:line)
+    endfo
+  el
+    for l:line in getline(1, "$")
+      call s:doModeline(l:line)
+    endfo
+  en
+endf
+
+" vim:ts=2:sw=2:sts=2
diff --git a/vim/.vim/bundle/pencil/plugin/pencil.vim b/vim/.vim/bundle/pencil/plugin/pencil.vim
new file mode 100644
index 0000000..d157214
--- /dev/null
+++ b/vim/.vim/bundle/pencil/plugin/pencil.vim
@@ -0,0 +1,198 @@
+" ============================================================================
+" File:        pencil.vim
+" Description: vim-pencil plugin
+" Maintainer:  Reed Esau <github.com/reedes>
+" Created:     December 28, 2013
+" License:     The MIT License (MIT)
+" ============================================================================
+"
+if exists('g:loaded_pencil') || &cp | fini | en
+let g:loaded_pencil = 1
+
+" Save 'cpoptions' and set Vim default to enable line continuations.
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:WRAP_MODE_DEFAULT = -1
+let s:WRAP_MODE_OFF     = 0
+let s:WRAP_MODE_HARD    = 1
+let s:WRAP_MODE_SOFT    = 2
+
+fun! s:unicode_enabled()
+  retu &encoding ==# 'utf-8'
+endf
+
+" helper for statusline
+"
+" Note that it shouldn't be dependent on init(), which
+" won't have been called for non-prose modules.
+fun! PencilMode()
+  if exists('b:pencil_wrap_mode')
+    if b:pencil_wrap_mode ==# s:WRAP_MODE_SOFT
+      return get(g:pencil#mode_indicators, 'soft', 'S')
+    elsei b:pencil_wrap_mode ==# s:WRAP_MODE_HARD
+      if &fo =~ 'a'
+        return get(g:pencil#mode_indicators, 'auto', 'A')
+      el
+        return get(g:pencil#mode_indicators, 'hard', 'H')
+      en
+    el
+      return get(g:pencil#mode_indicators, 'off', '')
+    en
+  else
+    return ''   " should be blank for non-prose modes
+  en
+endf
+
+if !exists('g:pencil#wrapModeDefault')
+  " user-overridable default, if detection fails
+  " should be 'soft' or 'hard' or 'off'
+  let g:pencil#wrapModeDefault = 'hard'
+en
+
+if !exists('g:pencil#textwidth')
+  " textwidth used when in hard linebreak mode
+  let g:pencil#textwidth = 74
+en
+
+if !exists('g:pencil#autoformat')
+  " by default, automatically format text when in Insert mode
+  " with hard wrap.
+  let g:pencil#autoformat = 1
+en
+
+if !exists('g:pencil#autoformat_config')
+  " Do not activate autoformat if entering Insert mode when
+  " the cursor is inside any of the following syntax groups.
+  "
+  " markdown* (tpope/vim-markdown)
+  " mkd*, htmlH[0-9] (plasticboy/vim-markdown)
+  " markdownFencedCodeBlock, markdownInlineCode, markdownRule, markdownH[0-9] (gabrielelana/vim-markdown)
+  " mmdTable[A-Za-z0-9]* (mattly/vim-markdown-enhancements)
+  " txtCode (timcharper/textile.vim)
+  " rst*,tex*,asciidoc* (syntax file shipped with vim)
+  let g:pencil#autoformat_config = {
+        \   'markdown': {
+        \     'black': [
+        \       'htmlH[0-9]',
+        \       'markdown(Code|H[0-9]|Url|IdDeclaration|Link|Rule|Highlight[A-Za-z0-9]+)',
+        \       'markdown(FencedCodeBlock|InlineCode)',
+        \       'mkd(Code|Rule|Delimiter|Link|ListItem|IndentCode)',
+        \       'mmdTable[A-Za-z0-9]*',
+        \     ],
+        \     'white': [
+        \      'markdown(Code|Link)',
+        \     ],
+        \   },
+        \   'asciidoc': {
+        \     'black': [
+        \       'asciidoc(AttributeList|AttributeEntry|ListLabel|Literal|SideBar|Source|Sect[0-9])',
+        \       'asciidoc[A-Za-z]*(Block|Macro|Title)',
+        \     ],
+        \     'white': [
+        \      'asciidoc(AttributeRef|Macro)',
+        \     ],
+        \     'enforce-previous-line': 1,
+        \   },
+        \   'rst': {
+        \     'black': [
+        \       'rst(CodeBlock|Directive|LiteralBlock|Sections)',
+        \     ],
+        \   },
+        \   'tex': {
+        \     'black': [
+        \       'tex(BeginEndName|Delimiter|DocType|InputFile|Math|RefZone|Statement|Title)',
+        \       'texSection$',
+        \     ],
+        \     'enforce-previous-line': 1,
+        \   },
+        \   'textile': {
+        \     'black': [
+        \       'txtCode',
+        \     ],
+        \   },
+        \ }
+en
+if !exists('g:pencil#autoformat_aliases')
+  " Aliases used exclusively for autoformat config.
+  " Pencil will NOT modify the filetype setting.
+  let g:pencil#autoformat_aliases = {
+        \    'md': 'markdown',
+        \    'mkd': 'markdown',
+        \  }
+en
+
+if !exists('g:pencil#joinspaces')
+  " by default, only one space after full stop (.)
+  let g:pencil#joinspaces = 0
+en
+
+if !exists('g:pencil#cursorwrap')
+  " by default, h/l and cursor keys will wrap around hard
+  " linebreaks. Set to 0 if you don't want this behavior
+  let g:pencil#cursorwrap = 1
+en
+
+if !exists('g:pencil#conceallevel')
+  " by default, concealing capability in your syntax plugin
+  " will be enabled. See tpope/vim-markdown for example.
+  " 0=disable, 1=onechar, 2=hidecust, 3=hideall
+  let g:pencil#conceallevel = 3
+en
+if !exists('g:pencil#concealcursor')
+  " n=normal, v=visual, i=insert, c=command
+  let g:pencil#concealcursor = 'c'
+en
+
+if !exists('g:pencil#softDetectSample')
+  " if no modeline, read as many as this many lines at
+  " start of file in attempt to detect at least one line
+  " whose byte count exceeds g:pencil#softDetectThreshold
+  let g:pencil#softDetectSample = 20
+en
+
+if !exists('g:pencil#softDetectThreshold')
+  " if the byte count of at least one sampled line exceeds
+  " this number, then pencil assumes soft line wrapping
+  let g:pencil#softDetectThreshold = 130
+en
+
+if !exists('g:pencil#mode_indicators')
+  " used to set PencilMode() for statusline
+  if s:unicode_enabled()
+    let g:pencil#mode_indicators = {'hard': '␍', 'auto': 'ª', 'soft': '⤸', 'off': '',}
+  el
+    let g:pencil#mode_indicators = {'hard': 'H', 'auto': 'A', 'soft': 'S', 'off': '',}
+  en
+en
+
+" Commands
+
+com -nargs=0 Pencil         call pencil#init({'wrap': 'on' })
+com -nargs=0 PencilOff      call pencil#init({'wrap': 'off' })
+com -nargs=0 NoPencil       call pencil#init({'wrap': 'off' })
+com -nargs=0 HardPencil     call pencil#init({'wrap': 'hard'})
+com -nargs=0 PencilHard     call pencil#init({'wrap': 'hard'})
+com -nargs=0 SoftPencil     call pencil#init({'wrap': 'soft'})
+com -nargs=0 PencilSoft     call pencil#init({'wrap': 'soft'})
+com -nargs=0 PencilToggle   call pencil#init({'wrap': 'toggle'})
+com -nargs=0 TogglePencil   call pencil#init({'wrap': 'toggle'})
+com -nargs=0 PFormat        call pencil#setAutoFormat(1)
+com -nargs=0 PFormatOff     call pencil#setAutoFormat(0)
+com -nargs=0 PFormatToggle  call pencil#setAutoFormat(-1)
+
+" NOTE: legacy commands have been disabled by default as of 31-Dec-15
+if !exists('g:pencil#legacyCommands')
+  let g:pencil#legacyCommands = 0
+en
+if g:pencil#legacyCommands
+  com -nargs=0 DropPencil    call pencil#init({'wrap': 'off' })
+  com -nargs=0 AutoPencil    call pencil#setAutoFormat(1)
+  com -nargs=0 ManualPencil  call pencil#setAutoFormat(0)
+  com -nargs=0 ShiftPencil   call pencil#setAutoFormat(-1)
+en
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim:ts=2:sw=2:sts=2
diff --git a/vim/.vim/bundle/pencil/screenshots/demo.gif b/vim/.vim/bundle/pencil/screenshots/demo.gif
new file mode 100644
index 0000000..d9977d8
Binary files /dev/null and b/vim/.vim/bundle/pencil/screenshots/demo.gif differ
diff --git a/vim/.vim/bundle/pencil/screenshots/demo.txt b/vim/.vim/bundle/pencil/screenshots/demo.txt
new file mode 100644
index 0000000..092dfc7
--- /dev/null
+++ b/vim/.vim/bundle/pencil/screenshots/demo.txt
@@ -0,0 +1,7 @@
+
+Captured with Quicktime.
+
+Processed with:
+
+$ ffmpeg -i four.mov -s 700x242 -pix_fmt rgb24 -vf "lutyuv=y=val*1.3" -r 10 -f gif - | \
+  gifsicle --optimize=3 --delay=3  > out.gif
diff --git a/vim/.vim/bundle/sleuth/CONTRIBUTING.markdown b/vim/.vim/bundle/sleuth/CONTRIBUTING.markdown
new file mode 100644
index 0000000..b3f0095
--- /dev/null
+++ b/vim/.vim/bundle/sleuth/CONTRIBUTING.markdown
@@ -0,0 +1 @@
+See the [contribution guidelines for pathogen.vim](https://github.com/tpope/vim-pathogen/blob/master/CONTRIBUTING.markdown).
diff --git a/vim/.vim/bundle/sleuth/README.markdown b/vim/.vim/bundle/sleuth/README.markdown
new file mode 100644
index 0000000..b76d16a
--- /dev/null
+++ b/vim/.vim/bundle/sleuth/README.markdown
@@ -0,0 +1,48 @@
+# sleuth.vim
+
+This plugin automatically adjusts `'shiftwidth'` and `'expandtab'`
+heuristically based on the current file, or, in the case the current file is
+new, blank, or otherwise insufficient, by looking at other files of the same
+type in the current and parent directories.  In lieu of adjusting
+`'softtabstop'`, `'smarttab'` is enabled.
+
+Compare to [DetectIndent][].  I wrote this because I wanted something fully
+automatic.  My goal is that by installing this plugin, you can remove all
+indenting related configuration from your vimrc.
+
+[DetectIndent]: http://www.vim.org/scripts/script.php?script_id=1171
+
+## Installation
+
+If you don't have a preferred installation method, I recommend
+installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
+then simply copy and paste:
+
+    cd ~/.vim/bundle
+    git clone git://github.com/tpope/vim-sleuth.git
+
+## Notes
+
+* Searching for other files of the same type continues up the directory
+  hierarchy until a match is found. This means, for example, the indent for
+  the first file in a brand new Ruby project might very well be derived from
+  your `.irbrc`.  I consider this a feature.
+* If your file is consistently indented with hard tabs, `'shiftwidth'` will be
+  set to your `'tabstop'`.  Otherwise, a `'tabstop'` of 8 is enforced.
+* The algorithm is rolled from scratch, fairly simplistic, and only lightly
+  battle tested.  It's probably not (yet) as good as [DetectIndent][].
+  Let me know what it fails on for you.
+
+## Self-Promotion
+
+Like sleuth.vim?  Follow the repository on
+[GitHub](https://github.com/tpope/vim-sleuth) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=4375).  And if
+you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and
+[GitHub](https://github.com/tpope).
+
+## License
+
+Copyright © Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/sleuth/doc/sleuth.txt b/vim/.vim/bundle/sleuth/doc/sleuth.txt
new file mode 100644
index 0000000..d79a7fe
--- /dev/null
+++ b/vim/.vim/bundle/sleuth/doc/sleuth.txt
@@ -0,0 +1,17 @@
+*sleuth.txt*  Heuristically set buffer options
+
+Author:  Tim Pope <http://tpo.pe/>
+Repo:    https://github.com/tpope/vim-sleuth
+License: Same terms as Vim itself (see |license|)
+
+This plugin is only available if 'compatible' is not set.
+
+SUMMARY                                         *sleuth*
+
+This plugin automatically adjusts 'shiftwidth' and 'expandtab' heuristically
+based on the current file, or, in the case the current file is new, blank, or
+otherwise insufficient, by looking at other files of the same type in the
+current and parent directories.  In lieu of adjusting 'softtabstop',
+'smarttab' is enabled.
+
+ vim:tw=78:et:ft=help:norl:
diff --git a/vim/.vim/bundle/sleuth/plugin/sleuth.vim b/vim/.vim/bundle/sleuth/plugin/sleuth.vim
new file mode 100644
index 0000000..560135e
--- /dev/null
+++ b/vim/.vim/bundle/sleuth/plugin/sleuth.vim
@@ -0,0 +1,171 @@
+" sleuth.vim - Heuristically set buffer options
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      1.1
+" GetLatestVimScripts: 4375 1 :AutoInstall: sleuth.vim
+
+if exists("g:loaded_sleuth") || v:version < 700 || &cp
+  finish
+endif
+let g:loaded_sleuth = 1
+
+function! s:guess(lines) abort
+  let options = {}
+  let heuristics = {'spaces': 0, 'hard': 0, 'soft': 0}
+  let ccomment = 0
+  let podcomment = 0
+  let triplequote = 0
+  let backtick = 0
+
+  for line in a:lines
+
+    if line =~# '^\s*$'
+      continue
+    endif
+
+    if line =~# '^\s*/\*'
+      let ccomment = 1
+    endif
+    if ccomment
+      if line =~# '\*/'
+        let ccomment = 0
+      endif
+      continue
+    endif
+
+    if line =~# '^=\w'
+      let podcomment = 1
+    endif
+    if podcomment
+      if line =~# '^=\%(end\|cut\)\>'
+        let podcomment = 0
+      endif
+      continue
+    endif
+
+    if triplequote
+      if line =~# '^[^"]*"""[^"]*$'
+        let triplequote = 0
+      endif
+      continue
+    elseif line =~# '^[^"]*"""[^"]*$'
+      let triplequote = 1
+    endif
+
+    if backtick
+      if line =~# '^[^`]*`[^`]*$'
+        let backtick = 0
+      endif
+      continue
+    elseif line =~# '^[^`]*`[^`]*$'
+      let backtick = 1
+    endif
+
+    let softtab = repeat(' ', 8)
+    if line =~# '^\t'
+      let heuristics.hard += 1
+    elseif line =~# '^' . softtab
+      let heuristics.soft += 1
+    endif
+    if line =~# '^  '
+      let heuristics.spaces += 1
+    endif
+    let indent = len(matchstr(substitute(line, '\t', softtab, 'g'), '^ *'))
+    if indent > 1 && get(options, 'shiftwidth', 99) > indent
+      let options.shiftwidth = indent
+    endif
+
+  endfor
+
+  if heuristics.hard && !heuristics.spaces
+    return {'expandtab': 0, 'shiftwidth': &tabstop}
+  elseif heuristics.soft != heuristics.hard
+    let options.expandtab = heuristics.soft > heuristics.hard
+    if heuristics.hard
+      let options.tabstop = 8
+    endif
+  endif
+
+  return options
+endfunction
+
+function! s:patterns_for(type) abort
+  if a:type ==# ''
+    return []
+  endif
+  if !exists('s:patterns')
+    redir => capture
+    silent autocmd BufRead
+    redir END
+    let patterns = {
+          \ 'c': ['*.c'],
+          \ 'html': ['*.html'],
+          \ 'sh': ['*.sh'],
+          \ }
+    let setfpattern = '\s\+\%(setf\%[iletype]\s\+\|set\%[local]\s\+\%(ft\|filetype\)=\|call SetFileTypeSH(["'']\%(ba\|k\)\=\%(sh\)\@=\)'
+    for line in split(capture, "\n")
+      let match = matchlist(line, '^\s*\(\S\+\)\='.setfpattern.'\(\w\+\)')
+      if !empty(match)
+        call extend(patterns, {match[2]: []}, 'keep')
+        call extend(patterns[match[2]], [match[1] ==# '' ? last : match[1]])
+      endif
+      let last = matchstr(line, '\S.*')
+    endfor
+    let s:patterns = patterns
+  endif
+  return copy(get(s:patterns, a:type, []))
+endfunction
+
+function! s:apply_if_ready(options) abort
+  if !has_key(a:options, 'expandtab') || !has_key(a:options, 'shiftwidth')
+    return 0
+  else
+    for [option, value] in items(a:options)
+      call setbufvar('', '&'.option, value)
+    endfor
+    return 1
+  endif
+endfunction
+
+function! s:detect() abort
+  if &modifiable == 0
+    return
+  endif
+
+  let options = s:guess(getline(1, 1024))
+  if s:apply_if_ready(options)
+    return
+  endif
+  let patterns = s:patterns_for(&filetype)
+  call filter(patterns, 'v:val !~# "/"')
+  let dir = expand('%:p:h')
+  while isdirectory(dir) && dir !=# fnamemodify(dir, ':h')
+    for pattern in patterns
+      for neighbor in split(glob(dir.'/'.pattern), "\n")[0:7]
+        if neighbor !=# expand('%:p') && filereadable(neighbor)
+          call extend(options, s:guess(readfile(neighbor, '', 256)), 'keep')
+        endif
+        if s:apply_if_ready(options)
+          let b:sleuth_culprit = neighbor
+          return
+        endif
+      endfor
+    endfor
+    let dir = fnamemodify(dir, ':h')
+  endwhile
+  if has_key(options, 'shiftwidth')
+    return s:apply_if_ready(extend({'expandtab': 1}, options))
+  endif
+endfunction
+
+setglobal smarttab
+
+if !exists('g:did_indent_on')
+  filetype indent on
+endif
+
+augroup sleuth
+  autocmd!
+  autocmd FileType * call s:detect()
+augroup END
+
+" vim:set et sw=2:
diff --git a/vim/.vim/bundle/slime b/vim/.vim/bundle/slime
new file mode 160000
index 0000000..7d03749
--- /dev/null
+++ b/vim/.vim/bundle/slime
@@ -0,0 +1 @@
+Subproject commit 7d0374935e7bd4a3a3c2c5d7ac7d70c2650b89ae
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/buf_utils.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/buf_utils.vim
new file mode 100644
index 0000000..d14d404
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/buf_utils.vim
@@ -0,0 +1,24 @@
+" buf_identifier is either a buf_nr or a filename
+" If any window shows the buffer move to the buffer
+" If not show it in current window (by c-w s c^ you can always
+" reshow the last buffer
+"
+" Example: buf_utils#GotoBuf("/tmp/tfile.txt", {'create': 1})
+" returns: The command which was used to switch to the buffer
+fun! buf_utils#GotoBuf(buf_identifier, opts)
+  let buf_nr = bufnr(a:buf_identifier)
+  if buf_nr == -1 && ( get(a:opts, 'create', 0) || has_key(a:opts, 'create_cmd'))
+    exec get(a:opts,'create_cmd','e').' '.fnameescape(a:buf_identifier)
+    return "e"
+  else
+    let win_nr = bufwinnr(buf_nr)
+    if win_nr == -1
+      exec 'b '.buf_nr
+      return "b"
+    else
+      exec win_nr.'wincmd w'
+      return "w"
+    endif
+    wincmd w"
+  endif
+endf
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/cached_file_contents.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/cached_file_contents.vim
new file mode 100644
index 0000000..3fc3ce4
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/cached_file_contents.vim
@@ -0,0 +1,104 @@
+" cached_file_contents.vim
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2010-01-03.
+" @Revision:    0.3.0
+
+"exec vam#DefineAndBind('s:c','g:cache_dir_options','{}')
+if !exists('g:cache_dir_options') | let g:cache_dir_options = {} | endif | let s:c = g:cache_dir_options 
+
+let s:c['cache_dir'] = get(s:c, 'cache_dir', expand('$HOME').'/.vim-cache')
+let s:c['scanned_files'] = get(s:c, 'scanned_files', {})
+let s:scanned_files = s:c['scanned_files']
+
+
+let s:define_cache_file = "let this_dir = s:c['cache_dir'].'/cached-file-contents' | let cache_file = expand(this_dir.'/'.substitute(string([func_as_string, a:file]),'[[\\]{}:/\\,''\"# ]\\+','_','g'))"
+
+" read a file, run function to extract contents and cache the result returned
+" by that function in memory. Optionally the result can be cached on disk as
+" because VimL can be slow!
+"
+" file     : the file to be read
+" func: { 'func': function which will be called by funcref#Call
+"       , 'version' : if this version changes cache will be invalidate automatically
+"       , 'ftime_check': optional, default 1. if set to 0 cache isn't updated when file changes and file is in cache
+"       }
+"
+" default: what to return if file doesn't exist
+" think twice about adding lines. This function is called many times.
+function! cached_file_contents#CachedFileContents(file, func, ...) abort
+  let ignore_ftime = a:0 > 0 ? a:1 : 0
+  " using string for default so that is evaluated when needed only
+  let use_file_cache = get(a:func, 'use_file_cache', 0)
+
+  " simple kind of normalization. necessary when using file caching
+  " this seems to be slower:
+  " let file = fnamemodify(a:file, ':p') " simple kind of normalization. necessary when using file caching
+  " / = assume its an absolute path
+  " let file = a:file[0] == '/' ? a:file : expand(a:file, ':p')
+  let file = a:file[0] == '/' ? a:file : fnamemodify(a:file, ':p') " simple kind of normalization. necessary when using file caching
+  let func_as_string = string(a:func['func'])
+
+  if (!has_key(s:scanned_files, func_as_string))
+    let s:scanned_files[func_as_string] = {}
+  endif
+  let dict = s:scanned_files[func_as_string]
+  if use_file_cache && !has_key(dict, a:file)
+    exec s:define_cache_file
+    if filereadable(cache_file)
+      let dict[file] = eval(readfile(cache_file,'b')[0])
+    endif
+  endif
+  if has_key(dict, a:file)
+    let d = dict[a:file]
+    if use_file_cache
+          \ && (ignore_ftime || getftime(a:file) <= d['ftime'])
+          \ && d['version'] == a:func['version']
+      return dict[a:file]['scan_result']
+    endif
+  endif
+  let scan_result = funcref#Call(a:func['func'], [a:file] )
+  let  dict[a:file] = {"ftime": getftime(a:file), 'version': a:func['version'], "scan_result": scan_result }
+  if use_file_cache
+    if !exists('cache_file') | exec s:define_cache_file | endif
+    if !isdirectory(this_dir) | call mkdir(this_dir,'p',0700) | endif
+    call writefile([string(dict[a:file])], cache_file)
+  endif
+  return scan_result
+endfunction
+
+fun! cached_file_contents#ClearScanCache()
+  let s:c['scanned_files'] = {}
+
+  " Don't run rm -fr. Ask user to run it. It cache_dir may have been set to
+  " $HOME ! (should nevere be the case but who knows
+  echoe "run manually in your shell:  rm -fr ".shellescape(s:c['cache_dir'])."/*"
+endf
+
+fun! cached_file_contents#Test()
+
+  " usually you use a global option so that the function can be reused
+  let my_interpreting_func  = {'func' : funcref#Function('return len(readfile(ARGS[0]))'), 'version': 2, 'use_file_cache':1}
+  let my_interpreting_func2 = {'func' : funcref#Function('return ARGS[0]')               , 'version': 2, 'use_file_cache':1}
+
+  let tmp = tempname()
+  call writefile(['some text','2nd line'], tmp)
+
+  let r = [ cached_file_contents#CachedFileContents(tmp, my_interpreting_func)
+        \ , cached_file_contents#CachedFileContents(tmp, my_interpreting_func2) ]
+   if r != [2, tmp]
+    throw "test failed 1, got ".string(r)
+  endif
+  unlet r
+
+  sleep 3
+
+  " now let's change contents
+  call writefile(['some text','2nd line','3rd line'], tmp)
+
+  let r = cached_file_contents#CachedFileContents(tmp, my_interpreting_func)
+  if 3 != r
+    throw "test failed 2, got ".string(r)
+  endif
+
+  echo "test passed"
+endf
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/env_reload.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/env_reload.vim
new file mode 100644
index 0000000..d8af33a
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/env_reload.vim
@@ -0,0 +1,12 @@
+" in sh/bash you can type export to get a list of environment variables
+" This function assigns those env vars to Vim.
+" Does not delete env vars yet
+" Example: env_reload#ReloadEnv(system("sh -c 'export'")
+fun! env_reload#ReloadEnv(bash_export_command_output)
+  for i in split(a:bash_export_command_output,"\n")
+    let m = matchlist(i, 'export \([^=]\+\)="\(.*\)"')
+    if empty(m) | continue | endif
+    " don't care about quoted values right now.
+    exec 'let $'.m[1].'='.string(m[2])
+  endfor
+endf
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/funcref.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/funcref.vim
new file mode 100644
index 0000000..20eec54
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/funcref.vim
@@ -0,0 +1,95 @@
+" funcref.vim
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2010-01-03.
+" @Revision:    0.1.0
+
+" documentation see doc/funcref.txt
+
+" usage:
+"  funcref#Function("filename#Function")
+"  optionally pass arguments:
+"  funcref#Function("filename#Function",{'args': [2]})
+"  optionally define self:
+"  funcref#Function("filename#Function",{'self': object})
+function! funcref#Function(name,...)
+  let d = a:0 > 0 ? a:1 : {}
+  let d['faked_function_reference'] = a:name
+  return d
+endfunction
+
+" args : same as used for call(f,[args], self)
+" f must be either
+"   - a string which can be evaled (use "return 'value'" to return a value)
+"   - a Vim function reference created by function('..')
+"   - a faked function reference created by funcref#Function(..)
+"
+" the last "self" argument can be overriden by the function reference
+" You can pass arguments in a closure like style
+function! funcref#Call(...)
+  let args = copy(a:000)
+
+  " add parameters:
+  if (len(args) < 2)
+    call add(args, [])
+  endif
+
+
+  let isDict = type(args[0]) == type({})
+
+  " prepend parameters which were passed by faked function reference:
+  if isDict &&  has_key(args[0], 'args')
+    let args[1] = args[0]['args']+args[1]
+  endif
+
+  " always pass self. this way you can call functions from dictionaries not
+  " refering to self
+  if (len(args) < 3)
+    call add(args, {})
+  endif
+
+  " the funcref overrides self:
+  if isDict && has_key(args[0], 'self')
+    let args[2] = args[0]['self']
+  endif
+
+  if type(a:1) == 2
+    " funcref: function must have been laoded
+    return call(function('call'), args)
+  elseif isDict && has_key(args[0], 'faked_function_reference')
+    let Fun = args[0]['faked_function_reference']
+    if type(Fun) == type('')
+        \ && (Fun[:len('return ')-1] == 'return ' 
+              \ || Fun[:len('call ')-1] == 'call '
+              \ || Fun[:len('if ')-1] == 'if '
+              \ || Fun[:len('let ')-1] == 'let '
+              \ || Fun[:len('echo ')-1] == 'echo '
+              \ || Fun[:len('exec ')-1] == 'exec '
+              \ || Fun[:len('debug ')-1] == 'debug ')
+      " it doesn't make sense to list all vim commands here
+      " So if you want to execute another action consider using 
+      " funcref#Function('exec  '.string('aw')) or such
+
+      " function is a String, call exec
+      let ARGS = args[1]
+      let SELF = args[2]
+      exec Fun
+    else 
+      " pseudo function, let's load it..
+      if type(Fun) == 1
+        if !exists('*'.Fun)
+          " lazily load function
+          let file = substitute(substitute(Fun,'#[^#]*$','',''),'#','/','g')
+          exec 'runtime /autoload/'.file.'.vim'
+        endif
+        let Fun2 = function(Fun)
+      else
+        let Fun2 = Fun
+      endif
+      let args[0] = Fun
+      return call(function('call'), args)
+    endif
+  else
+    " no function, return the value
+    return args[0]
+  endif
+endfunction
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/glob.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/glob.vim
new file mode 100644
index 0000000..9a0f79a
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/glob.vim
@@ -0,0 +1,27 @@
+exec vam#DefineAndBind('s:c','g:glob_like', '{}')
+
+" ignore vcs stuff, Don't think you want those..
+let s:c['regex_ignore_directory'] = '\<\%([_.]darcs\|\.git\|.svn\|.hg\|.cvs\|.bzr\)\>'
+let s:c['glob_cache'] = get(s:c, 'glob_cache', {})
+let s:glob_cache = s:c['glob_cache']
+
+fun! glob#Glob(pattern, ...)
+  let pattern = a:pattern
+  if pattern[0] == '~'
+    let pattern = $HOME.pattern[1:]
+  endif
+  let opts = a:0 > 0 ? a:1 : {}
+  " never cache current directory. You're very likely to edit files in it.
+
+  let c = getcwd()
+  let cachable = get(opts, 'cachable', 0) && pattern[:len(c)-1] != c
+  if cachable && has_key(s:glob_cache, pattern)
+    return s:glob_cache[pattern]
+  endif
+
+  " FIXME: don't recurse into \.git directory (thus reimplement glob in vimL!)
+  let r = filter(split(glob(pattern),"\n"),'v:val !~ '.string(s:c['regex_ignore_directory']))
+  if cachable | let s:glob_cache[pattern]  = r | endif
+  return r
+endf
+
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tiny_cmd.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tiny_cmd.vim
new file mode 100644
index 0000000..052bbe0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tiny_cmd.vim
@@ -0,0 +1,19 @@
+" vim suffers:
+
+exec vam#DefineAndBind('s:c','g:vim_tiny_cmd', '{}')
+
+fun! tiny_cmd#Put(a)
+  let new = get(s:c,'next',0) +1
+  let s:c['next'] = new
+  let s:c[new] = a:a
+  return new
+endf
+
+fun! tiny_cmd#Get(nr)
+  return s:c[a:nr]
+endf
+
+" Get and remove item
+fun! tiny_cmd#Pop(nr)
+  let r = s:c[a:nr] | unlet s:c[a:nr] | return r
+endf
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tovl/scratch_buffer.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tovl/scratch_buffer.vim
new file mode 100644
index 0000000..217dca1
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tovl/scratch_buffer.vim
@@ -0,0 +1,103 @@
+" old code
+
+augroup TOVLWrite
+augroup end
+
+" =========== scratch buffer =========================================
+" a scratch buffer is a temporary buffer where the user can enter some text
+" It can be used to get commit messages, edit configuration options and so on
+
+function! tovl#scratch_buffer#KeepIntactLineNr()
+  let i = 0
+  while getline(i)!= b:keepIntact && i < line('$')
+    let i = i+1
+  endwhile
+  if i > line('$')
+    return -1
+  else
+    return i
+  endif
+endfunction
+
+" opens a buffer and runs an action when the buffer is written
+" keys: 
+"  name :   the name of the buffer
+"  onWrite : will be called on write
+"            onWrite is responsible for setlocal nomodified to indicate that
+"            saving has been successful
+"  help  : callback returning additional information lines
+"  getContent : callback returning lines
+"  cmds    : extra commands to be run (optional)
+"            (maybe you prefer adding them the default way afer the
+"            ScratchBuffer call. They'll be rerun on GetContents
+"  sp_cmd  : the command to use to create the new buffer. Defaults to :e
+"  buftype : ...
+"  modifiable : 1 / 0 defaults to 1
+function! tovl#scratch_buffer#ScratchBuffer(opts)
+  let a:opts['name'] = get(a:opts,'name', 'strach_buffer_without_name')
+  exec get(a:opts, 'sp_cmd', 'e').' '.escape(a:opts['name'],' ')
+  let b:settings = a:opts
+  let b:settings['modifiable'] = get(a:opts,'modifiable', 1)
+  setlocal buftype=acwrite
+  command! -buffer -nargs=0 Help call tovl#scratch_buffer#Help()
+
+  " setup write notification
+  au TOVLWrite BufWriteCmd <buffer> call tovl#scratch_buffer#Write()
+
+  if has_key(a:opts,'getContent')
+    command! -buffer -nargs=0 GetContents call tovl#scratch_buffer#GetContents()
+    GetContents
+    if !b:settings['modifiable']
+      setlocal nomodifiable
+    endif
+  endif
+  "let u=&undolevels
+  "setlocal undolevels=-1
+  "exec 'setlocal undolevels='.u
+
+  " mark buffer as not modified
+  setlocal nomodified
+
+  au BufReadCmd <buffer> GetContents
+
+  " run addittional commands
+  for cmd in get(a:opts,'cmds',[])
+    exec cmd
+  endfor
+  silent echo get(a:opts,'echo_help', "type :Help for help")
+endfunction
+
+" =========== utility functions ======================================
+
+function! tovl#scratch_buffer#Write()
+  if has_key(b:settings, 'onWrite')
+    call funcref#Call(b:settings['onWrite'])
+  else
+    echo "don't know how to write. Option hasn't been passed"
+  endif
+endfunction
+
+function! tovl#scratch_buffer#GetContents()
+  setlocal modifiable
+  " empty buffer
+  %g!//d
+  call append(0, funcref#Call(b:settings['getContent']))
+  if !b:settings['modifiable']
+    setlocal nomodifiable
+  endif
+  for cmd in get(b:settings,'cmds',[])
+    exec cmd
+  endfor
+endfunction
+
+function! tovl#scratch_buffer#Help()
+  let help = ["use :e! to reload contents, ZZ or :w(q) to write and quit"
+          \ ,""
+          \ ,"Help for this scratch buffer:"
+          \ ,"=======================================================","",""]
+    \ + funcref#Call(get(b:settings, 'help', []))
+  call tovl#scratch_buffer#ScratchBuffer({
+        \ 'name' : "return Help of ".b:settings['name'],
+        \ 'getContent' : help
+        \ })
+endfunction
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tovl/ui/filter_list.vim b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tovl/ui/filter_list.vim
new file mode 100644
index 0000000..74b2ab4
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/autoload/tovl/ui/filter_list.vim
@@ -0,0 +1,473 @@
+" OLD CODE !
+" I should contribute the multiple filter feature to tlib
+
+" filter list displays a list of items
+" you can white / black filter them by regular expressions (similar to the
+" tlib TToC command
+" However you can edit the filters afterwards and select the cols which should
+" be shown
+
+fun! tovl#ui#filter_list#ListTest()
+  call tovl#ui#filter_list#ListView({
+	\ 'aligned' : 1,
+	\ 'Continuation' : funcref#Function('echo string(ARGS[0])'),
+	\ 'items' : [ {"aa" : "a\nAAAAAAAAAAA", 'bb' : "bbbbbbbbbbbbb\nB" }, 
+		   \  {"aa" : "2a\n2AAAAAAAAAAAA", "bb" : "2 bbbbbbbbbbbbb\n2B"},
+		   \  {"aa" : "XXX", "bb" : "YY"} ],
+	\ })
+
+endfun
+
+fun! s:Intersection(a, b)
+  return filter(copy(a:a), 'index(a:b, v:val) >= 0')
+endf
+
+fun! tovl#ui#filter_list#ListTestGotoLineCurrentBuf()
+  let nr=1
+  let lines = []
+  for l in getline(0,line('$'))
+    call add(lines, {'nr': nr, 'line' :l})
+    let nr = nr +1
+  endfor
+  call tovl#ui#filter_list#ListView({
+	\ 'aligned' : 0,
+	\ 'keys' : ['nr','line'],
+	\ 'number' : 1,
+	\ 'selectByIdOrFilter' : 1,
+	\ 'Continuation' : funcref#Function('exec ARGS[0]["nr"]'),
+	\ 'items' : lines,
+	\ })
+endfun
+
+" opens a new filtered list
+" keys of opts parameters:
+" Continuation: This function will be called with the selected items
+" items: { key : (string or dict) }
+"        items willl be modified. use copy(youritems) as argument to prevent
+"        this. An item is either a string or a dict 
+"        (eg {'file' : .., 'line': ... , 'msg' : .. )
+" keys: list of keys to be shown (optional)
+" filter: list of inital filters which must be applied
+" contains [ { filter: .. , keep : .. }, ] see FilterItems() below
+" aligned: default 0
+" sp_cmd: the command to be used to create the new buffer (default ':e')
+" init : 0 / 1 (default 1): wether to show the view right now
+" number: 0 /1 (default 1): number items ?
+" selectByIdOrFilter: 1: start in getchar() loop so that the user can select
+"                        the item even faster
+"                     auto: only do this if all items fit on screen
+"                     (recommend)
+" cmds: extra cmds to be run
+" cursorAt : at which item to put the cursor?
+"
+" If you don't like the default view you can override UpdateDisplay
+"
+" Usage examples of this list control:
+" - db results
+" - replacement of the quickfix window
+" - select a buffer etc
+fun! tovl#ui#filter_list#ListView(opts)
+  " ActivateAddons theonevimlib
+  let d = {}
+  let d.items = a:opts.items
+  let d.cursorAt = get(a:opts, 'cursorAt', 0)
+  let d.aligned = get(a:opts, 'aligned', 0)
+  let d.sep = '  '
+  let d.filter = get(a:opts, 'filter', [])
+  " using sp because of bd! (FIXME)
+  let d.sp_cmd = get(a:opts, 'sp_cmd', 'sp')
+  let d.allKeys = {}
+  let d.closeOnContinuation = get(a:opts,'closeOnContinuation',1)
+  " don't recommend OnSingleMatch, use OnSingleMatchCR instead
+  let d.continueOnSingleMatch = get(a:opts, 'continueOnSingleMatch',0)
+  let d.continueOnSingleMatchCR = get(a:opts, 'continueOnSingleMatchCR',1)
+  let d.selectByIdOrFilter = get(a:opts, 'selectByIdOrFilter', 0)
+  let d.linesToItems = {}
+  let d.number = get(a:opts, 'number', 1)
+  let d.cmds = get(a:opts, 'cmds', [])
+  let d.syn_cmds = get(a:opts, 'syn_cmds', [])
+
+  if has_key(a:opts,'keys') | let d.keys = a:opts.keys | endif
+  if has_key(a:opts,'Continuation') | let d.Continuation = a:opts.Continuation | endif
+
+  " cache already filtered items in case we want to view really long results
+  " contains [ { filter : { regex: .. , keep : .. } , items : .. , cursorAt :}, 
+  "            { filter : { ... } , items: .. , cursorAt : }
+  let d.cached = []
+  " id of buffer
+  let d.buffer = -1
+  let d.modeText = ''
+
+  fun d.HelpText()
+    return [ "you've entered the the help of the powerful filtered view buffer",
+	   \ "",
+	   \ "type f to start filtering items by regex",
+	   \ "type F to start dropping items by regex",
+	   \ "k / K will ask you for the key to apply the filter to first",
+	   \ "apply the filter by <cr> and press <cr> again to select item",
+	   \ "",
+	   \ "use :ShowAppliedFilters to list active filters",
+	   \ "use :ToggleAlignment to toggle alignment",
+	   \ "",
+	   \ "TODO: Implement sorting, implement interface to change keys (displayed columns)"
+	   \ ]
+  endfun
+
+  " create new scratch buffer
+  " preprocess items calculating line count and maxwidth for all items
+  fun d.NewBufferAndInit()
+    let self.bufferId = bufnr(bufname('%'))
+    for idx in range(0,len(self.items)-1)
+      if type(self.items[idx]) != 4
+	" no dict yet, make it one
+	let self.items[idx] = {'string_line' : self.items[idx]}
+      endif
+      let new = {}
+      for [k,v] in items(self.items[idx])
+	let lines = split(v,"\n")
+	let self.items[idx][k] = { 'text' : v, 'rows' : len(lines), 'cols' : max(map(copy(lines),'len(v:val)')), 'lines' : lines }
+	let self.allKeys[k] = 1
+        unlet k v
+      endfor
+    endfor
+    call tovl#scratch_buffer#ScratchBuffer({
+	  \ 'help' : funcref#Function(self.HelpText,{ 'self' : self }),
+	  \ 'sp_cmd' : self.sp_cmd,
+	  \ 'cmds' : self.cmds
+	  \ })
+    " I assume we have some kind of formatting anyway. Thus breaking lines is bad!
+    set nowrap
+    setlocal cursorline
+    let b:filtered_view = self
+    command! -buffer -nargs=0 ToggleAlignment call b:filtered_view.ToggleAlignment()
+    command! -buffer -nargs=0 ShowAppliedFilters call b:filtered_view.ShowAppliedFilters()
+    command! -buffer -nargs=0 RemoveFilters call b:filtered_view.RemoveFilters()
+    noremap <buffer> f :call b:filtered_view.FilterFromKeyboard(1,'')<cr>
+    " noremap <buffer> f :call b:filtered_view.FilterFromKeyboard(1)<cr>
+    noremap <buffer> F :call b:filtered_view.FilterFromKeyboard(0,'')<cr>
+    if has_key(self,'Continuation')
+      nnoremap <buffer> <cr> :call b:filtered_view.Continue()<cr>
+    endif
+    "noremap <buffer> k
+    "noremap <buffer> K
+
+    let [items, cursorAt] = self.FilteredItems()
+    " len(items) is an approximation because one item can have multiple
+    " lines.. However adding the lines first to check takes too much time
+    if self.selectByIdOrFilter == 1 || (self.selectByIdOrFilter == 'auto' && winheight('%') > len(items) )
+      call self.SelectByIdOrFilter()
+    else
+      " user should choose how to proceed
+      call self.UpdateDisplay()
+    endif
+  endfun
+
+  " user interface
+  fun d.ToggleAlignment()
+    let self.aligned = !self.aligned
+    call self.UpdateDisplay()
+  endfun
+  fun d.ShowAppliedFilters()
+    for i in self.filter | echo string(i) | endfor
+  endfun
+  fun d.RemoveFilters()
+    let self.filter = []
+    call self.UpdateDisplay()
+  endfun
+  fun d.Continue()
+    let item = self.CurrentItem()
+    call self.DoContinue(item)
+  endfun
+  fun d.DoContinue(v)
+    if self.closeOnContinuation | bw! | endif
+    call funcref#Call(self.Continuation,[a:v])
+  endfun
+
+  fun d.MapToOriginal(v)
+    if has_key(a:v, 'string_line')
+      return a:v.string_line.text
+    else
+      let d = {}
+      for [k,v] in items(a:v)
+	let d[k] = v.text
+	unlet k v
+      endfor
+      return d
+    endif
+  endfun
+
+  fun d.CurrentItem()
+    let idx=line('.')-len(self.headerLines)
+    while idx >= 0
+      if has_key(self.linesToItems, idx)
+	return self.MapToOriginal(self.FilteredItems()[0][self.linesToItems[idx]])
+      else
+	let idx = idx -1
+      endif
+    endwhile
+    throw "internal error, couldn't determine selected item!"
+  endfun
+
+  " updates the filter cache and returns the final filtered items
+  fun d.FilteredItems()
+    " update cache
+    let idx = 0
+    let [items, cursorAt] = [self.items, self.cursorAt]
+    for idx in range(0, len(self.filter)-1)
+      if idx +1 > len(self.cached) || self.cached[idx]['filter'] != self.filter[idx]
+	let self.cached = self.cached[:idx-1]
+	let [items, cursorAt] = self.FilterItem(copy(items), self.filter[idx], cursorAt)
+	call add(self.cached, { 'cursorAt' : cursorAt, 'items' : items, 'filter' : self.filter[idx]})
+      else
+        let ci = self.cached[idx]
+	let [items, cursorAt] = [ci['items'], ci['cursorAt']]
+      endif
+    endfor
+    return [items, cursorAt]
+  endfun
+
+  " calling this will return a set of lines which are expected to be the new
+  " buffer contents. The self.linesToItems dict is updated
+  fun d.UpdateDisplay()
+
+    if empty(self.filter)
+      let self.statusline= 'no filter applied, :Help for help'
+    else
+      let self.statusline = len(self.filter).' '.string(self.filter[-1])
+    endif
+
+    let self.linesToItems = {}
+    let [items, cursorAt] = self.FilteredItems()
+    "let num_width = printf('%.0f', trunc(log10(len(items))+1))
+    let num_width = 4
+    if self.aligned
+      " get column width.. (probably will not work with unicde characters.. I
+      " don't have a better solution)
+      let maxlens={}
+      for i in items
+	for [k,v] in items(i)
+	  if get(maxlens,k,0) < v.cols
+	    let maxlens[k] = v.cols
+	  endif
+	endfor
+      endfor
+    endif
+
+    " format lines
+    let self.headerLines = [self.modeText]
+    let lines = copy(self.headerLines)
+    let lines_count = 0
+    if self.number
+      let fmt_startA = '%'.num_width.'s)'
+      let fmt_startB = '%'.num_width.'s'
+    else
+      let fmt_startA = '' | let fmt_startB = ''
+    endif
+    let cursorAtLine = 1 " sane default
+    for idx in range(0,len(items)-1)
+      let self.linesToItems[lines_count + 1] = idx
+      let i = items[idx]
+      let keys = has_key(self,'keys')
+	    \ ? s:Intersection(self.keys, keys(i))
+	    \ : keys(i)
+      let fmt = ''
+      let args =  [i]
+      let cols = []
+      for k in keys
+	let fmt .= self.sep.'%-'.(self.aligned ? maxlens[k] : i[k]['cols']).'s'
+	call add(cols, i[k])
+      endfor
+      for row in range(0, max([1] + map(copy(cols),'v:val["rows"]'))-1)
+	let fmt_args = row == 0 ? [fmt_startA.fmt] :  [fmt_startB.fmt]
+	if self.number
+	  call add(fmt_args, row == 0 ? idx : '')
+	endif
+	for c in cols
+	  call add(fmt_args, c.rows <= row ? '' : c.lines[row])
+	endfor
+	call add(lines, call('printf', fmt_args))
+	let lines_count += 1
+      endfor
+      if idx == cursorAt
+        let cursorAtLine = lines_count
+      endif
+    endfor
+    " update stauts line to show last applied filter
+    " disabled cause it causes trouble on :wincmd w
+    " setlocal statusline=%!b:filtered_view.statusline
+
+    " syntax
+    syn clear
+    for s in self.syn_cmds | exec s | endfor
+    let id = 0
+    " highlight filter regex in buffer as well
+    let syn_ids = [ 'Underlined', 'Todo', 'Error', 'Type', 'Statement' ]
+    for f in self.filter
+      if !f.keep || !has_key(f, 'regex') | continue | endif
+      if f.regex != ''
+        try
+	exec 'syn match '.syn_ids[id % len(syn_ids)].' '.string(f.regex)
+        catch /.*/
+          " ignore errors such as \ without following characters. Thus just
+          " ignore and wait for the next character
+        endtry
+      endif
+      let id = id +1
+    endfor
+    if len(lines) > winheight('%')
+      call extend(lines, self.headerLines)
+    endif
+    normal ggdG
+    call append(0, lines)
+    " place cursor
+    exec (cursorAtLine+1)
+    " move cursor into the middle of the window
+    normal zz
+  endf
+
+  " filter = keys :
+  "  filter = string to be executed containing Val
+  "  keep = 1  keep on match 
+  "       = 0  drop on match
+  "  key (optional)
+  "  cursorAt: at which item to put the cursor
+  "            if that item is deleted it will be placed at the item above
+  " optional: key of dict if dict
+  fun d.FilterItem(items, filter, cursorAt)
+    let filter = 'Val =~ '.string(a:filter.regex)
+    let keep = a:filter.keep
+    let cursorAt = a:cursorAt
+
+    for idx in reverse(range(0, len(a:items)-1))
+      let i = a:items[idx]
+      if has_key(a:filter,'key')
+	let key = a:filter.key
+	if has_key(i, key)
+	  " key given, only filter by this column
+	  let Val = i[key]['text']
+	  exec 'let any = '.filter
+	else
+	  let any = 0
+	endif
+      else
+	let any = 0
+	" no key given, try all
+	for x in values(i)
+	  let Val = x['text']
+	  exec 'let any =  '.filter
+	  if any | break | endif
+	endfor
+      endif
+      if any != keep
+	call remove(a:items, idx)
+        if idx <= cursorAt
+          let cursorAt = cursorAt -1
+        endif
+      endif
+    endfor
+    return [a:items, cursorAt]
+  endfun
+
+  " if the user enters a number select by index else start filtering..
+  fun d.SelectByIdOrFilter()
+    let idx=''
+    let items = self.FilteredItems()[0]
+    try
+      let self.modeText = '[0-9]* : select by index| <esc>: escape getchar() loop, any char: start filtering'
+      call self.UpdateDisplay() | redraw
+      while 1
+	let c=getchar()
+	if index([13,10],c) >= 0
+	  return self.DoContinue(self.MapToOriginal(items[idx]))
+	elseif index([27], c) >=0
+	  " esc, abort
+	  return
+	else
+	  if type(c) == 0
+	    let c = nr2char(c)
+	  endif
+	  if c == "\<bs>" || index(map(range(0,10),'v:val.""'),c) >= 0
+	    if c == "\<bs>"
+	      let idx = idx[:-2]
+	    else
+	      let idx .= c
+	    endif
+	    if idx < len(items) && idx.'0' > len(items) || idx == 0 && len(items) < 10
+	      " only match
+	      return self.DoContinue(self.MapToOriginal(items[idx]))
+	    endif
+	  else
+	    return self.FilterFromKeyboard(1,c)
+	  endif
+	endif
+      endwhile
+    finally
+      let self.modeText = ''
+    endtry
+  endfun
+
+  " gets a regular expresion filter by keybaord and updates the display while
+  " you're typing. The regex ist shown in the statusline
+  fun d.FilterFromKeyboard(keep, start, ...)
+    let self.modeText = 'press ESC to exit getchar() loop'
+    call self.UpdateDisplay() | redraw
+
+    try
+      let key_text = a:0 > 0 ? 'key : '.a:1 : ''
+      let filter_bak = self.filter
+      let filter = copy(self.filter)
+      let start = a:start
+      let filter_new = ''
+      while 1
+	if start != ''
+	  " use c= last char to force updating display etc
+	  let filter_new = start[:-2]
+	  let c = start[-1:]
+	  let start = ''
+	else
+	  let c=getchar()
+	endif 
+	if index([13,10],c) >= 0
+	  " c-j or return, accept new filter
+	  let items = self.FilteredItems()
+	  if len(items) == 1 && has_key(self, 'Continuation') && self.continueOnSingleMatchCR
+	    call self.DoContinue(self.MapToOriginal(items[0]))
+	  endif
+	  return
+	elseif index([27], c) >=0
+	  " esc, abort
+	  let self.filter = filter_bak
+	  call self.UpdateDisplay()
+	  return
+	else
+	  if type(c) == 0
+	    let c = nr2char(c)
+	  endif
+	  if c == "\<bs>"
+	    let filter_new = filter_new[:-2]
+	  else
+	    let filter_new .= c
+	  endif
+	  let d = {'keep' : a:keep, 'regex' : filter_new }
+	  if a:0 > 0
+	    let d['key'] = a:1
+	  endif
+	  let self.filter = copy(filter_bak)
+	  call add(self.filter, d)
+	  let items = self.FilteredItems()
+	  if len(items) == 1 && has_key(self, 'Continuation') && self.continueOnSingleMatch
+	    call self.DoContinue(self.MapToOriginal(items[0]))
+	    return
+	  endif
+	  call self.UpdateDisplay() | redraw
+	endif
+      endwhile
+    finally
+      let self.modeText = ''
+    endtry
+  endfun
+
+  if get(a:opts,'init',1)
+    call d.NewBufferAndInit()
+  endif
+endfun
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/doc/cached_file_contents.txt b/vim/.vim/bundle/snipmate-addon-mw-utils/doc/cached_file_contents.txt
new file mode 100644
index 0000000..a47a8cf
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/doc/cached_file_contents.txt
@@ -0,0 +1,7 @@
+*cached_file_contents*  read contents of a file then cache extracted data
+                    Author: Marc Weber, marco-oweber@gmx.de
+
+-----------------------------------------------------------------------
+HOWTO~
+
+  see cached_file_contents#Test()
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/doc/funcref.txt b/vim/.vim/bundle/snipmate-addon-mw-utils/doc/funcref.txt
new file mode 100644
index 0000000..cb366d0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/doc/funcref.txt
@@ -0,0 +1,35 @@
+*funcref*   create lazier function references. Pass arguments to create closure
+            like function calls
+                    Author: Marc Weber, marco-oweber@gmx.de
+
+-----------------------------------------------------------------------
+HOWTO~
+
+Use *funcref#Function* to create a special dict called
+*faked-function-reference* which can be called by *funcref#Call*
+>
+    { 'faked_function_reference': 'file#FuncName' }
+<   passing some arguments and / or self: >
+    { 'faked_function_reference': 'MyFunc', 'args': [1,2], 'self' : { a object ] }
+<   You can also create lambda like functions which will be evaled: >
+    { 'faked_function_reference': 'return ARGS[1]' }
+
+REASONS ~
+  Creating a Vim funcref pointing to an autoload function will make Vim source
+  that file. This is not lazy enough. (Seems to be no longer true? Has this changed?)
+
+  A Vim function reference neither allows attaching arguments nor self.
+
+  Don't care about case of variables. Normally when using Vim function
+  references you have to use variable names starting with an upper case letter
+  (E704)
+
+Example: ~
+>
+  let f = funcref#Function('return ARGS[0].ARGS[1].SELF["key"]',{'args':[3], 'self':{'key': 'value'} })
+  echo funcref#Call(f, [2])
+  " prints  "32value"
+
+  echo funcref#Call('no value')
+< 
+  echo funcref#Call(f, [2])
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/doc/tiny_cmd.txt b/vim/.vim/bundle/snipmate-addon-mw-utils/doc/tiny_cmd.txt
new file mode 100644
index 0000000..bc6e002
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/doc/tiny_cmd.txt
@@ -0,0 +1,18 @@
+*tiny-cmd*  make long commands short so that they hopefully no longer trigger "press Enter .. [ok]"
+                    Author: Marc Weber, marco-oweber@gmx.de
+
+-----------------------------------------------------------------------
+HOWTO~
+
+Problem: >
+  exec 'map <F2> :silent! let g:g="'.repeat('foobar ',200).'"<cr>'
+Now run the mapping by pressing <F2> and you notice what I'm talking about
+
+Solution (Example):
+
+
+Example usage: >
+  let nr = tiny_cmd#Put('let g:g="'.repeat('foobar ',200).'"')
+  exec 'map <F2> :exec tiny_cmd#Get('.nr.')<cr>'
+< 
+Use Pop instead of Get if you use this command once only
diff --git a/vim/.vim/bundle/snipmate-addon-mw-utils/vim-addon-mw-utils-addon-info.txt b/vim/.vim/bundle/snipmate-addon-mw-utils/vim-addon-mw-utils-addon-info.txt
new file mode 100644
index 0000000..0b20bb3
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-addon-mw-utils/vim-addon-mw-utils-addon-info.txt
@@ -0,0 +1,9 @@
+{
+  "name" : "vim-addon-mw-utils",
+  "version" : "0.0",
+  "author" : "Marc Weber <marco-oweber@gmx.de>",
+  "maintainer" : "Marc Weber <marco-oweber@gmx.de>",
+  "repository" : {"type": "git", "url": "git://github.com/MarcWeber/vim-addon-manager-known-repositories.git"},
+  "dependencies" : {},
+  "description" : "various utils such as caching interpreted contents of files or advanced glob like things"
+}
diff --git a/vim/.vim/bundle/snipmate-tlib/CHANGES.TXT b/vim/.vim/bundle/snipmate-tlib/CHANGES.TXT
new file mode 100644
index 0000000..84357bf
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/CHANGES.TXT
@@ -0,0 +1,755 @@
+0.1
+Initial release
+
+0.2
+- More list convenience functions
+- tlib#EditList()
+- tlib#InputList(): properly handle duplicate items; it type contains 
+'i', the list index + 1 is returned, not the element
+
+0.3
+- tlib#InputList(): Show feedback in statusline instead of the echo area
+- tlib#GetVar(), tlib#GetValue()
+
+0.4
+- tlib#InputList(): Up/Down keys wrap around list
+- tlib#InputList(): FIX: Problem when reducing the filter & using AND
+- tlib#InputList(): Made <a-numeric> work (can be configured via 
+- tlib#InputList(): special display_format: "filename"
+- tlib#Object: experimental support for some kind of OOP
+- tlib#World: Extracted some functions from tlib.vim to tlib/World.vim
+- tlib#FileJoin(), tlib#FileSplit(), tlib#RelativeFilename()
+- tlib#Let()
+- tlib#EnsureDirectoryExists(dir)
+- tlib#DirName(dir)
+- tlib#DecodeURL(url), tlib#EncodeChar(char), tlib#EncodeURL(url)
+- FIX: Problem when using shift-up/down with filtered lists
+
+0.5
+- tlib#InputList(): FIX: Selecting items in filtered view
+- tlib#InputList(): <c-bs>: Remove last AND pattern from filter
+
+0.6
+- tlib#InputList(): Disabled <c-space> map
+- tlib#InputList(): try to be smart about user itentions only if a 
+list's length is < g:tlib_sortprefs_threshold (default: 200)
+- tlib#Object: Super() method
+- tlib#MyRuntimeDir()
+- tlib#GetCacheName(), tlib#CacheSave(), tlib#CacheGet()
+- tlib#Args(), tlib#GetArg()
+- FIX: tlib#InputList(): Display problem with first item
+
+0.7
+- tlib#InputList(): <c-z> ... Suspend/Resume input
+- tlib#InputList(): <c-q> ... Input text on the command line (useful on 
+slow systems when working with very large lists)
+- tlib#InputList(): AND-pattern starting with '!' will work as 'exclude 
+matches'
+- tlib#InputList(): FIX <c-bs> pop OR-patterns properly
+- tlib#InputList(): display_format == filename: don't add '/' to 
+directory names (avoid filesystem access)
+
+0.8
+- FIX: Return empty cache name for buffers that have no files attached to it
+- Some re-arranging
+
+0.9
+- Re-arrangements & modularization (this means many function names have 
+changed, on the other hand only those functions are loaded that are 
+actually needed)
+- tlib#input#List(): Added maps with m-modifiers for <c-q>, <c-z>, <c-a>
+- tlib#input#List(): Make sure &fdm is manual
+- tlib#input#List(): When exiting the list view, consume the next 5 
+characters in the queue (if any)
+- tlib#input#EditList(): Now has cut, copy, paste functionality.
+- Added documentation and examples
+
+0.10
+- tlib#input#List(): (v)split type of commands leave the original window 
+untouched (you may use <c-w> to replace its contents)
+- tlib#file#With(): Check whether an existing buffer is loaded.
+- Scratch related functions went to tlib/scratch.vim so that they are 
+accessible from other scripts.
+- Configure the list window height via g:tlib_inputlist_pct (1..100%)
+
+0.11
+NEW:
+    - The :TLet command replaces :TLLet (which was removed)
+    - :TScratch[!] command (with ! don't split but use the whole window)
+    - tlib#rx#Escape(text, ?magic='m')
+    - tlib#buffer#GetList(?show_hidden=0)
+    - tlib#dir#CD(), tlib#dir#Push(), tlib#dir#Pop()
+    - tlib#input#ListW: A slightly remodeled version of tlib#input#List 
+    that takes a World as second argument.
+    - Added some documentation doc/tlib.txt (most of it is automatically 
+    compiled from the source files)
+CHANGES:
+    - tlib#input#List(): The default keys for AND, NOT have changed to 
+    be more Google-like (space, minus); the keys can be configured via 
+    global variables.
+IMPROVEMENTS:
+    - In file listings, indicate if a file is loaded, listed, modified 
+    etc.
+    - tlib#input#List(): Highlight the filter pattern
+    - tlib#input#List(): <c-up/down> scrolls g:tlib_scroll_lines 
+    (default=10) lines
+FIXES:
+    - tlib#input#List(): Centering line, clear match, clear & restore 
+    the search register
+    - tlib#input#List(): Ensure the window layout doesn't change (if the 
+    number of windows hasn't changed)
+    - tlib#arg#Ex(): Don't escape backslashes by default
+
+0.12
+NEW:
+    - tlib/tab.vim
+CHANGES:
+    - Renamed tlib#win#SetWin() to tlib#win#Set()
+IMPROVEMENTS:
+    - tlib#input#List(): <left>, <right> keys work in some lists
+    - tlib#input#List(): If an index_table is provided this will be used 
+    instead of the item's list index.
+FIXES:
+    - tlib#input#List(): Problem with scrolling, when the list was 
+    shorter than the window (eg when using a vertical window).
+    - tlib#cache#Filename(): Don't rewrite name as relative filename if 
+    explicitly given as argument. Avoid double (back)slashes.
+    - TLet: simplified
+
+0.13
+CHANGES:
+    - Scratch: Set &fdc=0.
+    - The cache directory can be configured via g:tlib_cache
+    - Renamed tlib#buffer#SetBuffer() to tlib#buffer#Set().
+FIXES:
+    - tlib#input#List(): Select the active item per mouse.
+    - TLet: simplified
+
+0.14
+NEW:
+    - tlib#buffer#InsertText()
+CHANGES:
+    - tlib#win#[SG]etLayout(): Use a dictionnary, set &cmdheight.
+FIXES:
+    - Wrong order with pre-defined filters.
+
+0.15
+NEW:
+    - tlib#string#TrimLeft(), tlib#string#TrimRight(), tlib#string#Strip()
+    - Progress bar
+
+0.16
+NEW:
+    - tlib#string#Printf1()
+
+0.17
+NEW:
+    - TBrowseOutput
+- Some minor changes
+
+0.18
+NEW:
+    - tlib/time.vim
+    - g:tlib_inputlist_livesearch_threshold
+CHANGES:
+    - tlib#input#ListD(), World: Don't redisplay the list while typing 
+    new letters; calculate filter regexps only once before filtering the 
+    list.
+    - World.vim: Minor changes to how filenames are handled.
+
+0.19
+NEW:
+    - tag.vim
+FIX:
+    - dir.vim: Use plain dir name in tlib#dir#Ensure()
+    - tlib#input#List(): An initial filter argument creates [[filter]] 
+    and not as before [[''], [filter]].
+    - tlib#input#List(): When type was "si" and the item was picked by 
+    filter, the wrong index was returned.
+    - tlib#input#List(): Don't check if chars are typed when displaying 
+    the list for the first time.
+
+0.20
+- The arguments of tlib#tag#Collect() have changed.
+- tlib#input#List(): The view can be "suspended" on initial display.
+- tlib#input#List(): Follow/trace cursor functionality
+
+0.21
+- tlib#buffer#InsertText(): Respect tabs and (experimental) formatoptions+=or
+- tlib/syntax.vim: Syntax-related functions
+
+0.22
+- FIX: very magic mode for tlib#rx#Escape() (thanks A Politz)
+- FIX: tlib#arg#Ex: escape "!"
+
+0.23
+- Respect the setting of g:tlib_inputlist_filename_indicators
+- tlib#input#List(): Reset syntax on resume; option to make list window "sticky"
+- tlib#agent#ToggleStickyList()
+- Simplified tlib#url#Decode()
+- tlib#arg#Ex(): use fnameescape() if available
+
+0.24
+- s:prototype.SetInitialFilter: accept list as argument
+- Maintain buffer MRU if required
+
+0.25
+- NEW: tlib#notify#TrimMessage(): trim message to prevent "Press ENTER" 
+messages (contributed by Erik Falor)
+- NEW: tlib#notify#Echo()
+- FIX: World.CloseScratch(): Set window
+- FIX: tlib#input#ListW(): Set initial_display = 1 on reset
+
+0.26
+- NEW: tlib#normal#WithRegister()
+- FIX: Try not to change numbered registers
+
+0.27
+- FIX: Cosmetic bug, wrong packaging (thanks Nathan Neff)
+- Meaning of World#filter_format changed; new World#filter_options 
+- Filtering didn't work as advertised
+- tlib#string#Count()
+
+0.28
+- tlib#input#List():
+-- Improved handling of sticky lists; <cr> and <Leftmouse> resume a 
+suspended list and immediately selects the item under the cursor
+-- Experimental "seq" matching style: the conjunctions are sequentially 
+ordered, they are combined with "OR" (disjunctions), the regexp is 
+'magic', and "." is expanded to '.\{-}'
+-- Experimental "cnfd" matching style: Same as cnf but with an "elastic" 
+dot "." that matches '\.\{-}'
+-- Filtering acts as if &ic=1 && $sc=1
+-- Weighting is done by the filter
+- tlib#agent#Input(): Consume <esc> when aborting input()
+- INCOMPATIBLE CHANGE: Changed eligible values of g:tlib_inputlist_match 
+to "cnf", "cnfd", "seq" and "fuzzy"
+- NEW: tlib#buffer#KeepCursorPosition()
+- tlib#buffer#InsertText(): Take care of the extra line when appending 
+text to an empty buffer.
+
+0.29
+- tlib#string#Strip(): Strip also control characters (newlines etc.)
+- tlib#rx#Suffixes(): 'suffixes' as Regexp
+- World#RestoreOrigin(): Don't assume &splitbelow
+
+0.30
+- World#RestoreOrigin(): Don't assume &splitright
+
+0.31
+- :TRequire command
+-tlib#input#List: For i-type list views, make sure agents are called 
+with the base indices.
+
+0.32
+- tlib#agent#Exit: explicitly return empty value (as a consequence, 
+pressing <esc> when browsing an index-list, returns 0 and not "")
+- tlib#signs
+- tlib#input#List: set local statusline
+
+0.33
+- Don't reset statusline
+- Don't use fnamemodify() to split filenames (for performance reasons)
+- scratch: Set ft after setting up scratch options
+- tlib#map#PumAccept(key)
+
+0.34
+- tlib#buffer#HighlightLine(line): call tlib#autocmdgroup#Init() 
+(reported by Sergey Khorev)
+
+0.35
+- tlib#input#EditList(): return the list if the user presses esc
+
+0.36
+- Display a message when the filter is for whatever reason invalid
+- Removed tlib#paragraph#Delete()
+- New: tlib#paragraph#Define(), tlib#textobjects#StandardParagraph()
+- Try to speed up list display (a rewrite of World.DisplayList() etc. is 
+required)
+
+0.37
+- g:tlib_inputlist_livesearch_threshold defaults to 1000
+- tlib#World: optional scratch_pos field
+- tlib#input#List: By default <m-NUMBER> selects by number but NUMBER is 
+interpreted as string
+- tlib#date
+- TTimeCommand
+
+0.38
+- tlib#World#Resize: set winfix{height|width}
+
+0.39
+- g:tlib#cache#dont_purge
+- tlib#vim#RestoreWindow()
+- tlib#ballon#...()
+
+0.40
+- tlib#agent#ViewFile: Use split/sbuffer if nohidden && modified 
+- tlib#buffer#GetList(): order by "basename"
+
+version: "0.41"
+  - World.UseScratch(): keepalt
+  - Really include balloon.vim
+  MD5 checksum: 3fcbc4f7556f5378d39622e62ab8f379
+
+version: "0.42"
+  - tlib#input#List: <s-space> inserts a *-like wildcard (represented as "__")
+  - Check if a cache file cannot be created because a directory of the same name exists (display a message if so)
+  - tlib#cache#Filename: Removed check if a directory of the same name exists (due to inconsistent use)
+  - Minor improvements related to buffer handling (scratch_split)
+  - .gitignore
+  - docs (thanks to blueyed)
+  - There is no "edit" answer possibility.
+  - Fix first purge: do nothing if no timestamp file.
+  - g:tlib_pick_single_item
+  - Removed pick_single_item. Changed the default behavour when a list has only 1 item. See doc for g:tlib_pick_last_item.
+  - Updated help for tlib#input#List(); help_extra attribute
+  - EXPERIMENTAL: cache_var, restore_from_cache, on_leave properties; #Initialize(), #Leave()
+  - added tlib#cmd#BrowseOutputWithCallback function and :TBrowseScriptnames command
+  - tlib#cmd#BrowseOutputWithCallback function and :TBrowseScriptnames command documentation
+  - s:prototype.Initialize(): unlet self.cache_var after restoring values
+  - tlib#input#List: filter-specific help
+  - Removed the seq filter (use cnfd or fuzzy instead)
+  - tlib#input#List: temp_prompt (for help message)
+  MD5 checksum: aa8b5a4602235cc1a5bc9ee45d801b81
+
+version: "0.42"
+  - g:tlib#cache#silent: don't display messages when purging the cache (fixes #9)
+  - Changed message when deleting directories in the cache.
+  - g:tlib#input#use_popup: Don't rely on has('menu') but also check for gtk & win gui (fixes #10)
+  - debug
+  - tlib#input#ListW(): Didn't return a list when type == "m"
+  - docs (solves #11)
+  MD5 checksum: aa8b5a4602235cc1a5bc9ee45d801b81
+
+version: "0.45"
+  - fuzzy mode: prototype.highlight defaults to g:tlib_inputlist_higroup
+  - tlib#scratch: Use noautocmd
+  - tlib#input#ListW(): Use world.RestoreOrigin() instead of tlib#win#SetLayout(world.winview)
+  - tlib#input#ListW(): Revert to tlib#win#SetLayout(world.winview)
+  - tlib#cmd#OutputAsList(): Also save output in g:tlib#cmd#last_output
+  - tlib#agent#Suspend(): Resume on BufEnter
+  - tlib#input#Resume(): Make sure we are in the right buffer
+  - tlib#agent#Suspend(): Use only BufEnter event to trigger a Resume
+  - tlib#input#ListW(): When redisplaying a list, make sure prefix > 0
+  - tlib#vcs: Access vcs (initially only git is supported)
+  - tlib#vcs: improved
+  - tlib#persistent: Persistent data file names
+  - tlib#file#With(): Trigger BufRead autocommands
+  - Duplicate help tags (fixes #13)
+  - Make sure scrolloff is 0 while viewing the list (fixes https://github.com/tomtom/vikitasks_vim/issues/2)
+  MD5 checksum: 0af19ebc0e424727a598a988fdc90f4e
+
+  - Support for tinykeymap (move paragraph)
+  - Moved para_move to autoload/tinykeymap/map
+  - tlib#vcs: some "diff" commands were defined as "ls"; updated hg def; %s is optional
+  MD5 checksum: f2f2fe0893e75bb9423c1ddcd01f38f6
+version: "0.46"
+
+  - tlib#input#List: optimizations
+  - Prepare for multi-mode maps
+  - tlib#input#List: cnfx is new default filter
+  - Filters: minor changes to how the pattern is displayed
+  - g:tlib#input#format_filename: alternative method for formatting filenames
+  - tlib#input#List: allow multiple keymaps / modes
+  - Handle rezise events
+  - Don't initialize the same window twice
+  - Minor optimizations to how help is displayed
+  - Handle VimResize event per buffer
+  - Improve display of filenames & highlighting
+  - Filename highlighter: set Highlight_filename()
+  - RunStateHandlers(): set world variable
+  - Optimize help display
+  MD5 checksum: e3652927722bdc51935eb1a04238546b
+version: "1.00"
+
+  - Set g:tlib_inputlist_and to  ' ' again
+  - g:tlib#input#filename_max_width: maximum display width of filenames
+  - tlib#input#List: <s-esc>, <f10>: run command by name
+  MD5 checksum: a42f90275cdbe9f7d92cac61b884a2d1
+version: "1.01"
+
+  - #UseInputListScratch(): Make sure the TLib autogroup was created (fixes #14)
+  MD5 checksum: 5a6da7fc99c7fc7584e8fc2f7bf86fe4
+version: "1.02"
+
+  - tlib#cache#Value(cfile, generator, ftime, ...): cache value & check timestamp
+  - Replaced g:tlib#cache#silent with g:tlib#cache#verbosity
+  - FormatFilenames: improved handling of utf8 characters
+  - tlib#persistent#Value()
+  - tlib#input#List: Allow filename indiactors defined by the caller
+  - Custom filename_indicators are displayed after (and clearly separted from) the standard indicators
+  - Check the return value of an unknown_key agent
+  - Format filename = "l": Allow ".." as start of a directory name
+  - Format filename = "l": If the filename is just a filename's tail, display it on both sides
+  - Set g:tlib_filename_sep to "\" on Windows (again)
+  - g:tlib#cache#max_filename: If the cache filename is longer than N characters, use |pathshorten()|.
+  MD5 checksum: b64ce6764f39f40bfc95f3916bbb0057
+version: "1.04"
+
+version: "1.05"
+  - tlib#hash: Adler32 & CRC32 (using zlib via ruby) algorithms
+  - tlib#cache#Filename(): If the cache filename is too long, add the Adler32 checksum to the shortened path
+  - tlib#cache#Filename(): Use tlib#hash#Adler32() only if the or() function exists
+  - tlib#hash#Adler32(): Raise error, if or() doesn't exist
+  - tlib#hash#CRC32(): Alternative implementation of crc32 (doesn't work yet, thus currently disabled)
+  - tlib#bitwise: Bitwise operations for older versions of vim
+  - tlib#number: Base conversion
+  - tlib#input#ListW(): Handle mouse clicks more correctly
+  - tlib#bitwise#Num2Bits(): Supports returning floats
+  - tlib#hash#CRC32(): Alternative implementation of crc32 (doesn't work yet)
+  - tlib#hash#CRC32(): Re-enable ruby version
+  - tlib#hash#CRC32B(): Implementation of CRC32B checksum in vimscript (used only if +ruby isn't available)
+  - tlib#hash#CRC32B(): vim version: cache the crc table
+  - tlib#cache#Filename(): Use tlib#hash#CRC32B(file) instead of not Adler32 for filenames too long
+  - tlib#hash#CRC32B(): ruby version: return upper case hex value
+  - g:tlib#hash#use_crc32: define which crc32b version should be used
+  - Moved spec files from vimtlib to tlib_vim
+  - tlib#bitwise#Add() and tlib#bitwise#Sub()
+  - tlib#file#Relative(): Wrong results for filenames that don't exist
+  - Implementation of hash#Adler32 for earlier vim versions; g:tlib#hash#use_adler32
+  - tlib#cache#Filename(): Use adler32 again
+  - addon-info
+  - tlib#file#Absolute(): remove redundant "." parts in full filename
+  - win32: Fix moving window when using :vertical for tlib#inpu#List()
+  - tlib#cache#Filename(): Don't create wrong directory if the cache filename is too long
+  - tlib#file#Join(): if strip_slashes, also strip redundant (back)slashes
+  - tlib#input#ListW(): Always set post_keys variable
+  - tlib#file#With(): escape backslashes
+  - tlib#cmd#OutputAsList(): Support for nesting
+  - tlib#dir#NativeName(dirname)
+  MD5 checksum: 493f9beca44374de386f20d1613155e3
+
+  - Rename g:tlib_debug to g:tlib#debug
+  - Renamed g:tlib_sortprefs_threshold to g:tlib#input#sortprefs_threshold
+  - Renamed g:tlib#input#livesearch_threshold
+  - Renamed g:tlib_inputlist_match to g:tlib#input#filter_mode
+  - Renamed g:tlib_inputlist_higroup to g:tlib#input#higroup
+  - Renamed g:tlib#debug
+  - Moved g:tlib_pick_last_item
+  - Renamed g:tlib#input#and, g:tlib#input#or, g:tlib#input#not
+  - Moved g:tlib_numeric_chars to autoload/tlib/input.vim
+  - Renamed g:tlib#input#keyagents_InputList_s, g:tlib#input#keyagents_InputList_m, g:tlib#input#handlers_EditList
+  - Moved g:tlib_inputlist_pct, g:tlib_inputlist_width_filename, g:tlib_inputlist_filename_indicators, g:tlib_inputlist_shortmessage to autoload/tlib/World.vim
+  - Renamed tlib#input#pick_last_item (2)
+  - prototype.SelectItemsByNames()
+  - filtered_items: Restricted view
+  - prototype.PrintLines()
+  - Restricted view (2)
+  - Moved g:tlib_scroll_lines to autoload/tlib/agent.vim
+  - prototype.PrintLines() (2)
+  - tlib#input: Improved handling of popup menu (allows submenu)
+  - tlib#input: Allow mods in keys
+  - Moved g:tlib_scratch_pos to autoload/tlib/scratch.vim
+  - Moved g:tlib_tags_extra, g:tlib_tag_substitute to autoload/tlib/tag.vim
+  - tlib#agent#CompleteAgentNames(): Respect Arglead
+  - Move g:tlib_viewline_position to autoload/tlib/buffer.vim
+  - Move g:tlib_cache to autoload/tlib/cache.vim
+  - Renamed g:tlib_filename_sep to g:tlib#dir#sep
+  - prototype.UseScratch(): Set b:tlib_world
+  - tlib#input: f9 toggles resticted view
+  - tlib#input: next_agent, next_eval
+  - tlib#input: Revised use of the popup menu
+  - tlib#input: Disable popup menu for gui_gtk
+  - tlib#input: Re-enabled the popup menu for gtk gui
+  - tlib#input: FIX popup menu on Windows
+  - Renamed g:tlib_numeric_chars to g:tlib#input#numeric_chars (disabled per-buffer values) (fixes #35)
+  - Improve scratch list
+  - New: tlib#grep
+  - Merge branch 'master' of https://github.com/bruno-/tlib_vim into pull16
+  - g:tlib_scratch_hidden: Configure how to "hide" the scratch buffer
+  - tlib#grep#Do: don't escape "*" in patterns
+  - Optimize use of visible scratch buffers
+  - World.scratch_hidden parameter
+  - scratch: Always use keepalt & keepjumps
+  MD5 checksum: 2e40449c47dc606ccef57aa0b1e22e8e
+version: "1.06"
+
+version: "1.07"
+  - Help template
+  - prototype.Highlight_filename(): Use matchstr() instead of fnamemodify()
+  - Display buffer-related filename indicators only if g:tlib_inputlist_filename_indicators is true
+  - tlib#file#Join(): strip_slashes defaults to 1
+  MD5 checksum: 6c8fa96fd3747be05df848ee93dd789b
+
+version: "1.08"
+  - list#input: Improved support for file indicators (closes #17)
+  - tlib#char#Get(): Optionally, also return mod
+  - tlib#input#ListW: Use #DisplayFormat(world.list)
+  - Renamed cnfx filter to glob & minor filter-related enhancements
+  - list#input: Make help available as command; help cannot be called via ?
+  - list#input: Improved help message
+  - list#input: Support Home & End keys
+  - list#input: Added glob filter
+  - tlib#agent#ShowInfo: Show full filename
+  - tlib#cmd#BrowseOutputWithCallback: Support calling callback with multiple results
+  - tlib#cmd#ParseScriptname: Properly parse results from :scriptnames
+  - tlib#tab#Set()
+  - Prepare for proper handling of scratch_split == -1
+  - tlib#vim#CopyFunction()
+  - tlib#cache#Value(): If generator is empty, use the optional argument as start value
+  - tlib#persistent#Get() refers to tlib#cache#Get()
+  MD5 checksum: 459ec620168d1ae9b18c69eb3f991832
+
+  - tlib#cache#Filename(): Use sha256() for VIM >= 7.4
+  - tlib#cache#Value(): Undo previous hack
+  - tlib#list#Uniq(): option to remove empty values
+  - tlib#cache#MTime(); tlib#persistent#Save() calls tlib#cache#Save()
+  - tlib#input#ListW: Temporarily set noshowmode
+  - tlib#list#Uniq(): Fix handling of empty items
+  - lis picker: Remove <C-Space> from help
+  - tlib#list#Uniq(): Implementation based on syntastic#util#unique(list) by scrooloose
+  MD5 checksum: b5fb4107d63930c2c8b1f0f6b3a7ff07
+version: "1.09"
+
+  - tlib#cache#Filename(): Use sha256() for VIM >= 7.4
+  - tlib#cache#Value(): Undo previous hack
+  - tlib#list#Uniq(): option to remove empty values
+  - tlib#cache#MTime(); tlib#persistent#Save() calls tlib#cache#Save()
+  - tlib#input#ListW: Temporarily set noshowmode
+  - tlib#list#Uniq(): Fix handling of empty items
+  - lis picker: Remove <C-Space> from help
+  - tlib#list#Uniq(): Implementation based on syntastic#util#unique(list) by scrooloose
+  MD5 checksum: b5fb4107d63930c2c8b1f0f6b3a7ff07
+version: "1.09"
+
+  - tlib#string#Chomp: Optional argument: max number of chars that should be removed
+  MD5 checksum: 8c1b94e25045580874e2f892d509291b
+version: "1.10"
+
+  - tlib#vcs#FindVCS(filename): Wrong parameters to fnamemodifiy if filename is a directory
+  - Some system-related functions (e.g. facilitate use of cygwin tools)
+  - tlib#arg#StringAsKeyArgsEqual(), tlib#arg#StringAsKeyArgs(): Support "key=val" type argument lists
+  - tlib#vcs#Executable()
+  - scripts/create_crc_table.rb
+  - tlib#var#Get(): For namespaces other than global, replace "#" with "_"
+  MD5 checksum: 4a33f2f23e1fc6600b32e7f8323e001e
+version: "1.11"
+
+  - tlib#list#ToDictionary()
+  - tlib#dir#CanonicName(): Use tlib#file#Canonic()
+  - tlib#file#Canonic()
+  MD5 checksum: 7995ab58f31eb6673d20deab8761838e
+version: "1.12"
+
+  - SetInitialFilter(): Use deepcopy()
+  - tlib#var#List(): use keys(namespace) for newer versions of vim
+  - g:tlib#input#user_shortcuts (not functional yet)
+  - tlib#input#List: state "picked"
+  - UseInputListScratch(): Allow customization via self.index_next_syntax
+  - tlib#cmd#Capture()
+  - Facilitate customization of key agents via g:tlib_extend_keyagents_InputList_s, g:tlib_extend_keyagents_InputList_m
+  MD5 checksum: 7dd8b17a1a5b555df979381dcbd4c9aa
+version: "1.13"
+
+  - SetInitialFilter(): Use deepcopy()
+  - tlib#var#List(): use keys(namespace) for newer versions of vim
+  - g:tlib#input#user_shortcuts (not functional yet)
+  - tlib#input#List: state "picked"
+  - UseInputListScratch(): Allow customization via self.index_next_syntax
+  - tlib#cmd#Capture()
+  - Facilitate customization of key agents via g:tlib_extend_keyagents_InputList_s, g:tlib_extend_keyagents_InputList_m
+  MD5 checksum: 7dd8b17a1a5b555df979381dcbd4c9aa
+version: "1.13"
+
+version: "1.14"
+  - FIX #18: Make sure the scratch isn't readonly
+  - FIX: display filter (properly handle backslashes)
+  - Remove loaded_* guard from autoload files
+  - tlib#notify#Echo(): minor changes
+  - tlib#file#Edit() (used by tlib#agent#ViewFile)
+  - tlib#buffer#GetList(): Buffer numbers are converted to numbers
+  - tlib#sys: Change order of functions (move tlib#sys#IsCygwinBin to the (possibly FIX #19)
+  - g:tlib#sys#check_cygpath: Call tlib#sys#IsExecutable('cygpath', 1)  (possibly FIX #19)
+  MD5 checksum: 2cf6386218736a2d09db43c8e751e5a4
+
+version: "1.15"
+  - tlib#file#Join(): New optional argument: maybe_absolute Drop preceding parts if a part looks like an absolute filename
+  - tlib#sys#Open(), tlib#sys#IsSpecial() (moved from viki)
+  - tlib#list#Uniq(): Handle hetergenous lists
+  - FIX #21: duplicate help tag
+  - NEW tlib#dictionary#Rev()
+  - tlib#input#List(): Use <Tab> to complete current word
+  - NEW tlib#arg#GetOpts(); ENH tlib#arg#StringAsKeyArgsEqual()
+  - cache: Allow for in memory cache
+  - NEW tlib#eval#Extend()
+  - Move qfl/loclist browser from trag to tlib
+  - FIX tlib#eval#Extend()
+  - Simplify tlib#eval#Extend()
+  - World.index_next_syntax may be a dict
+  - tlib#qfl#QflList: Use copy()
+  - tlib#arg#GetOpts: Handle exit code
+  MD5 checksum: 13fd8b0e4ba9cd932c57fc40ac3f641f
+
+version: "1.15"
+  - tlib#file#Join(): New optional argument: maybe_absolute Drop preceding parts if a part looks like an absolute filename
+  - tlib#sys#Open(), tlib#sys#IsSpecial() (moved from viki)
+  - tlib#list#Uniq(): Handle hetergenous lists
+  - FIX #21: duplicate help tag
+  - NEW tlib#dictionary#Rev()
+  - tlib#input#List(): Use <Tab> to complete current word
+  - NEW tlib#arg#GetOpts(); ENH tlib#arg#StringAsKeyArgsEqual()
+  - cache: Allow for in memory cache
+  - NEW tlib#eval#Extend()
+  - Move qfl/loclist browser from trag to tlib
+  - FIX tlib#eval#Extend()
+  - Simplify tlib#eval#Extend()
+  - World.index_next_syntax may be a dict
+  - tlib#qfl#QflList: Use copy()
+  - tlib#arg#GetOpts: Handle exit code
+  MD5 checksum: 13fd8b0e4ba9cd932c57fc40ac3f641f
+
+  - tlib#arg#GetOpts: Handle short options
+  - tlib#arg: support short flags & facilitate completion
+  - NEW :TLibTrace
+  - tlib#sys#system_browser: FIX XDG string
+  - NEW tlib#sys#SystemInDir() (used by tlib#vcs#Ls)
+  - tlib#agent#Complete: improve fltrx
+  - Remove tlib#arg#Key(), :TKeyArg
+  - Move :TRequire, :TTimeCommand to macros/tlib.vim
+  - NEW tlib#cmd#TBrowseScriptnames()
+  - TScratch: use empty('<bang>')
+  - NEW :TLibTrace
+  - tlib#qfl: FIX TTagedFilesFilename regexp
+  - Remove tlib#arg#Key()
+  - tlib#buffer#InsertText(): Don't use TKeyArg
+  - tlib#eval#Extend: don't assign value
+  - NEW :TLibTrace, tlib#trace (was tlib#debug)
+  - NEW tlib#string#SplitCommaList()
+  - NEW tlib#time#FormatNow()
+  - tlib#arg#GetOpts: selectively disable "long", "short" flags
+  - tlib#arg#CComplete(): Support values completion (complete_customlist field)
+  - NEW tlib#date#Shift()
+  - tlib#qfl#Balloon(): Handle items with no bufnr
+  - NEW tlib#file#Glob, tlib#file#Globpath
+  - tlib#progressbar#Display(): optional "always" argument
+  - tlib#vcs#GitLsPostprocess(): Try to handle encoded filenames from git ls-files
+  - tlib#vcs#GitLsPostprocess: Eval only \ddd substrings
+  - FIX #22: duplicate tag
+  - tlib#buffer: Use 2match instead of 3match (incompatibility with matchparen)
+  - FIX #23: duplicate help tag
+  - tlib#string#SplitCommaList: optional "sep" argument
+  - Rename TLibTrace -> Tlibtrace; NEW Tlibtraceset command
+  - Rename s:SetSyntax -> tlib#qfl#SetSyntax
+  - mv tlib#rx#Convert to incubator
+  MD5 checksum: f3656fb35b7b3033084d6c5e504aca61
+version: "1.16"
+
+  - tlib#input#List: #ReduceFilter: make sure the regexp is valid
+  - TTimeCommand -> Ttimecommand
+  - tlib#eval#Extend: mode argument for expand() compatibility
+  - tlib#input#List: Key handlers can have additional arguments
+  - tlib#qfl#AgentWithSelected: Set world
+  - prototype.UseInputListScratch: Run tlib_UseInputListScratch hook earlier
+  - tlib#qfl#AgentWithSelected: typo
+  - tlib#arg#GetOpts: type conversion (comma-separated lists etc.)
+  - tlib#arg: validators
+  - NEW tlib#date#IsDate()
+  - tlib#balloon#Remove: Unset &ballooneval, &balloonexpr
+  - NEW tlib#balloon#Expand()
+  - NEW tlib#date#Format()
+  - FIX tlib#date#Shift(..., "+Xm") for months
+  - NEW tlib#trace#Backtrace()
+  - NEW tlib#type#Is(), tlib#type#Are(), tlib#type#Has(), tlib#type#Have()
+  - NEW :Tlibassert
+  MD5 checksum: 3c4125a28ff1860accd254846651c251
+version: "1.17"
+
+  - tlib#input#List: #ReduceFilter: make sure the regexp is valid
+  - TTimeCommand -> Ttimecommand
+  - tlib#eval#Extend: mode argument for expand() compatibility
+  - tlib#input#List: Key handlers can have additional arguments
+  - tlib#qfl#AgentWithSelected: Set world
+  - prototype.UseInputListScratch: Run tlib_UseInputListScratch hook earlier
+  - tlib#qfl#AgentWithSelected: typo
+  - tlib#arg#GetOpts: type conversion (comma-separated lists etc.)
+  - tlib#arg: validators
+  - NEW tlib#date#IsDate()
+  - tlib#balloon#Remove: Unset &ballooneval, &balloonexpr
+  - NEW tlib#balloon#Expand()
+  - NEW tlib#date#Format()
+  - FIX tlib#date#Shift(..., "+Xm") for months
+  - NEW tlib#trace#Backtrace()
+  - NEW tlib#type#Is(), tlib#type#Are(), tlib#type#Has(), tlib#type#Have()
+  - NEW :Tlibassert
+  MD5 checksum: 3c4125a28ff1860accd254846651c251
+version: "1.17"
+
+  - tlib#input#List: #ReduceFilter: make sure the regexp is valid
+  - TTimeCommand -> Ttimecommand
+  - tlib#eval#Extend: mode argument for expand() compatibility
+  - tlib#input#List: Key handlers can have additional arguments
+  - tlib#qfl#AgentWithSelected: Set world
+  - prototype.UseInputListScratch: Run tlib_UseInputListScratch hook earlier
+  - tlib#qfl#AgentWithSelected: typo
+  - tlib#arg#GetOpts: type conversion (comma-separated lists etc.)
+  - tlib#arg: validators
+  - NEW tlib#date#IsDate()
+  - tlib#balloon#Remove: Unset &ballooneval, &balloonexpr
+  - NEW tlib#balloon#Expand()
+  - NEW tlib#date#Format()
+  - FIX tlib#date#Shift(..., "+Xm") for months
+  - NEW tlib#trace#Backtrace()
+  - NEW tlib#type#Is(), tlib#type#Are(), tlib#type#Has(), tlib#type#Have()
+  - NEW :Tlibassert
+  MD5 checksum: 3c4125a28ff1860accd254846651c251
+version: "1.17"
+
+  - tlib#input#List: #ReduceFilter: make sure the regexp is valid
+  - TTimeCommand -> Ttimecommand
+  - tlib#eval#Extend: mode argument for expand() compatibility
+  - tlib#input#List: Key handlers can have additional arguments
+  - tlib#qfl#AgentWithSelected: Set world
+  - prototype.UseInputListScratch: Run tlib_UseInputListScratch hook earlier
+  - tlib#qfl#AgentWithSelected: typo
+  - tlib#arg#GetOpts: type conversion (comma-separated lists etc.)
+  - tlib#arg: validators
+  - NEW tlib#date#IsDate()
+  - tlib#balloon#Remove: Unset &ballooneval, &balloonexpr
+  - NEW tlib#balloon#Expand()
+  - NEW tlib#date#Format()
+  - FIX tlib#date#Shift(..., "+Xm") for months
+  - NEW tlib#trace#Backtrace()
+  - NEW tlib#type#Is(), tlib#type#Are(), tlib#type#Has(), tlib#type#Have()
+  - NEW :Tlibassert
+  MD5 checksum: 3c4125a28ff1860accd254846651c251
+version: "1.17"
+
+  - tlib#arg: Completion for comma-separated lists
+  - Use "silent cd"
+  - NEW tlib#type#DefSchema(); FIX tlib#type#Has()
+  - tlib#cache#Value(): minor change
+  - tlib#date#IsDate() also checks whether the date is valid
+  - ! tlib#sys#Open(): escape special chars only once
+  - tlib#trace#Print: Allow for strings
+  - :Tlibtrace, :Tlibtraceset, :Tlibassert remove `-bar`
+  - NEW :Tlibtype (type/schema assertions); tlib#type#Is() also accepts schemas as "types"
+  - tlib#dir#CD(): Use haslocaldir()
+  - tlib#qfl#AgentGotoQFE: Don't use wincmd w
+  - NEW tlib#string#Input()
+  - FIX g:tlib#sys#system_rx; add OpenOffice exensions to g:tlib#sys#special_suffixes
+  - NEW tlib#selection#GetSelection()
+  - tlib#date#Shift(): Fix "Xm", ++specs
+  - tlib#trace#Set: FIX Properly handly "-label"
+  MD5 checksum: c3a1fe7d3cd86becbd3f7b0ba7ae9cd8
+version: "1.19"
+
+version: "1.20"
+  - tlib#arg: Completion for comma-separated lists
+  - Use "silent cd"
+  - NEW tlib#type#DefSchema(); FIX tlib#type#Has()
+  - tlib#cache#Value(): minor change
+  - tlib#date#IsDate() also checks whether the date is valid
+  - ! tlib#sys#Open(): escape special chars only once
+  - tlib#trace#Print: Allow for strings
+  - :Tlibtrace, :Tlibtraceset, :Tlibassert remove `-bar`
+  - NEW :Tlibtype (type/schema assertions); tlib#type#Is() also accepts schemas as "types"
+  - tlib#dir#CD(): Use haslocaldir()
+  - tlib#qfl#AgentGotoQFE: Don't use wincmd w
+  - NEW tlib#string#Input()
+  - FIX g:tlib#sys#system_rx; add OpenOffice exensions to g:tlib#sys#special_suffixes
+  - NEW tlib#selection#GetSelection()
+  - tlib#date#Shift(): Fix "Xm", ++specs
+  - tlib#trace#Set: FIX Properly handly "-label"
+  MD5 checksum: c919e0782931a8c628c6996903f989d3
+
diff --git a/vim/.vim/bundle/snipmate-tlib/LICENSE.TXT b/vim/.vim/bundle/snipmate-tlib/LICENSE.TXT
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/LICENSE.TXT
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/vim/.vim/bundle/snipmate-tlib/README b/vim/.vim/bundle/snipmate-tlib/README
new file mode 100644
index 0000000..70f6958
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/README
@@ -0,0 +1,21 @@
+This library provides some utility functions. There isn't much need to 
+install it unless another plugin requires you to do so.
+
+Most of the library is included in autoload files. No autocommands are 
+created. With the exception of loading ../plugin/02tlib.vim at startup 
+the library has no impact on startup time or anything else.
+
+The change-log is included at the bottom of ../plugin/02tlib.vim
+(move the cursor over the file name and type gfG)
+
+Demo of |tlib#input#List()|: 
+http://vimsomnia.blogspot.com/2010/11/selecting-items-from-list-with-tlibs.html
+
+
+-----------------------------------------------------------------------
+
+
+License: GPLv3 or later
+Install: See http://github.com/tomtom/vimtlib/blob/master/INSTALL.TXT
+See http://github.com/tomtom for related plugins.
+
diff --git a/vim/.vim/bundle/snipmate-tlib/addon-info.json b/vim/.vim/bundle/snipmate-tlib/addon-info.json
new file mode 100644
index 0000000..3585531
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/addon-info.json
@@ -0,0 +1,9 @@
+{
+    "name" : "tlib",
+    "version" : "dev",
+    "author" : "Tom Link <micathom at gmail com>",
+    "maintainer" : "Tom Link <micathom at gmail com>",
+    "repository" : {"type": "git", "url": "git://github.com/tomtom/tlib_vim.git"},
+    "dependencies" : {},
+    "description" : "tlib -- A library of vim functions"
+}
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tinykeymap/map/para_move.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tinykeymap/map/para_move.vim
new file mode 100644
index 0000000..908f5f7
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tinykeymap/map/para_move.vim
@@ -0,0 +1,12 @@
+" para_move.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2012-08-28.
+" @Last Change: 2012-08-29.
+" @Revision:    3
+
+" Move paragraphs
+call tinykeymap#EnterMap("para_move", "gp", {'name': 'move paragraph'})
+call tinykeymap#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '<count>')")
+call tinykeymap#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '<count>')")
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib.vim
new file mode 100755
index 0000000..5d805ac
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib.vim
@@ -0,0 +1,8 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    13
+
+" :nodefault:
+TLet g:tlib#debug = 0
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_cnf.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_cnf.vim
new file mode 100755
index 0000000..0bcb6c0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_cnf.vim
@@ -0,0 +1,151 @@
+" Filter_cnf.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2014-11-18.
+" @Revision:    0.0.114
+
+let s:prototype = tlib#Object#New({'_class': ['Filter_cnf'], 'name': 'cnf'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+" The search pattern for |tlib#input#List()| is in conjunctive normal 
+" form: (P1 OR P2 ...) AND (P3 OR P4 ...) ...
+" The pattern is a '/\V' very no-'/magic' regexp pattern.
+"
+" Pressing <space> joins two patterns with AND.
+" Pressing | joins two patterns with OR.
+" I.e. In order to get "lala AND (foo OR bar)", you type 
+" "lala foo|bar".
+"
+" This is also the base class for other filters.
+function! tlib#Filter_cnf#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Init(world) dict "{{{3
+endf
+
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call a:world.PushHelp(
+                \ printf('"%s", "%s", "%sWORD"', g:tlib#input#and, g:tlib#input#or, g:tlib#input#not),
+                \ 'AND, OR, NOT')
+endf
+
+
+" :nodoc:
+function! s:prototype.AssessName(world, name) dict "{{{3
+    let xa  = 0
+    let prefix = self.FilterRxPrefix()
+    for flt in a:world.filter_pos
+        " let flt = prefix . a:world.GetRx(fltl)
+        " if flt =~# '\u' && a:name =~# flt
+        "     let xa += 5
+        " endif
+
+        if a:name =~ '\^'. flt
+            let xa += 4
+        elseif a:name =~ '\<'. flt
+            let xa += 3
+        " elseif a:name =~ '[[:punct:][:space:][:digit:]]'. flt
+        "     let xa += 2
+        elseif a:name =~ '\A'. flt .'\|'. flt .'\A'
+            let xa += 1
+        endif
+    endfor
+    " TLogVAR a:name, xa
+    return xa
+endf
+
+
+" :nodoc:
+function! s:prototype.Match(world, text) dict "{{{3
+    " TLogVAR a:text
+    " let sc = &smartcase
+    " let ic = &ignorecase
+    " if &ignorecase
+    "     set smartcase
+    " endif
+    " try
+    if !empty(a:world.filter_neg)
+        for rx in a:world.filter_neg
+            " TLogVAR rx
+            if a:text =~ rx
+                return 0
+            endif
+        endfor
+    endif
+    if !empty(a:world.filter_pos)
+        for rx in a:world.filter_pos
+            " TLogVAR rx
+            if a:text !~ rx
+                return 0
+            endif
+        endfor
+    endif
+    " finally
+    "     let &smartcase = sc
+    "     let &ignorecase = ic
+    " endtry
+    return 1
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayFilter(filter) dict "{{{3
+    let filter1 = deepcopy(a:filter)
+    call map(filter1, '"(". join(reverse(self.Pretty(v:val)), " OR ") .")"')
+    return join(reverse(filter1), ' AND ')
+endf
+
+
+function! s:prototype.Pretty(filter) dict "{{{3
+    " call map(a:filter, 'substitute(v:val, ''\\\.\\{-}'', ''=>'', ''g'')')
+    call map(a:filter, 'self.CleanFilter(v:val)')
+    return a:filter
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let a:world.filter[0] = reverse(split(a:pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    let a:world.filter[0][0] .= nr2char(a:char)
+endf
+
+
+" :nodoc:
+function! s:prototype.ReduceFrontFilter(world) dict "{{{3
+    let filter = a:world.filter[0][0]
+    " TLogVAR filter
+    let str = matchstr(filter, '\(\\\(\.\\{-}\|[.?*+$^]\)\|\)$')
+    if empty(str)
+        let filter = filter[0 : -2]
+    else
+        let filter = strpart(filter, 0, len(filter) - len(str))
+    endif
+    " TLogVAR str, filter
+    let a:world.filter[0][0] = filter
+endf
+
+
+" :nodoc:
+function! s:prototype.FilterRxPrefix() dict "{{{3
+    return '\V'
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return a:filter
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_cnfd.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_cnfd.vim
new file mode 100755
index 0000000..27f00fe
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_cnfd.vim
@@ -0,0 +1,53 @@
+" Filter_cnfd.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2014-01-23.
+" @Revision:    0.0.57
+
+let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_cnfd'], 'name': 'cnfd'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+
+" The same as |tlib#Filter_cnf#New()| but a dot is expanded to '\.\{-}'. 
+" As a consequence, patterns cannot match dots.
+" The pattern is a '/\V' very no-'/magic' regexp pattern.
+function! tlib#Filter_cnfd#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Init(world) dict "{{{3
+endf
+
+
+let s:Help = s:prototype.Help
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call call(s:Help, [a:world], self)
+    call a:world.PushHelp('.', 'Any characters')
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let pattern = substitute(a:pattern, '\.', '\\.\\{-}', 'g')
+    let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    let a:world.filter[0][0] .= a:char == 46 ? '\.\{-}' : nr2char(a:char)
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return substitute(a:filter, '\\.\\{-}', '.', 'g')
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_fuzzy.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_fuzzy.vim
new file mode 100755
index 0000000..349bfd5
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_fuzzy.vim
@@ -0,0 +1,83 @@
+" Filter_fuzzy.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2013-09-25.
+" @Revision:    0.0.47
+
+let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_fuzzy'], 'name': 'fuzzy'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+
+" Support for "fuzzy" pattern matching in |tlib#input#List()|. 
+" Patterns are interpreted as if characters were connected with '.\{-}'.
+"
+" In "fuzzy" mode, the pretty printing of filenames is disabled.
+function! tlib#Filter_fuzzy#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Init(world) dict "{{{3
+    " TLogVAR a:world.display_format
+    " :nodoc:
+    function! a:world.Set_display_format(value) dict
+        if a:value == 'filename'
+            let self.display_format = ''
+        else
+            let self.display_format = a:value
+        endif
+    endf
+endf
+
+
+let s:Help = s:prototype.Help
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call call(s:Help, [a:world], self)
+    call a:world.PushHelp('Patterns are interpreted as if characters were connected with .\{-}')
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayFilter(filter) dict "{{{3
+    " TLogVAR a:filter
+    let filter1 = deepcopy(a:filter)
+    call map(filter1, '"{". join(reverse(v:val), " OR ") ."}"')
+    return join(reverse(filter1), ' AND ')
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let a:world.filter[0] = map(reverse(split(a:pattern, '\s*|\s*')), 'join(map(split(v:val, ''\zs''), ''tlib#rx#Escape(v:val, "V")''), ''\.\{-}'')') + a:world.filter[0][1 : -1]
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    let ch = tlib#rx#Escape(nr2char(a:char), 'V')
+    if empty(a:world.filter[0][0])
+        let a:world.filter[0][0] .= ch
+    else
+        let a:world.filter[0][0] .= '\.\{-}'. ch
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.ReduceFrontFilter(world) dict "{{{3
+    let a:world.filter[0][0] = substitute(a:world.filter[0][0], '\(\\\.\\{-}\)\?.$', '', '')
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return substitute(a:filter, '\\\.\\{-}', '', 'g')
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_glob.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_glob.vim
new file mode 100644
index 0000000..904b226
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Filter_glob.vim
@@ -0,0 +1,68 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2014-11-18.
+" @Revision:    0.0.82
+
+let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_glob'], 'name': 'glob'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+
+" A character that should be expanded to '\.\{-}'.
+TLet g:tlib#Filter_glob#seq = '*'
+
+
+" A character that should be expanded to '\.\?'.
+TLet g:tlib#Filter_glob#char = '?'
+
+
+" The same as |tlib#Filter_cnf#New()| but a a customizable character 
+" |see tlib#Filter_glob#seq| is expanded to '\.\{-}' and 
+" |g:tlib#Filter_glob#char| is expanded to '\.'.
+" The pattern is a '/\V' very no-'/magic' regexp pattern.
+function! tlib#Filter_glob#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+let s:Help = s:prototype.Help
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call call(s:Help, [a:world], self)
+    call a:world.PushHelp(g:tlib#Filter_glob#seq, 'Any characters')
+    call a:world.PushHelp(g:tlib#Filter_glob#char, 'Single characters')
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#seq, 'V'), '\\.\\{-}', 'g')
+    let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#char, 'V'), '\\.', 'g')
+    let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    " TLogVAR a:char, nr2char(a:char)
+    if a:char == char2nr(g:tlib#Filter_glob#seq)
+        let char = '\.\{-}'
+    elseif a:char == char2nr(g:tlib#Filter_glob#char)
+        let char = '\.'
+    else
+        let char = nr2char(a:char)
+    endif
+    let a:world.filter[0][0] .= char
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    let filter = substitute(a:filter, '\\\.\\{-}', g:tlib#Filter_glob#seq, 'g')
+    let filter = substitute(filter, '\\\.', g:tlib#Filter_glob#char, 'g')
+    return filter
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Object.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Object.vim
new file mode 100755
index 0000000..21f38b2
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Object.vim
@@ -0,0 +1,154 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    127
+
+" :filedoc:
+" Provides a prototype plus some OO-like methods.
+
+let s:id_counter = 0
+let s:prototype  = {'_class': ['object'], '_super': [], '_id': 0} "{{{2
+
+" :def: function! tlib#Object#New(?fields={})
+" This function creates a prototype that provides some kind of 
+" inheritance mechanism and a way to call parent/super methods.
+"
+" The usage demonstrated in the following example works best when every 
+" class/prototype is defined in a file of its own.
+"
+" The reason for why there is a dedicated constructor function is that 
+" this layout facilitates the use of templates and that methods are 
+" hidden from the user. Other solutions are possible.
+"
+" EXAMPLES: >
+"     let s:prototype = tlib#Object#New({
+"                 \ '_class': ['FooBar'],
+"                 \ 'foo': 1, 
+"                 \ 'bar': 2, 
+"                 \ })
+"     " Constructor
+"     function! FooBar(...)
+"         let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+"         return object
+"     endf
+"     function! s:prototype.babble() {
+"       echo "I think, therefore I am ". (self.foo * self.bar) ." months old."
+"     }
+"
+" < This could now be used like this: >
+"     let myfoo = FooBar({'foo': 3})
+"     call myfoo.babble()
+"     => I think, therefore I am 6 months old.
+"     echo myfoo.IsA('FooBar')
+"     => 1
+"     echo myfoo.IsA('object')
+"     => 1
+"     echo myfoo.IsA('Foo')
+"     => 0
+"     echo myfoo.RespondTo('babble')
+"     => 1
+"     echo myfoo.RespondTo('speak')
+"     => 0
+function! tlib#Object#New(...) "{{{3
+    return s:prototype.New(a:0 >= 1 ? a:1 : {})
+endf
+
+
+function! s:prototype.New(...) dict "{{{3
+    let object = deepcopy(self)
+    let s:id_counter += 1
+    let object._id = s:id_counter
+    if a:0 >= 1 && !empty(a:1)
+        " call object.Extend(deepcopy(a:1))
+        call object.Extend(a:1)
+    endif
+    return object
+endf
+
+
+function! s:prototype.Inherit(object) dict "{{{3
+    let class = copy(self._class)
+    " TLogVAR class
+    let objid = self._id
+    for c in get(a:object, '_class', [])
+        " TLogVAR c
+        if index(class, c) == -1
+            call add(class, c)
+        endif
+    endfor
+    call extend(self, a:object, 'keep')
+    let self._class = class
+    " TLogVAR self._class
+    let self._id    = objid
+    " let self._super = [super] + self._super
+    call insert(self._super, a:object)
+    return self
+endf
+
+
+function! s:prototype.Extend(dictionary) dict "{{{3
+    let super = copy(self)
+    let class = copy(self._class)
+    " TLogVAR class
+    let objid = self._id
+    let thisclass = get(a:dictionary, '_class', [])
+    for c in type(thisclass) == 3 ? thisclass : [thisclass]
+        " TLogVAR c
+        if index(class, c) == -1
+            call add(class, c)
+        endif
+    endfor
+    call extend(self, a:dictionary)
+    let self._class = class
+    " TLogVAR self._class
+    let self._id    = objid
+    " let self._super = [super] + self._super
+    call insert(self._super, super)
+    return self
+endf
+
+
+function! s:prototype.IsA(class) dict "{{{3
+    return index(self._class, a:class) != -1
+endf
+
+
+function! s:prototype.IsRelated(object) dict "{{{3
+    return len(filter(a:object._class, 'self.IsA(v:val)')) > 1
+endf
+
+
+function! s:prototype.RespondTo(name) dict "{{{3
+    " return has_key(self, a:name) && type(self[a:name]) == 2
+    return has_key(self, a:name)
+endf
+
+
+function! s:prototype.Super(method, arglist) dict "{{{3
+    for o in self._super
+        " TLogVAR o
+        if o.RespondTo(a:method)
+            " let self._tmp_method = o[a:method]
+            " TLogVAR self._tmp_method
+            " return call(self._tmp_method, a:arglist, self)
+            return call(o[a:method], a:arglist, self)
+        endif
+    endfor
+    echoerr 'tlib#Object: Does not respond to '. a:method .': '. string(self)
+endf
+
+
+function! tlib#Object#Methods(object, ...) "{{{3
+    TVarArg ['pattern', '\d\+']
+    let o = items(a:object)
+    call filter(o, 'type(v:val[1]) == 2 && string(v:val[1]) =~ "^function(''\\d\\+'')"')
+    let acc = {}
+    for e in o
+        let id = matchstr(string(e[1]), pattern)
+        if !empty(id)
+            let acc[id] = e[0]
+        endif
+    endfor
+    return acc
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Test.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Test.vim
new file mode 100755
index 0000000..4a4281e
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/Test.vim
@@ -0,0 +1,19 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    11
+
+" :enddoc:
+
+
+let s:prototype = tlib#Object#New({'_class': ['Test']}) "{{{2
+function! tlib#Test#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+function! s:prototype.Dummy() dict "{{{3
+    return 'Test.vim'
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/TestChild.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/TestChild.vim
new file mode 100755
index 0000000..16979a7
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/TestChild.vim
@@ -0,0 +1,19 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    15
+
+" :enddoc:
+
+
+let s:prototype = tlib#Test#New({'_class': ['TestChild']}) "{{{2
+function! tlib#TestChild#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+function! s:prototype.Dummy() dict "{{{3
+    return 'TestChild.vim'
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/World.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/World.vim
new file mode 100755
index 0000000..aa1bc9e
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/World.vim
@@ -0,0 +1,1404 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    1434
+
+" :filedoc:
+" A prototype used by |tlib#input#List|.
+" Inherits from |tlib#Object#New|.
+
+
+" Size of the input list window (in percent) from the main size (of &lines).
+" See |tlib#input#List()|.
+TLet g:tlib_inputlist_pct = 50
+
+" Size of filename columns when listing filenames.
+" See |tlib#input#List()|.
+TLet g:tlib_inputlist_width_filename = '&co / 3'
+" TLet g:tlib_inputlist_width_filename = 25
+
+" If true, |tlib#input#List()| will show some indicators about the 
+" status of a filename (e.g. buflisted(), bufloaded() etc.).
+" This is disabled by default because vim checks also for the file on 
+" disk when doing this.
+TLet g:tlib_inputlist_filename_indicators = 0
+
+" If not null, display only a short info about the filter.
+TLet g:tlib_inputlist_shortmessage = 0
+
+
+
+" Known keys & values:
+"   scratch_split ... See |tlib#scratch#UseScratch()|
+let s:prototype = tlib#Object#New({
+            \ '_class': 'World',
+            \ 'name': 'world',
+            \ 'allow_suspend': 1,
+            \ 'base': [], 
+            \ 'bufnr': -1,
+            \ 'buffer_local': 1,
+            \ 'cache_var': '',
+            \ 'display_format': '',
+            \ 'fileencoding': &fileencoding,
+            \ 'fmt_display': {},
+            \ 'fmt_filter': {},
+            \ 'fmt_options': {},
+            \ 'filetype': '',
+            \ 'filter': [['']],
+            \ 'filter_format': '',
+            \ 'filter_options': '',
+            \ 'follow_cursor': '',
+            \ 'has_menu': 0,
+            \ 'help_extra': [],
+            \ 'index_table': [],
+            \ 'initial_filter': [['']],
+            \ 'initial_index': 1,
+            \ 'initial_display': 1,
+            \ 'initialized': 0,
+            \ 'key_handlers': [],
+            \ 'list': [],
+            \ 'matcher': {},
+            \ 'next_agent': '',
+            \ 'next_eval': '',
+            \ 'next_state': '',
+            \ 'numeric_chars': g:tlib#input#numeric_chars,
+            \ 'offset': 1,
+            \ 'offset_horizontal': 0,
+            \ 'on_leave': [],
+            \ 'pick_last_item': tlib#var#Get('tlib#input#pick_last_item', 'bg'),
+            \ 'post_handlers': [],
+            \ 'query': '',
+            \ 'resize': 0,
+            \ 'resize_vertical': 0,
+            \ 'restore_from_cache': [],
+            \ 'filtered_items': [],
+            \ 'resume_state': '', 
+            \ 'retrieve_eval': '',
+            \ 'return_agent': '',
+            \ 'rv': '',
+            \ 'scratch': '__InputList__',
+            \ 'scratch_filetype': 'tlibInputList',
+            \ 'scratch_hidden': g:tlib#scratch#hidden,
+            \ 'scratch_vertical': 0,
+            \ 'scratch_split': 1,
+            \ 'sel_idx': [],
+            \ 'show_empty': 0,
+            \ 'state': 'display', 
+            \ 'state_handlers': [],
+            \ 'sticky': 0,
+            \ 'temp_lines': [],
+            \ 'temp_prompt': [],
+            \ 'timeout': 0,
+            \ 'timeout_resolution': 2,
+            \ 'tabpagenr': -1,
+            \ 'type': '', 
+            \ 'win_wnr': -1,
+            \ 'win_height': -1,
+            \ 'win_width': -1,
+            \ 'win_pct': 25,
+            \ })
+            " \ 'handlers': [],
+            " \ 'filter_options': '\c',
+
+function! tlib#World#New(...)
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    call object.SetMatchMode(tlib#var#Get('tlib#input#filter_mode', 'g', 'cnf'))
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Set_display_format(value) dict "{{{3
+    if a:value == 'filename'
+        call self.Set_highlight_filename()
+        let self.display_format = 'world.FormatFilename(%s)'
+    else
+        let self.display_format = a:value
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayFormat(list) dict "{{{3
+    let display_format = self.display_format
+    if !empty(display_format)
+        if has_key(self, 'InitFormatName')
+            call self.InitFormatName()
+        endif
+        let cache = self.fmt_display
+        " TLogVAR display_format, fmt_entries
+        return map(copy(a:list), 'self.FormatName(cache, display_format, v:val)')
+    else
+        return a:list
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.Set_highlight_filename() dict "{{{3
+    let self.tlib_UseInputListScratch = 'call world.Highlight_filename()'
+endf
+
+
+if g:tlib#input#format_filename == 'r'
+
+    " :nodoc:
+    function! s:prototype.Highlight_filename() dict "{{{3
+        syntax match TLibDir /\s\+\zs.\{-}[\/]\ze[^\/]\+$/
+        hi def link TLibDir Directory
+        syntax match TLibFilename /[^\/]\+$/
+        hi def link TLibFilename Normal
+    endf
+
+    " :nodoc:
+    function! s:prototype.FormatFilename(file) dict "{{{3
+        if !has_key(self.fmt_options, 'maxlen')
+            let maxco = &co - len(len(self.base)) - eval(g:tlib#input#filename_padding_r)
+            let maxfi = max(map(copy(self.base), 'strwidth(v:val)'))
+            let self.fmt_options.maxlen = min([maxco, maxfi])
+            " TLogVAR maxco, maxfi, self.fmt_options.maxlen
+        endif
+        let max = self.fmt_options.maxlen
+        if len(a:file) > max
+            let filename = '...' . strpart(a:file, len(a:file) - max + 3)
+        else
+            let filename = printf('% '. max .'s', a:file)
+        endif
+        return filename
+    endf
+
+else
+
+    " :nodoc:
+    function! s:prototype.Highlight_filename() dict "{{{3
+        " let self.width_filename = 1 + eval(g:tlib_inputlist_width_filename)
+        " TLogVAR self.base
+        let self.width_filename = min([
+                    \ get(self, 'width_filename', &co),
+                    \ empty(g:tlib#input#filename_max_width) ? &co : eval(g:tlib#input#filename_max_width),
+                    \ max(map(copy(self.base), 'strwidth(matchstr(v:val, "[^\\/]*$"))'))
+                    \ ])
+       "  TLogVAR self.width_filename
+         exec 'syntax match TLibDir /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename'
+         exec 'syntax match TLibMarker /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \S.*$/ contains=TLibDir'
+       "  exec 'syntax match TLibDir /\(|\|\[.\{-}\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename'
+       "  exec 'syntax match TLibMarker /\(|\|\[.\{-}\]\) \S.*$/ contains=TLibDir'
+        exec 'syntax match TLibFilename /[^\/]\+$/ contained containedin=TLibDir'
+        hi def link TLibMarker Special
+        hi def link TLibDir Directory
+        hi def link TLibFilename NonText
+        " :nodoc:
+        function! self.Highlighter(rx) dict
+            let rx = '/\c\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) .\{-}\zs'. escape(a:rx, '/') .'/'
+            exec 'match' self.matcher.highlight rx
+        endf
+    endf
+
+
+    " :nodoc:
+    function! s:prototype.UseFilenameIndicators() dict "{{{3
+        return g:tlib_inputlist_filename_indicators || has_key(self, 'filename_indicators')
+    endf
+
+
+    " :nodoc:
+    function! s:prototype.InitFormatName() dict "{{{3 
+        if self.UseFilenameIndicators()
+            let self._buffers = {}
+            for bufnr in range(1, bufnr('$'))
+                let filename = fnamemodify(bufname(bufnr), ':p')
+                " TLogVAR filename
+                let bufdef = {
+                            \ 'bufnr': bufnr,
+                            \ }
+                " '&buflisted'
+                for opt in ['&modified', '&bufhidden']
+                    let bufdef[opt] = getbufvar(bufnr, opt)
+                endfor
+                let self._buffers[filename] = bufdef
+            endfor
+        endif
+    endf
+
+
+    " :nodoc:
+    function! s:prototype.FormatFilename(file) dict "{{{3
+        " TLogVAR a:file
+        let width = self.width_filename
+        let split = match(a:file, '[/\\]\zs[^/\\]\+$')
+        if split == -1
+            let fname = a:file
+            let dname = a:file
+        else
+            let fname = strpart(a:file, split)
+            " let dname = strpart(a:file, 0, split - 1)
+            let dname = a:file
+        endif
+        if strwidth(fname) > width
+            let fname = strpart(fname, 0, width - 3) .'...'
+        endif
+        let dnmax = &co - max([width, strwidth(fname)]) - 8 - self.index_width - &fdc
+        let use_indicators = self.UseFilenameIndicators()
+        " TLogVAR use_indicators
+        let marker = []
+        if use_indicators
+            call insert(marker, '[')
+            if g:tlib_inputlist_filename_indicators
+                let bufdef = get(self._buffers, a:file, {})
+                " let bnr = bufnr(a:file)
+                let bnr = get(bufdef, 'bufnr', -1)
+                " TLogVAR a:file, bnr, self.bufnr
+                if bnr != -1
+                    if bnr == self.bufnr
+                        call add(marker, '%')
+                    else
+                        call add(marker, bnr)
+                    endif
+                    if get(bufdef, '&modified', 0)
+                        call add(marker, '+')
+                    endif
+                    if get(bufdef, '&bufhidden', '') == 'hide'
+                        call add(marker, 'h')
+                    endif
+                    " if !get(bufdef, '&buflisted', 1)
+                    "     call add(marker, 'u')
+                    " endif
+                    " echom "DBG" a:file string(get(self,'filename_indicators'))
+                endif
+            endif
+            if has_key(self, 'filename_indicators') && has_key(self.filename_indicators, a:file)
+                if len(marker) > 1
+                    call add(marker, '|')
+                endif
+                call add(marker, self.filename_indicators[a:file])
+            endif
+            if len(marker) <= 1
+                call add(marker, ' ')
+            endif
+            call add(marker, ']')
+        else
+            call add(marker, '|')
+        endif
+        let markers = join(marker, '')
+        if !empty(markers)
+            let dnmax -= len(markers)
+        endif
+        if strwidth(dname) > dnmax
+            let dname = '...'. strpart(dname, len(dname) - dnmax)
+        endif
+        return printf("%-*s %s %s",
+                    \ self.width_filename + len(fname) - strwidth(fname),
+                    \ fname, markers, dname)
+    endf
+
+endif
+
+
+" :nodoc:
+function! s:prototype.GetSelectedItems(current) dict "{{{3
+    " TLogVAR a:current
+    if stridx(self.type, 'i') != -1
+        let rv = copy(self.sel_idx)
+    else
+        let rv = map(copy(self.sel_idx), 'self.GetBaseItem(v:val)')
+    endif
+    if !empty(a:current)
+        " TLogVAR a:current, rv, type(a:current)
+        if tlib#type#IsNumber(a:current) || tlib#type#IsString(a:current)
+            call s:InsertSelectedItems(rv, a:current)
+        elseif tlib#type#IsList(a:current)
+            for item in a:current
+                call s:InsertSelectedItems(rv, item)
+            endfor
+        elseif tlib#type#IsDictionary(a:current)
+            for [inum, item] in items(a:current)
+                call s:InsertSelectedItems(rv, item)
+            endfor
+        endif
+    endif
+    " TAssert empty(rv) || rv[0] == a:current
+    if stridx(self.type, 'i') != -1
+        if !empty(self.index_table)
+            " TLogVAR rv, self.index_table
+            call map(rv, 'self.index_table[v:val - 1]')
+            " TLogVAR rv
+        endif
+    endif
+    return rv
+endf
+
+
+function! s:InsertSelectedItems(rv, current) "{{{3
+    let ci = index(a:rv, a:current)
+    if ci != -1
+        call remove(a:rv, ci)
+    endif
+    call insert(a:rv, a:current)
+endf
+
+
+" :nodoc:
+function! s:prototype.SelectItemsByNames(mode, items) dict "{{{3
+    for item in a:items
+        let bi = index(self.base, item) + 1
+        " TLogVAR item, bi
+        if bi > 0
+            let si = index(self.sel_idx, bi)
+            " TLogVAR self.sel_idx
+            " TLogVAR si
+            if si == -1
+                call add(self.sel_idx, bi)
+            elseif a:mode == 'toggle'
+                call remove(self.sel_idx, si)
+            endif
+        endif
+    endfor
+    return 1
+endf
+
+
+" :nodoc:
+function! s:prototype.SelectItem(mode, index) dict "{{{3
+    " TLogVAR a:mode, a:index
+    let bi = self.GetBaseIdx(a:index)
+    " if self.RespondTo('MaySelectItem')
+    "     if !self.MaySelectItem(bi)
+    "         return 0
+    "     endif
+    " endif
+    " TLogVAR bi
+    let si = index(self.sel_idx, bi)
+    " TLogVAR self.sel_idx
+    " TLogVAR si
+    if si == -1
+        call add(self.sel_idx, bi)
+    elseif a:mode == 'toggle'
+        call remove(self.sel_idx, si)
+    endif
+    return 1
+endf
+
+
+" :nodoc:
+function! s:prototype.FormatBaseFromData() abort dict "{{{3
+    if has_key(self, 'format_data') && has_key(self, 'data')
+        let self.base = map(copy(self.data), 'call(self.format_data, [v:val], self)')
+    endif    
+endf
+
+
+" :nodoc:
+function! s:prototype.FormatArgs(format_string, arg) dict "{{{3
+    let nargs = len(substitute(a:format_string, '%%\|[^%]', '', 'g'))
+    return [a:format_string] + repeat([string(a:arg)], nargs)
+endf
+
+
+" :nodoc:
+function! s:prototype.GetRx(filter) dict "{{{3
+    return '\('. join(filter(copy(a:filter), 'v:val[0] != "!"'), '\|') .'\)' 
+endf
+
+
+" :nodoc:
+function! s:prototype.GetRx0(...) dict "{{{3
+    exec tlib#arg#Let(['negative'])
+    let rx0 = []
+    for filter in self.filter
+        " TLogVAR filter
+        let rx = join(reverse(filter(copy(filter), '!empty(v:val)')), '\|')
+        " TLogVAR rx
+        if !empty(rx) && (negative ? rx[0] == g:tlib#input#not : rx[0] != g:tlib#input#not)
+            call add(rx0, rx)
+        endif
+    endfor
+    let rx0s = join(rx0, '\|')
+    if empty(rx0s)
+        return ''
+    else
+        return self.FilterRxPrefix() .'\('. rx0s .'\)'
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.FormatName(cache, format, value) dict "{{{3
+    " TLogVAR a:format, a:value
+    " TLogDBG has_key(self.fmt_display, a:value)
+    if has_key(a:cache, a:value)
+        " TLogDBG "cached"
+        return a:cache[a:value]
+    else
+        let world = self
+        let ftpl = self.FormatArgs(a:format, a:value)
+        let fn = call(function("printf"), ftpl)
+        let fmt = eval(fn)
+        " TLogVAR ftpl, fn, fmt
+        let a:cache[a:value] = fmt
+        return fmt
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.GetItem(idx) dict "{{{3
+    return self.list[a:idx - 1]
+endf
+
+
+" :nodoc:
+function! s:prototype.GetListIdx(baseidx) dict "{{{3
+    " if empty(self.index_table)
+        let baseidx = a:baseidx
+    " else
+    "     let baseidx = 0 + self.index_table[a:baseidx - 1]
+    "     " TLogVAR a:baseidx, baseidx, self.index_table 
+    " endif
+    let rv = index(self.table, baseidx)
+    " TLogVAR rv, self.table
+    return rv
+endf
+
+
+" :nodoc:
+" The first index is 1.
+function! s:prototype.GetBaseIdx(idx) dict "{{{3
+    " TLogVAR a:idx, self.table, self.index_table
+    if !empty(self.table) && a:idx > 0 && a:idx <= len(self.table)
+        return self.table[a:idx - 1]
+    else
+        return 0
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.GetBaseIdx0(idx) dict "{{{3
+    let idx0 = self.GetBaseIdx(a:idx) - 1
+    if idx0 < 0
+        call tlib#notify#Echo('TLIB: Internal Error: GetBaseIdx0: idx0 < 0', 'WarningMsg')
+    endif
+    return idx0
+endf
+
+
+" :nodoc:
+function! s:prototype.GetBaseItem(idx) dict "{{{3
+    return self.base[a:idx - 1]
+endf
+
+
+" :nodoc:
+function! s:prototype.SetBaseItem(idx, item) dict "{{{3
+    let self.base[a:idx - 1] = a:item
+endf
+
+
+" :nodoc:
+function! s:prototype.GetLineIdx(lnum) dict "{{{3
+    let line = getline(a:lnum)
+    let prefidx = substitute(matchstr(line, '^\d\+\ze[*:]'), '^0\+', '', '')
+    return prefidx
+endf
+
+
+" :nodoc:
+function! s:prototype.SetPrefIdx() dict "{{{3
+    " let pref = sort(range(1, self.llen), 'self.SortPrefs')
+    " let self.prefidx = get(pref, 0, self.initial_index)
+    let pref_idx = -1
+    let pref_weight = -1
+    " TLogVAR self.filter_pos, self.filter_neg
+    " let t0 = localtime() " DBG
+    for idx in range(1, self.llen)
+        let item = self.GetItem(idx)
+        let weight = self.matcher.AssessName(self, item)
+        " TLogVAR item, weight
+        if weight > pref_weight
+            let pref_idx = idx
+            let pref_weight = weight
+        endif
+    endfor
+    " TLogVAR localtime() - t0
+    " TLogVAR pref_idx
+    " TLogDBG self.GetItem(pref_idx)
+    if pref_idx == -1
+        let self.prefidx = self.initial_index
+    else
+        let self.prefidx = pref_idx
+    endif
+endf
+
+
+" " :nodoc:
+" function! s:prototype.GetCurrentItem() dict "{{{3
+"     let idx = self.prefidx
+"     " TLogVAR idx
+"     if stridx(self.type, 'i') != -1
+"         return idx
+"     elseif !empty(self.list)
+"         if len(self.list) >= idx
+"             let idx1 = idx - 1
+"             let rv = self.list[idx - 1]
+"             " TLogVAR idx, idx1, rv, self.list
+"             return rv
+"         endif
+"     else
+"         return ''
+"     endif
+" endf
+
+
+" :nodoc:
+function! s:prototype.CurrentItem() dict "{{{3
+    if stridx(self.type, 'i') != -1
+        return self.GetBaseIdx(self.llen == 1 ? 1 : self.prefidx)
+    else
+        if self.llen == 1
+            " TLogVAR self.llen
+            return self.list[0]
+        elseif self.prefidx > 0
+            " TLogVAR self.prefidx
+            " return self.GetCurrentItem()
+            if len(self.list) >= self.prefidx
+                let rv = self.list[self.prefidx - 1]
+                " TLogVAR idx, rv, self.list
+                return rv
+            endif
+        else
+            return ''
+        endif
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.FilterRxPrefix() dict "{{{3
+    return self.matcher.FilterRxPrefix()
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFilter() dict "{{{3
+    " let mrx = '\V'. (a:0 >= 1 && a:1 ? '\C' : '')
+    let mrx = self.FilterRxPrefix() . self.filter_options
+    let self.filter_pos = []
+    let self.filter_neg = []
+    " TLogVAR mrx, self.filter
+    for filter in self.filter
+        " TLogVAR filter
+        let rx = join(reverse(filter(copy(filter), '!empty(v:val)')), '\|')
+        " TLogVAR rx
+        if !empty(rx)
+            if rx =~ '\u'
+                let mrx1 = mrx .'\C'
+            else
+                let mrx1 = mrx
+            endif
+            " TLogVAR rx
+            if rx[0] == g:tlib#input#not
+                if len(rx) > 1
+                    call add(self.filter_neg, mrx1 .'\('. rx[1:-1] .'\)')
+                endif
+            else
+                call add(self.filter_pos, mrx1 .'\('. rx .'\)')
+            endif
+        endif
+    endfor
+    " TLogVAR self.filter_pos, self.filter_neg
+endf
+
+
+" :nodoc:
+function! s:prototype.IsValidFilter() dict "{{{3
+    let last = self.FilterRxPrefix() .'\('. self.filter[0][0] .'\)'
+    Tlibtrace 'tlib', last
+    " TLogVAR last
+    try
+        let a = match("", last)
+        return 1
+    catch
+        Tlibtrace 'tlib', v:exception
+        return 0
+    endtry
+endf
+
+
+" :nodoc:
+function! s:prototype.SetMatchMode(match_mode) dict "{{{3
+    " TLogVAR a:match_mode
+    if !empty(a:match_mode)
+        unlet self.matcher
+        try
+            let self.matcher = tlib#Filter_{a:match_mode}#New()
+            call self.matcher.Init(self)
+        catch /^Vim\%((\a\+)\)\=:E117/
+            throw 'tlib: Unknown mode for tlib#input#filter_mode: '. a:match_mode
+        endtry
+    endif
+endf
+
+
+" function! s:prototype.Match(text) dict "{{{3
+"     return self.matcher.Match(self, text)
+" endf
+
+
+" :nodoc:
+function! s:prototype.MatchBaseIdx(idx) dict "{{{3
+    let text = self.GetBaseItem(a:idx)
+    if !empty(self.filter_format)
+        let text = self.FormatName(self.fmt_filter, self.filter_format, text)
+    endif
+    " TLogVAR text
+    " return self.Match(text)
+    return self.matcher.Match(self, text)
+endf
+
+
+" :nodoc:
+function! s:prototype.BuildTableList() dict "{{{3
+    " let time0 = str2float(reltimestr(reltime()))  " DBG
+    " TLogVAR time0
+    call self.SetFilter()
+    " TLogVAR self.filter_neg, self.filter_pos
+    let self.table = range(1, len(self.base))
+    " TLogVAR self.filtered_items
+    let copy_base = 1
+    if !empty(self.filtered_items)
+        let self.table = filter(self.table, 'index(self.filtered_items, v:val) != -1')
+        let copy_base = 0
+    endif
+    if !empty(self.filter_pos) || !empty(self.filter_neg)
+        let self.table = filter(self.table, 'self.MatchBaseIdx(v:val)')
+        let copy_base = 0
+    endif
+    if copy_base
+        let self.list = copy(self.base)
+    else
+        let self.list  = map(copy(self.table), 'self.GetBaseItem(v:val)')
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.ReduceFilter() dict "{{{3
+    " TLogVAR self.filter
+    let reduced = 0
+    while !reduced
+        if self.filter[0] == [''] && len(self.filter) > 1
+            call remove(self.filter, 0)
+        elseif empty(self.filter[0][0]) && len(self.filter[0]) > 1
+            call remove(self.filter[0], 0)
+        else
+            call self.matcher.ReduceFrontFilter(self)
+        endif
+        if self.IsValidFilter()
+            let reduced = 1
+        endif
+    endwh
+endf
+
+
+" :nodoc:
+" filter is either a string or a list of list of strings.
+function! s:prototype.SetInitialFilter(filter) dict "{{{3
+    " let self.initial_filter = [[''], [a:filter]]
+    Tlibtrace 'tlib', a:filter
+    if type(a:filter) == 3
+        let self.initial_filter = deepcopy(a:filter)
+    else
+        let self.initial_filter = [[a:filter]]
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.PopFilter() dict "{{{3
+    " TLogVAR self.filter
+    if len(self.filter[0]) > 1
+        call remove(self.filter[0], 0)
+    elseif len(self.filter) > 1
+        call remove(self.filter, 0)
+    else
+        let self.filter[0] = ['']
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.FilterIsEmpty() dict "{{{3
+    " TLogVAR self.filter
+    return self.filter == copy(self.initial_filter)
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayFilter() dict "{{{3
+    let filter1 = copy(self.filter)
+    call filter(filter1, 'v:val != [""]')
+    " TLogVAR self.matcher['_class']
+    let rv = self.matcher.DisplayFilter(filter1)
+    let rv = self.CleanFilter(rv)
+    return rv
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(pattern) dict "{{{3
+    call self.matcher.SetFrontFilter(self, a:pattern)
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(char) dict "{{{3
+    call self.matcher.PushFrontFilter(self, a:char)
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return self.matcher.CleanFilter(a:filter)
+endf
+
+
+" :nodoc:
+function! s:prototype.UseScratch() dict "{{{3
+    " if type(self.scratch) != 0 && get(self, 'buffer_local', 1)
+    "     if self.scratch != fnamemodify(self.scratch, ':p')
+    "         let self.scratch = tlib#file#Join([expand('%:p:h'), self.scratch])
+    "         " TLogVAR self.scratch
+    "     endif
+    "     " let self.scratch_hidden = 'wipe'
+    " endif
+    keepjumps keepalt let rv = tlib#scratch#UseScratch(self)
+    " if expand('%:t') == self.scratch
+        let b:tlib_world = self
+    " endif
+    return rv
+endf
+
+
+" :nodoc:
+function! s:prototype.CloseScratch(...) dict "{{{3
+    TVarArg ['reset_scratch', 0]
+    " TVarArg ['reset_scratch', 1]
+    " TLogVAR reset_scratch
+    if self.sticky
+        return 0
+    else
+        let rv = tlib#scratch#CloseScratch(self, reset_scratch)
+        " TLogVAR rv
+        if rv
+            call self.SwitchWindow('win')
+        endif
+        return rv
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.Initialize() dict "{{{3
+    let self.initialized = 1
+    call self.SetOrigin(1)
+    call self.Reset(1)
+    if !empty(self.cache_var) && exists(self.cache_var)
+        for prop in self.restore_from_cache
+            exec 'let self[prop] = get('. self.cache_var .', prop, self[prop])'
+        endfor
+        exec 'unlet '. self.cache_var
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.Leave() dict "{{{3
+    if !empty(self.cache_var)
+        exec 'let '. self.cache_var .' = self'
+    endif
+    for handler in self.on_leave
+        call call(handler, [self])
+    endfor
+endf
+
+
+" :nodoc:
+function! s:prototype.UseInputListScratch() dict "{{{3
+    let scratch = self.UseScratch()
+    if !exists('b:tlib_list_init')
+        call tlib#autocmdgroup#Init()
+        autocmd TLib VimResized <buffer> call feedkeys("\<c-j>", 't')
+        " autocmd TLib WinLeave <buffer> let b:tlib_world_event = 'WinLeave' | call feedkeys("\<c-j>", 't')
+        let b:tlib_list_init = 1
+    endif
+    if !exists('w:tlib_list_init')
+        " TLogVAR scratch
+        if has_key(self, 'index_next_syntax')
+            if type(self.index_next_syntax) == 1
+                exec 'syntax match InputlListIndex /^\d\+:\s/ nextgroup='. self.index_next_syntax
+            elseif type(self.index_next_syntax) == 4
+                for [n, nsyn] in items(self.index_next_syntax)
+                    let fn = printf('%0'. world.index_width .'d', n)
+                    exec 'syntax match InputlListIndex /^'. fn .':\s/ nextgroup='. nsyn
+                endfor
+            endif
+        else
+            syntax match InputlListIndex /^\d\+:\s/
+        endif
+        call tlib#hook#Run('tlib_UseInputListScratch', self)
+        syntax match InputlListCursor /^\d\+\* .*$/ contains=InputlListIndex
+        syntax match InputlListSelected /^\d\+# .*$/ contains=InputlListIndex
+        hi def link InputlListIndex Constant
+        hi def link InputlListCursor Search
+        hi def link InputlListSelected IncSearch
+        setlocal nowrap
+        " hi def link InputlListIndex Special
+        " let b:tlibDisplayListMarks = {}
+        let b:tlibDisplayListMarks = []
+        let b:tlibDisplayListWorld = self
+        let w:tlib_list_init = 1
+    endif
+    return scratch
+endf
+
+
+" s:prototype.Reset(?initial=0)
+" :nodoc:
+function! s:prototype.Reset(...) dict "{{{3
+    TVarArg ['initial', 0]
+    " TLogVAR initial
+    Tlibtrace 'tlib', initial, self.initial_filter
+    let self.state     = 'display'
+    let self.offset    = 1
+    let self.filter    = deepcopy(self.initial_filter)
+    let self.idx       = ''
+    let self.prefidx   = 0
+    let self.initial_display = 1
+    let self.fmt_display = {}
+    let self.fmt_filter = {}
+    call self.UseInputListScratch()
+    call self.ResetSelected()
+    call self.Retrieve(!initial)
+    call self.FormatBaseFromData()
+    return self
+endf
+
+
+" :nodoc:
+function! s:prototype.ResetSelected() dict "{{{3
+    let self.sel_idx   = []
+endf
+
+
+" :nodoc:
+function! s:prototype.Retrieve(anyway) dict "{{{3
+    " TLogVAR a:anyway, self.base
+    " TLogDBG (a:anyway || empty(self.base))
+    if (a:anyway || empty(self.base))
+        let ra = self.retrieve_eval
+        " TLogVAR ra
+        if !empty(ra)
+            let back  = self.SwitchWindow('win')
+            let world = self
+            let self.base = eval(ra)
+            " TLogVAR self.base
+            exec back
+            return 1
+        endif
+    endif
+    return 0
+endf
+
+
+function! s:FormatHelp(help) "{{{3
+    " TLogVAR a:help
+    let max = [0, 0]
+    for item in a:help
+        " TLogVAR item
+        if type(item) == 3
+            let itemlen = map(copy(item), 'strwidth(v:val)')
+            " TLogVAR itemlen
+            let max = map(range(2), 'max[v:val] >= itemlen[v:val] ? max[v:val] : itemlen[v:val]')
+        endif
+        unlet item
+    endfor
+    " TLogVAR max
+    let cols = float2nr((winwidth(0) - &foldcolumn - 1) / (max[0] + max[1] + 2))
+    if cols < 1
+        let cols = 1
+    endif
+    let fmt = printf('%%%ds: %%-%ds', max[0], max[1])
+    " TLogVAR cols, fmt
+    let help = []
+    let idx = -1
+    let maxidx = len(a:help)
+    while idx < maxidx
+        let push_item = 0
+        let accum = []
+        for i in range(cols)
+            let idx += 1
+            if idx >= maxidx
+                break
+            endif
+            let item = a:help[idx]
+            if type(item) == 3
+                call add(accum, item)
+            else
+                let push_item = 1
+                break
+            endif
+            unlet item
+        endfor
+        if !empty(accum)
+            call add(help, s:FormatHelpItem(accum, fmt))
+        endif
+        if push_item
+            call add(help, a:help[idx])
+        endif
+    endwh
+    " TLogVAR help
+    return help
+endf
+
+
+function! s:FormatHelpItem(item, fmt) "{{{3
+    let args = [join(repeat([a:fmt], len(a:item)), '  ')]
+    for item in a:item
+        " TLogVAR item
+        let args += item
+    endfor
+    " TLogVAR args
+    return call('printf', args)
+endf
+
+
+" :nodoc:
+function! s:prototype.InitHelp() dict "{{{3
+    return []
+endf
+
+
+" :nodoc:
+function! s:prototype.PushHelp(...) dict "{{{3
+    " TLogVAR a:000
+    if a:0 == 1
+        if type(a:1) == 3
+            let self.temp_lines += a:1
+        else
+            call add(self.temp_lines, a:1)
+        endif
+    elseif a:0 == 2
+        call add(self.temp_lines, a:000)
+    else
+        throw "TLIB: PushHelp: Wrong number of arguments: ". string(a:000)
+    endif
+    " TLogVAR helpstring
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayHelp() dict "{{{3
+    let self.temp_lines = self.InitHelp()
+    call self.PushHelp('<Esc>', self.key_mode == 'default' ? 'Abort' : 'Reset keymap')
+    call self.PushHelp('Enter, <cr>', 'Pick the current item')
+    call self.PushHelp('Mouse', 'L: Pick item, R: Show menu')
+    call self.PushHelp('<M-Number>',  'Select an item')
+    call self.PushHelp('<BS>, <C-BS>', 'Reduce filter')
+    call self.PushHelp('<Tab>', 'Complete word')
+    call self.PushHelp('<S-Esc>, <F10>', 'Enter command')
+
+    if self.key_mode == 'default'
+        call self.PushHelp('<C|M-r>',      'Reset the display')
+        call self.PushHelp('Up/Down',      'Next/previous item')
+        call self.PushHelp('<C|M-q>',      'Edit top filter string')
+        call self.PushHelp('Page Up/Down', 'Scroll')
+        call self.PushHelp('<S-Space>',    'Enter * Wildcard')
+        if self.allow_suspend
+            call self.PushHelp('<C|M-z>', 'Suspend/Resume')
+            call self.PushHelp('<C-o>', 'Switch to origin')
+        endif
+        if stridx(self.type, 'm') != -1
+            call self.PushHelp('<S-Up/Down>', '(Un)Select items')
+            call self.PushHelp('#', '(Un)Select the current item')
+            call self.PushHelp('<C|M-a>', '(Un)Select all items')
+            call self.PushHelp('<F9>', '(Un)Restrict view to selection')
+            " \ '<c-\>        ... Show only selected',
+        endif
+    endif
+
+    " TLogVAR len(self.temp_lines)
+    call self.matcher.Help(self)
+
+    " TLogVAR self.key_mode
+    for handler in values(self.key_map[self.key_mode])
+        " TLogVAR handler
+        let key = get(handler, 'key_name', '')
+        " TLogVAR key
+        if !empty(key)
+            let desc = get(handler, 'help', '')
+            if empty(desc)
+                let desc = get(handler, 'agent', '')
+            endif
+            call self.PushHelp(key, desc)
+        endif
+    endfor
+
+    if !has_key(self.key_map[self.key_mode], 'unknown_key')
+        call self.PushHelp('Letter', 'Filter the list')
+    endif
+
+    if self.key_mode == 'default' && !empty(self.help_extra)
+        call self.PushHelp(self.help_extra)
+    endif
+
+    " TLogVAR len(self.temp_lines)
+    call self.PushHelp([
+                \ '',
+                \ 'Matches at word boundaries are prioritized.',
+                \ ])
+    let self.temp_lines = s:FormatHelp(self.temp_lines)
+    call self.PrintLines()
+endf
+
+
+function! s:prototype.PrintLines() dict "{{{3
+    let self.temp_prompt = ['Press any key to continue.', 'Question']
+    call tlib#buffer#DeleteRange('1', '$')
+    call append(0, self.temp_lines)
+    call tlib#buffer#DeleteRange('$', '$')
+    1
+    call self.Resize(len(self.temp_lines), 0)
+    let self.temp_lines = []
+endf
+
+
+" :nodoc:
+function! s:prototype.Resize(hsize, vsize) dict "{{{3
+    " TLogVAR self.scratch_vertical, a:hsize, a:vsize
+    let world_resize = ''
+    let winpos = ''
+    let scratch_split = get(self, 'scratch_split', 1)
+    " TLogVAR scratch_split
+    if scratch_split > 0
+        if self.scratch_vertical
+            if a:vsize
+                let world_resize = 'vert resize '. a:vsize
+                let winpos = tlib#fixes#Winpos()
+                " let w:winresize = {'v': a:vsize}
+                setlocal winfixwidth
+            endif
+        else
+            if a:hsize
+                let world_resize = 'resize '. a:hsize
+                " let w:winresize = {'h': a:hsize}
+                setlocal winfixheight
+            endif
+        endif
+    endif
+    if !empty(world_resize)
+        " TLogVAR world_resize, winpos
+        exec world_resize
+        if !empty(winpos)
+            exec winpos
+        endif
+        " redraw!
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.GetResize(size) dict "{{{3
+    let resize0 = get(self, 'resize', 0)
+    let resize = empty(resize0) ? 0 : eval(resize0)
+    " TLogVAR resize0, resize
+    let resize = resize == 0 ? a:size : min([a:size, resize])
+    " let min = self.scratch_vertical ? &cols : &lines
+    let min1 = (self.scratch_vertical ? self.win_width : self.win_height) * g:tlib_inputlist_pct
+    let min2 = (self.scratch_vertical ? &columns : &lines) * self.win_pct
+    let min = max([min1, min2])
+    let resize = min([resize, (min / 100)])
+    " TLogVAR resize, a:size, min, min1, min2
+    return resize
+endf
+
+
+" function! s:prototype.DisplayList(?query=self.Query(), ?list=[])
+" :nodoc:
+function! s:prototype.DisplayList(...) dict "{{{3
+    " TLogVAR self.state
+    let query = a:0 >= 1 ? a:1 : self.Query()
+    let list = a:0 >= 2 ? a:2 : []
+    " TLogVAR query, len(list)
+    " TLogDBG 'len(list) = '. len(list)
+    call self.UseScratch()
+    " TLogVAR self.scratch
+    " TAssert IsNotEmpty(self.scratch)
+    if self.state == 'scroll'
+        call self.ScrollToOffset()
+    elseif self.state == 'help'
+        call self.DisplayHelp()
+        call self.SetStatusline(query)
+    elseif self.state == 'printlines'
+        call self.PrintLines()
+        call self.SetStatusline(query)
+    else
+        " TLogVAR query
+        " let ll = len(list)
+        let ll = self.llen
+        " let x  = len(ll) + 1
+        let x  = self.index_width + 1
+        " TLogVAR ll
+        if self.state =~ '\<display\>'
+            call self.Resize(self.GetResize(ll), eval(get(self, 'resize_vertical', 0)))
+            call tlib#normal#WithRegister('gg"tdG', 't')
+            let lines = copy(list)
+            let lines = map(lines, 'substitute(v:val, ''[[:cntrl:][:space:]]'', " ", "g")')
+            let w = winwidth(0) - &fdc
+            " let w = winwidth(0) - &fdc - 1
+            let lines = map(lines, 'printf("%-'. w .'.'. w .'s", v:val)')
+            " TLogVAR lines
+            call append(0, lines)
+            call tlib#normal#WithRegister('G"tddgg', 't')
+        endif
+        " TLogVAR self.prefidx
+        let base_pref = self.GetBaseIdx(self.prefidx)
+        " TLogVAR base_pref
+        if self.state =~ '\<redisplay\>'
+            call filter(b:tlibDisplayListMarks, 'index(self.sel_idx, v:val) == -1 && v:val != base_pref')
+            " TLogVAR b:tlibDisplayListMarks
+            call map(b:tlibDisplayListMarks, 'self.DisplayListMark(x, v:val, ":")')
+            " let b:tlibDisplayListMarks = map(copy(self.sel_idx), 'self.DisplayListMark(x, v:val, "#")')
+            " call add(b:tlibDisplayListMarks, self.prefidx)
+            " call self.DisplayListMark(x, self.GetBaseIdx(self.prefidx), '*')
+        endif
+        let b:tlibDisplayListMarks = map(copy(self.sel_idx), 'self.DisplayListMark(x, v:val, "#")')
+        call add(b:tlibDisplayListMarks, base_pref)
+        call self.DisplayListMark(x, base_pref, '*')
+        call self.SetOffset()
+        call self.SetStatusline(query)
+        " TLogVAR self.offset
+        call self.ScrollToOffset()
+        let rx0 = self.GetRx0()
+        " TLogVAR rx0
+        if !empty(self.matcher.highlight)
+            if empty(rx0)
+                match none
+            elseif self.IsValidFilter()
+                if has_key(self, 'Highlighter')
+                    call self.Highlighter(rx0)
+                else
+                    exec 'match '. self.matcher.highlight .' /\c'. escape(rx0, '/') .'/'
+                endif
+            endif
+        endif
+    endif
+    redraw
+endf
+
+
+" :nodoc:
+function! s:prototype.SetStatusline(query) dict "{{{3
+    " TLogVAR a:query
+    if !empty(self.temp_prompt)
+        let echo = get(self.temp_prompt, 0, '')
+        let hl = get(self.temp_prompt, 1, 'Normal')
+        let self.temp_prompt = []
+    else
+        let hl = 'Normal'
+        let query   = a:query
+        let options = [self.matcher.name]
+        if self.sticky
+            call add(options, '#')
+        endif
+        if self.key_mode != 'default'
+            call add(options, 'map:'. self.key_mode)
+        endif
+        if !empty(self.filtered_items)
+            if g:tlib_inputlist_shortmessage
+                call add(options, 'R')
+            else
+                call add(options, 'restricted')
+            endif
+        endif
+        if !empty(options)
+            let sopts = printf('[%s]', join(options, ', '))
+            " let echo  = query . repeat(' ', &columns - len(sopts) - len(query) - 20) . sopts
+            let echo  = query . '  ' . sopts
+            " let query .= '%%='. sopts .' '
+        endif
+        " TLogVAR &l:statusline, query
+        " let &l:statusline = query
+    endif
+    echo
+    if hl != 'Normal'
+        exec 'echohl' hl
+        echo echo
+        echohl None
+    else
+        echo echo
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.Query() dict "{{{3
+    let flt = self.DisplayFilter()
+    if g:tlib_inputlist_shortmessage
+        let query = 'Filter: '. flt
+    else
+        let query = self.query .' (filter: '. flt .'; press <F1> for help)'
+    endif
+    return query
+endf
+
+
+" :nodoc:
+function! s:prototype.ScrollToOffset() dict "{{{3
+    " TLogVAR self.scratch_vertical, self.llen, winheight(0)
+    exec 'norm! '. self.offset .'zt'
+endf
+
+
+" :nodoc:
+function! s:prototype.SetOffset() dict "{{{3
+    " TLogVAR self.prefidx, self.offset
+    " TLogDBG winheight(0)
+    " TLogDBG self.prefidx > self.offset + winheight(0) - 1
+    let listtop = len(self.list) - winheight(0) + 1
+    if listtop < 1
+        let listtop = 1
+    endif
+    if self.prefidx > listtop
+        let self.offset = listtop
+    elseif self.prefidx > self.offset + winheight(0) - 1
+        let listoff = self.prefidx - winheight(0) + 1
+        let self.offset = min([listtop, listoff])
+    "     TLogVAR self.prefidx
+    "     TLogDBG len(self.list)
+    "     TLogDBG winheight(0)
+    "     TLogVAR listtop, listoff, self.offset
+    elseif self.prefidx < self.offset
+        let self.offset = self.prefidx
+    endif
+    " TLogVAR self.offset
+endf
+
+
+" :nodoc:
+function! s:prototype.ClearAllMarks() dict "{{{3
+    let x = self.index_width + 1
+    call map(range(1, line('$')), 'self.DisplayListMark(x, v:val, ":")')
+endf
+
+
+" :nodoc:
+function! s:prototype.MarkCurrent(y) dict "{{{3
+    let x = self.index_width + 1
+    call self.DisplayListMark(x, a:y, '*')
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayListMark(x, y, mark) dict "{{{3
+    " TLogVAR a:y, a:mark
+    if a:x > 0 && a:y >= 0
+        " TLogDBG a:x .'x'. a:y .' '. a:mark
+        let sy = self.GetListIdx(a:y) + 1
+        " TLogVAR sy
+        if sy >= 1
+            call setpos('.', [0, sy, a:x, 0])
+            exec 'norm! r'. a:mark
+            " exec 'norm! '. a:y .'gg'. a:x .'|r'. a:mark
+        endif
+    endif
+    return a:y
+endf
+
+
+" :nodoc:
+function! s:prototype.SwitchWindow(where) dict "{{{3
+    " TLogDBG string(tlib#win#List())
+    if self.tabpagenr != tabpagenr()
+        call tlib#tab#Set(self.tabpagenr)
+    endif
+    let wnr = get(self, a:where.'_wnr')
+    " TLogVAR self, wnr
+    return tlib#win#Set(wnr)
+endf
+
+
+" :nodoc:
+function! s:prototype.FollowCursor() dict "{{{3
+    if !empty(self.follow_cursor)
+        let back = self.SwitchWindow('win')
+        " TLogVAR back
+        " TLogDBG winnr()
+        try
+            call call(self.follow_cursor, [self, [self.CurrentItem()]])
+        finally
+            exec back
+        endtry
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.SetOrigin(...) dict "{{{3
+    TVarArg ['winview', 0]
+    " TLogVAR self.win_wnr, self.bufnr
+    " TLogDBG bufname('%')
+    " TLogDBG winnr()
+    " TLogDBG winnr('$')
+    let self.win_wnr = winnr()
+    let self.win_height = winheight(self.win_wnr)
+    let self.win_width = winwidth(self.win_wnr)
+    " TLogVAR self.win_wnr, self.win_height, self.win_width
+    let self.bufnr   = bufnr('%')
+    let self.tabpagenr = tabpagenr()
+    let self.cursor  = getpos('.')
+    if winview
+        let self.winview = tlib#win#GetLayout()
+    endif
+    " TLogVAR self.win_wnr, self.bufnr, self.winview
+    return self
+endf
+
+
+" :nodoc:
+function! s:prototype.RestoreOrigin(...) dict "{{{3
+    TVarArg ['winview', 0]
+    if winview
+        " TLogVAR winview
+        call tlib#win#SetLayout(self.winview)
+    endif
+    " TLogVAR self.win_wnr, self.bufnr, self.cursor, &splitbelow
+    " TLogDBG "RestoreOrigin0 ". string(tlib#win#List())
+    " If &splitbelow or &splitright is false, we cannot rely on 
+    " self.win_wnr to be our source buffer since, e.g, opening a buffer 
+    " in a split window changes the whole layout.
+    " Possible solutions:
+    " - Restrict buffer switching to cases when the number of windows 
+    "   hasn't changed.
+    " - Guess the right window, which we try to do here.
+    if &splitbelow == 0 || &splitright == 0
+        let wn = bufwinnr(self.bufnr)
+        " TLogVAR wn
+        if wn == -1
+            let wn = 1
+        end
+    else
+        let wn = self.win_wnr
+    endif
+    if wn != winnr()
+        exec wn .'wincmd w'
+    endif
+    exec 'buffer! '. self.bufnr
+    call setpos('.', self.cursor)
+    " TLogDBG "RestoreOrigin1 ". string(tlib#win#List())
+endf
+
+
+function! s:prototype.Suspend() dict "{{{3
+    call tlib#agent#Suspend(self, self.rv)
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/agent.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/agent.vim
new file mode 100644
index 0000000..e61f24b
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/agent.vim
@@ -0,0 +1,665 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    329
+
+
+" :filedoc:
+" Various agents for use as key handlers in tlib#input#List()
+
+" Number of items to move when pressing <c-up/down> in the input list window.
+TLet g:tlib_scroll_lines = 10
+
+
+" General {{{1
+
+function! tlib#agent#Exit(world, selected) "{{{3
+    if a:world.key_mode == 'default'
+        call a:world.CloseScratch()
+        let a:world.state = 'exit empty escape'
+        let a:world.list = []
+        " let a:world.base = []
+        call a:world.ResetSelected()
+    else
+        let a:world.key_mode = 'default'
+        let a:world.state = 'redisplay'
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#CopyItems(world, selected) "{{{3
+    let @* = join(a:selected, "\n")
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+
+" InputList related {{{1
+
+function! tlib#agent#PageUp(world, selected) "{{{3
+    let a:world.offset -= (winheight(0) / 2)
+    let a:world.state = 'scroll'
+    return a:world
+endf
+
+
+function! tlib#agent#PageDown(world, selected) "{{{3
+    let a:world.offset += (winheight(0) / 2)
+    let a:world.state = 'scroll'
+    return a:world
+endf
+
+
+function! tlib#agent#Home(world, selected) "{{{3
+    let a:world.prefidx = 1
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#End(world, selected) "{{{3
+    let a:world.prefidx = len(a:world.list)
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Up(world, selected, ...) "{{{3
+    TVarArg ['lines', 1]
+    let a:world.idx = ''
+    if a:world.prefidx > lines
+        let a:world.prefidx -= lines
+    else
+        let a:world.prefidx = len(a:world.list)
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Down(world, selected, ...) "{{{3
+    TVarArg ['lines', 1]
+    let a:world.idx = ''
+    if a:world.prefidx <= (len(a:world.list) - lines)
+        let a:world.prefidx += lines
+    else
+        let a:world.prefidx = 1
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#UpN(world, selected) "{{{3
+    return tlib#agent#Up(a:world, a:selected, g:tlib_scroll_lines)
+endf
+
+
+function! tlib#agent#DownN(world, selected) "{{{3
+    return tlib#agent#Down(a:world, a:selected, g:tlib_scroll_lines)
+endf
+
+
+function! tlib#agent#ShiftLeft(world, selected) "{{{3
+    let a:world.offset_horizontal -= (winwidth(0) / 2)
+    if a:world.offset_horizontal < 0
+        let a:world.offset_horizontal = 0
+    endif
+    let a:world.state = 'display shift'
+    return a:world
+endf
+
+
+function! tlib#agent#ShiftRight(world, selected) "{{{3
+    let a:world.offset_horizontal += (winwidth(0) / 2)
+    let a:world.state = 'display shift'
+    return a:world
+endf
+
+
+function! tlib#agent#Reset(world, selected) "{{{3
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#agent#ToggleRestrictView(world, selected) "{{{3
+    if empty(a:world.filtered_items)
+        return tlib#agent#RestrictView(a:world, a:selected)
+    else
+        return tlib#agent#UnrestrictView(a:world, a:selected)
+    endif
+endf
+
+
+function! tlib#agent#RestrictView(world, selected) "{{{3
+    " TLogVAR a:selected
+    let filtered_items = map(copy(a:selected), 'index(a:world.base, v:val) + 1')
+    " TLogVAR 1, filtered_items
+    let filtered_items = filter(filtered_items, 'v:val > 0')
+    " TLogVAR 2, filtered_items
+    if !empty(filtered_items)
+        let a:world.filtered_items = filtered_items
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#UnrestrictView(world, selected) "{{{3
+    let a:world.filtered_items = []
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#Input(world, selected) "{{{3
+    let flt0 = a:world.CleanFilter(a:world.filter[0][0])
+    let flt1 = input('Filter: ', flt0)
+    echo
+    if flt1 != flt0
+        if empty(flt1)
+            call getchar(0)
+        else
+            call a:world.SetFrontFilter(flt1)
+        endif
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+" Suspend (see |tlib#agent#Suspend|) the input loop and jump back to the 
+" original position in the parent window.
+function! tlib#agent#SuspendToParentWindow(world, selected) "{{{3
+    let world = a:world
+    let winnr = world.win_wnr
+    " TLogVAR winnr
+    if winnr != -1
+        let world = tlib#agent#Suspend(world, a:selected)
+        if world.state =~ '\<suspend\>'
+            call world.SwitchWindow('win')
+            " let pos = world.cursor
+            " " TLogVAR pos
+            " if !empty(pos)
+            "     call setpos('.', pos)
+            " endif
+            return world
+        endif
+    endif
+    let world.state = 'redisplay'
+    return world
+endf
+
+
+" Suspend lets you temporarily leave the input loop of 
+" |tlib#input#List|. You can resume editing the list by pressing <c-z>, 
+" <m-z>. <space>, <c-LeftMouse> or <MiddleMouse> in the suspended window.
+" <cr> and <LeftMouse> will immediatly select the item under the cursor.
+" < will select the item but the window will remain opened.
+function! tlib#agent#Suspend(world, selected) "{{{3
+    if a:world.allow_suspend
+        " TAssert IsNotEmpty(a:world.scratch)
+        " TLogDBG bufnr('%')
+        let br = tlib#buffer#Set(a:world.scratch)
+        " TLogVAR br, a:world.bufnr, a:world.scratch
+        if bufnr('%') != a:world.scratch
+            echohl WarningMsg
+            echom "tlib#agent#Suspend: Internal error: Not a scratch buffer:" bufname('%')
+            echohl NONE
+        endif
+        " TLogVAR bufnr('%'), bufname('%'), a:world.scratch
+        call tlib#autocmdgroup#Init()
+        exec 'autocmd TLib BufEnter <buffer='. a:world.scratch .'> call tlib#input#Resume("world", 0, '. a:world.scratch .')'
+        let b:tlib_world = a:world
+        exec br
+        let a:world.state = 'exit suspend'
+    else
+        echom 'Suspend disabled'
+        let a:world.state = 'redisplay'
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#Help(world, selected) "{{{3
+    let a:world.state = 'help'
+    return a:world
+endf
+
+
+function! tlib#agent#OR(world, selected) "{{{3
+    if !empty(a:world.filter[0])
+        call insert(a:world.filter[0], '')
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#AND(world, selected) "{{{3
+    if !empty(a:world.filter[0])
+        call insert(a:world.filter, [''])
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#ReduceFilter(world, selected) "{{{3
+    call a:world.ReduceFilter()
+    let a:world.offset = 1
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#PopFilter(world, selected) "{{{3
+    call a:world.PopFilter()
+    let a:world.offset = 1
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#Debug(world, selected) "{{{3
+    " echo string(world.state)
+    echo string(a:world.filter)
+    echo string(a:world.idx)
+    echo string(a:world.prefidx)
+    echo string(a:world.sel_idx)
+    call getchar()
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#Select(world, selected) "{{{3
+    call a:world.SelectItem('toggle', a:world.prefidx)
+    " let a:world.state = 'display keepcursor'
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#SelectUp(world, selected) "{{{3
+    call a:world.SelectItem('toggle', a:world.prefidx)
+    if a:world.prefidx > 1
+        let a:world.prefidx -= 1
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#SelectDown(world, selected) "{{{3
+    call a:world.SelectItem('toggle', a:world.prefidx)
+    if a:world.prefidx < len(a:world.list)
+        let a:world.prefidx += 1
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#SelectAll(world, selected) "{{{3
+    let listrange = range(1, len(a:world.list))
+    let mode = empty(filter(copy(listrange), 'index(a:world.sel_idx, a:world.GetBaseIdx(v:val)) == -1'))
+                \ ? 'toggle' : 'set'
+    for i in listrange
+        call a:world.SelectItem(mode, i)
+    endfor
+    let a:world.state = 'display keepcursor'
+    return a:world
+endf
+
+
+function! tlib#agent#ToggleStickyList(world, selected) "{{{3
+    let a:world.sticky = !a:world.sticky
+    let a:world.state = 'display keepcursor'
+    return a:world
+endf
+
+
+
+" EditList related {{{1
+
+function! tlib#agent#EditItem(world, selected) "{{{3
+    let lidx = a:world.prefidx
+    " TLogVAR lidx
+    " TLogVAR a:world.table
+    let bidx = a:world.GetBaseIdx(lidx)
+    " TLogVAR bidx
+    let item = a:world.GetBaseItem(bidx)
+    let item = input(lidx .'@'. bidx .': ', item)
+    if item != ''
+        call a:world.SetBaseItem(bidx, item)
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+" Insert a new item below the current one.
+function! tlib#agent#NewItem(world, selected) "{{{3
+    let basepi = a:world.GetBaseIdx(a:world.prefidx)
+    let item = input('New item: ')
+    call insert(a:world.base, item, basepi)
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#agent#DeleteItems(world, selected) "{{{3
+    let remove = copy(a:world.sel_idx)
+    let basepi = a:world.GetBaseIdx(a:world.prefidx)
+    if index(remove, basepi) == -1
+        call add(remove, basepi)
+    endif
+    " call map(remove, 'a:world.GetBaseIdx(v:val)')
+    for idx in reverse(sort(remove))
+        call remove(a:world.base, idx - 1)
+    endfor
+    let a:world.state = 'display'
+    call a:world.ResetSelected()
+    " let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#agent#Cut(world, selected) "{{{3
+    let world = tlib#agent#Copy(a:world, a:selected)
+    return tlib#agent#DeleteItems(world, a:selected)
+endf
+
+
+function! tlib#agent#Copy(world, selected) "{{{3
+    let a:world.clipboard = []
+    let bidxs = copy(a:world.sel_idx)
+    call add(bidxs, a:world.GetBaseIdx(a:world.prefidx))
+    for bidx in sort(bidxs)
+        call add(a:world.clipboard, a:world.GetBaseItem(bidx))
+    endfor
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Paste(world, selected) "{{{3
+    if has_key(a:world, 'clipboard')
+        for e in reverse(copy(a:world.clipboard))
+            call insert(a:world.base, e, a:world.prefidx)
+        endfor
+    endif
+    let a:world.state = 'display'
+    call a:world.ResetSelected()
+    return a:world
+endf
+
+
+function! tlib#agent#EditReturnValue(world, rv) "{{{3
+    return [a:world.state !~ '\<exit\>', a:world.base]
+endf
+
+
+
+" Files related {{{1
+
+function! tlib#agent#ViewFile(world, selected) "{{{3
+    if !empty(a:selected)
+        let back = a:world.SwitchWindow('win')
+        " TLogVAR back
+        for filename in a:selected
+            call tlib#file#Edit(filename)
+        endfor
+        " if !&hidden && &l:modified
+        "     let cmd0 = 'split'
+        "     let cmd1 = 'sbuffer'
+        " else
+        "     let cmd0 = 'edit'
+        "     let cmd1 = 'buffer'
+        " endif
+        " call tlib#file#With(cmd0, cmd1, a:selected, a:world)
+        " TLogVAR &filetype
+        exec back
+        let a:world.state = 'display'
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#EditFile(world, selected) "{{{3
+    return tlib#agent#Exit(tlib#agent#ViewFile(a:world, a:selected), a:selected)
+endf
+
+
+function! tlib#agent#EditFileInSplit(world, selected) "{{{3
+    call a:world.CloseScratch()
+    " call tlib#file#With('edit', 'buffer', a:selected[0:0], a:world)
+    " call tlib#file#With('split', 'sbuffer', a:selected[1:-1], a:world)
+    call tlib#file#With('split', 'sbuffer', a:selected, a:world)
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#EditFileInVSplit(world, selected) "{{{3
+    call a:world.CloseScratch()
+    " call tlib#file#With('edit', 'buffer', a:selected[0:0], a:world)
+    " call tlib#file#With('vertical split', 'vertical sbuffer', a:selected[1:-1], a:world)
+    let winpos = tlib#fixes#Winpos()
+    call tlib#file#With('vertical split', 'vertical sbuffer', a:selected, a:world)
+    if !empty(winpos)
+        exec winpos
+    endif
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#EditFileInTab(world, selected) "{{{3
+    " TLogVAR a:selected
+    call a:world.CloseScratch()
+    call tlib#file#With('tabedit', 'tab sbuffer', a:selected, a:world)
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#ToggleScrollbind(world, selected) "{{{3
+    let a:world.scrollbind = get(a:world, 'scrollbind') ? 0 : 1
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#ShowInfo(world, selected)
+    let lines = []
+    for f in a:selected
+        if filereadable(f)
+            let desc = [getfperm(f), strftime('%c', getftime(f)),  getfsize(f) .' bytes', getftype(f)]
+            call add(lines, fnamemodify(f, ':p'))
+            call add(lines, '  '. join(desc, '; '))
+        endif
+    endfor
+    let a:world.temp_lines = lines
+    let a:world.state = 'printlines'
+    return a:world
+endf
+
+
+
+" Buffer related {{{1
+
+function! tlib#agent#PreviewLine(world, selected) "{{{3
+    let l = a:selected[0]
+    let ww = winnr()
+    exec a:world.win_wnr .'wincmd w'
+    call tlib#buffer#ViewLine(l, 1)
+    exec ww .'wincmd w'
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+" If not called from the scratch, we assume/guess that we don't have to 
+" suspend the input-evaluation loop.
+function! tlib#agent#GotoLine(world, selected) "{{{3
+    if !empty(a:selected)
+
+        " let l = a:selected[0]
+        " " TLogVAR l
+        " let back = a:world.SwitchWindow('win')
+        " " TLogVAR back
+        " " if a:world.win_wnr != winnr()
+        " "     let world = tlib#agent#Suspend(a:world, a:selected)
+        " "     exec a:world.win_wnr .'wincmd w'
+        " " endif
+        " call tlib#buffer#ViewLine(l)
+        " exec back
+        " let a:world.state = 'display'
+
+        let l = a:selected[0]
+        if a:world.win_wnr != winnr()
+            let world = tlib#agent#Suspend(a:world, a:selected)
+            exec a:world.win_wnr .'wincmd w'
+        endif
+        call tlib#buffer#ViewLine(l, 1)
+        
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#DoAtLine(world, selected) "{{{3
+    if !empty(a:selected)
+        let cmd = input('Command: ', '', 'command')
+        if !empty(cmd)
+            call a:world.SwitchWindow('win')
+            " let pos = getpos('.')
+            let view = winsaveview()
+            for l in a:selected
+                call tlib#buffer#ViewLine(l, '')
+                exec cmd
+            endfor
+            " call setpos('.', pos)
+            call winrestview(view)
+        endif
+    endif
+    call a:world.ResetSelected()
+    let a:world.state = 'exit'
+    return a:world
+endf
+
+
+function! tlib#agent#Wildcard(world, selected) "{{{3
+    if !empty(a:world.filter[0])
+        let rx_type = a:world.matcher.FilterRxPrefix()
+        let flt0 = a:world.CleanFilter(a:world.filter[0][0])
+        if rx_type == '\V'
+            let flt0 .= '\.\{-}'
+        else
+            let flt0 .= '.\{-}'
+        endif
+        call a:world.SetFrontFilter(flt0)
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Null(world, selected) "{{{3
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#ExecAgentByName(world, selected) "{{{3
+    let s:agent_names_world = a:world
+    let agent_names = {'Help': 'tlib#agent#Help'}
+    for def in values(a:world.key_map[a:world.key_mode])
+        if has_key(def, 'help') && !empty(def.help) && has_key(def, 'agent') && !empty(def.agent)
+            let agent_names[def.help] = def.agent
+        endif
+    endfor
+    let s:agent_names = sort(keys(agent_names))
+    let command = input('Command: ', '', 'customlist,tlib#agent#CompleteAgentNames')
+    " TLogVAR command
+    if !has_key(agent_names, command)
+        " TLogVAR command
+        silent! let matches = filter(keys(agent_names), 'v:val =~ command')
+        " TLogVAR matches
+        if len(matches) == 1
+            let command = matches[0]
+        endif
+    endif
+    if has_key(agent_names, command)
+        let agent = agent_names[command]
+        return call(agent, [a:world, a:selected])
+    else
+        if !empty(command)
+            echohl WarningMsg
+            echom "Unknown command:" command
+            echohl NONE
+            sleep 1
+        endif
+        let a:world.state = 'display'
+        return a:world
+    endif
+endf
+
+
+function! tlib#agent#CompleteAgentNames(ArgLead, CmdLine, CursorPos)
+    let arglead = tolower(a:Arglead)
+    return filter(copy(s:agent_names), 'stridx(tolower(v:val), arglead) != -1')
+endf
+
+
+function! tlib#agent#Complete(world, selected) abort "{{{3
+    let rxprefix = a:world.matcher.FilterRxPrefix()
+    let flt = a:world.filter[0][0]
+    " TLogVAR flt
+    let fltrx = rxprefix . flt . '\m[^[:space:][:cntrl:][:punct:]<>*+?&~{}()\[\]\\/]\+'
+    let fltrx0 = '\m^' . fltrx
+    " TLogVAR fltrx, fltrx0
+    let words = {}
+    for item in a:world.list
+        let parts = split(item, '\ze'. fltrx)
+        " TLogVAR item, parts
+        for part in parts
+            let word = matchstr(part, fltrx0)
+            " TLogVAR part, word
+            if !empty(word)
+                let words[word] = 1
+            endif
+        endfor
+    endfor
+    " TLogVAR keys(words)
+    let completions = keys(words)
+    " let completions = filter(keys(words), 'matchstr(v:val, fltrx0)')
+    let completions = sort(completions, 's:SortCompletions')
+    let completions = tlib#list#Uniq(completions)
+    " TLogVAR 0, completions
+    while len(completions) > 1
+        let nchar = strwidth(completions[0]) - 1
+        let completions = map(completions, 'strpart(v:val, 0, nchar)')
+        " TLogVAR 'reduce', completions
+        let completions = tlib#list#Uniq(completions)
+        " TLogVAR 'unique', len(completions), completions
+    endwh
+    " TLogVAR 9, completions
+    if empty(completions)
+        let a:world.state = 'redisplay update'
+    else
+        let a:world.filter[0][0] = completions[0]
+        let a:world.state = 'display update'
+    endif
+    return a:world
+endf
+
+
+function! s:SortCompletions(a, b) abort "{{{3
+    let i1 = strwidth(a:a)
+    let i2 = strwidth(a:b)
+    return i2 - i1
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/arg.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/arg.vim
new file mode 100755
index 0000000..f7d479e
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/arg.vim
@@ -0,0 +1,338 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2016-06-06.
+" @Revision:    267
+
+
+" :def: function! tlib#arg#Get(n, var, ?default="", ?test='')
+" Set a positional argument from a variable argument list.
+" See tlib#string#RemoveBackslashes() for an example.
+function! tlib#arg#Get(n, var, ...) "{{{3
+    let default = a:0 >= 1 ? a:1 : ''
+    let atest   = a:0 >= 2 ? a:2 : ''
+    " TLogVAR default, atest
+    if !empty(atest)
+        let atest = ' && (a:'. a:n .' '. atest .')'
+    endif
+    let test = printf('a:0 >= %d', a:n) . atest
+    return printf('let %s = %s ? a:%d : %s', a:var, test, a:n, string(default))
+endf
+
+
+" :def: function! tlib#arg#Let(list, ?default='')
+" Set a positional arguments from a variable argument list.
+" See tlib#input#List() for an example.
+function! tlib#arg#Let(list, ...) "{{{3
+    let default = a:0 >= 1 ? a:1 : ''
+    let list = map(copy(a:list), 'type(v:val) == 3 ? v:val : [v:val, default]')
+    let args = map(range(1, len(list)), 'call("tlib#arg#Get", [v:val] + list[v:val - 1])')
+    return join(args, ' | ')
+endf
+
+
+" :def: function! tlib#arg#StringAsKeyArgs(string, ?keys=[], ?evaluate=0, ?sep=':', ?booleans=0)
+function! tlib#arg#StringAsKeyArgs(string, ...) "{{{1
+    TVarArg ['keys', {}], ['evaluate', 0], ['sep', ':'], ['booleans', 0]
+    let keyargs = {}
+    let args = split(a:string, '\\\@<! ')
+    let key_rx = booleans ? '\([-+]\?\w\+\)' : '\(\w\+\)'
+    let arglist = map(args, 'matchlist(v:val, ''^\%('. key_rx . sep .'\(.*\)\|\(.*\)\)$'')')
+    " TLogVAR a:string, args, arglist
+    let pos = -1
+    for matchlist in arglist
+        if !empty(matchlist[3])
+            if booleans && matchlist[3] =~ '^[-+]'
+                let key = substitute(matchlist[3], '^[-+]', '', '')
+                let val = matchstr(matchlist[3], '^[-+]')
+                let keyargs[key] = val ==# '+'
+            else
+                let pos += 1
+                let keyargs[pos] = matchlist[3]
+            endif
+        else
+            let [match, key, val; rest] = matchlist
+            if empty(keys) || has_key(keys, key)
+                let val = substitute(val, '\\\\', '\\', 'g')
+                if evaluate
+                    let val = eval(val)
+                endif
+                let keyargs[key] = val
+            else
+                echom 'Unknown key: '. key .'='. val
+            endif
+        endif
+    endfor
+    if pos >= 0
+        let keyargs['__posargs__'] = range(0, pos)
+    endif
+    return keyargs
+endf
+
+
+function! tlib#arg#StringAsKeyArgsEqual(string) "{{{1
+    return tlib#arg#StringAsKeyArgs(a:string, [], 0, '=', 1)
+endf
+
+
+" :display: tlib#arg#GetOpts(args, ?def={})
+" Convert a list of strings of command-line arguments into a dictonary.
+"
+" The main use case is to pass [<f-args>], i.e. the command-line 
+" arguments of a command as list, from a command definition to this 
+" function.
+"
+" Example:
+" ['-h']
+" => If def contains a 'help' key, invoke |:help| on its value.
+"
+" ['-ab', '--foo', '--bar=BAR', 'bla', bla']
+" => {'a': 1, 'b': 1, 'foo': 1, 'bar': 'BAR', '__rest__': ['bla', 'bla']}
+"
+" ['-ab', '--', '--foo', '--bar=BAR']
+" => {'a': 1, 'b': 1, '__rest__': ['--foo', '--bar=BAR']}
+function! tlib#arg#GetOpts(args, ...) abort "{{{3
+    let throw = a:0 == 0
+    TVarArg ['def', {}]
+    " TLogVAR def
+    let opts = {'__exit__': 0}
+    for [key, vdef] in items(get(def, 'values', {}))
+        if has_key(vdef, 'default')
+            let opts[key] = vdef.default
+        endif
+    endfor
+    let idx = 0
+    for o in a:args
+        let [break, idx] = s:SetOpt(def, opts, idx, o)
+        if break == 1
+            break
+        elseif break == 2
+            if throw
+                throw 'tlib#arg#GetOpts: Show help'
+            else
+                let opts.__exit__ = 5
+            endif
+        endif
+    endfor
+    let opts.__rest__ = a:args[idx : -1]
+    return opts
+endf
+
+
+function! s:GetValueType(def) abort "{{{3
+    return get(a:def, 'type', type(get(a:def, 'default', '')))
+endf
+
+
+function! s:SetOpt(def, opts, idx, opt) abort "{{{3
+    " TLogVAR a:def
+    let idx = a:idx + 1
+    let break = 0
+    let long = get(a:def, 'long', 1)
+    let short = get(a:def, 'short', 1)
+    if (short && a:opt =~# '^-[?h]$') || (long && a:opt ==# '--help')
+        if has_key(a:def, 'help')
+            exec 'help' a:def.help
+        else
+            " TLogVAR a:def
+            let values = get(a:def, 'values', {})
+            let flags = get(a:def, 'flags', {})
+            if empty(values) && empty(flags)
+                echom 'No help'
+            else
+                if !empty(values)
+                    echom 'Options:'
+                    for [key, vdef] in sort(items(values))
+                        let opt = key
+                        let default = get(vdef, 'default', '')
+                        let type = s:GetValueType(vdef)
+                        if default =~ '^-\?\d\+\%(\.\d\+\)$'
+                            if type == -1
+                                let opt .= ' (flag)'
+                            elseif type == 1
+                                let opt .= '=INT'
+                            else
+                                let opt .= '=INT or maybe BOOL'
+                            endif
+                        elseif type(default) == 1
+                            let opt .= '=STRING'
+                        elseif type(default) == 3
+                            let opt .= '=COMMA-LIST'
+                        endif
+                        echom printf('  --%20s (default: %s)', opt, string(default))
+                    endfor
+                endif
+                if !empty(flags)
+                    echom 'Short flags:'
+                    for [sflag, lflag] in sort(items(flags))
+                        echom printf('  -%s -> %s', sflag, lflag)
+                    endfor
+                endif
+            endif
+        endif
+        let break = 2
+    elseif long &&  a:opt =~# '^--\%(no-\)\?debug$'
+        if has_key(a:def, 'trace')
+            let mod = a:opt =~# '--no-' ? '-' : '+'
+            exec 'Tlibtraceset' mod . a:def.trace
+        endif
+    elseif long &&  a:opt =~# '^--no-.\+'
+        let key = matchstr(a:opt, '^--no-\zs.\+$')
+        let a:opts[key] = s:Validate(a:def, key, 0)
+    elseif long &&  a:opt =~# '^--\w\+$'
+        let key = matchstr(a:opt, '^--\zs.\+$')
+        let a:opts[key] = s:Validate(a:def, key, 1)
+    elseif long &&  a:opt =~# '^--\w\+='
+        let ml = matchlist(a:opt, '^--\(\w\+\)=\(.*\)$')
+        if empty(ml)
+            throw 'tlib#arg#GetOpts: Cannot parse: '. a:opt
+        else
+            let values = get(a:def, 'values', {})
+            if has_key(values, ml[1])
+                let vdef = values[ml[1]]
+                let type = s:GetValueType(vdef)
+                if type == -1
+                    let opt_value = !!str2nr(ml[2])
+                elseif type == 0
+                    let opt_value = str2nr(ml[2])
+                elseif type == 1
+                    let opt_value = ml[2]
+                elseif type == 2
+                    let opt_value = function(ml[2])
+                elseif type == 3
+                    let opt_value = tlib#string#SplitCommaList(ml[2])
+                elseif type == 4
+                    throw 'tlib#arg#GetOpts: Unsupported type conversion for '. ml[1]
+                elseif type == 5
+                    let opt_value = str2float(ml[2])
+                endif
+            else
+                let opt_value = ml[2]
+            endif
+            let a:opts[ml[1]] = s:Validate(a:def, ml[1], opt_value)
+            unlet opt_value
+        endif
+    elseif short && a:opt =~# '^-\w='
+        let flagdefs = get(a:def, 'flags', {})
+        let flag = matchstr(a:opt, '^-\zs\w')
+        let rest = matchstr(a:opt, '^-\w\zs.*$')
+        call s:SetFlag(a:def, a:opts, idx, flag, rest, flagdefs)
+    elseif short && a:opt =~# '^-\w\+$'
+        let flagdefs = get(a:def, 'flags', {})
+        for flag in split(substitute(a:opt, '^-', '', ''), '\zs')
+            call s:SetFlag(a:def, a:opts, idx, flag, '', flagdefs)
+        endfor
+    else
+        let break = 1
+        if a:opt !=# '--'
+            let idx -= 1
+        endif
+    endif
+    return [break, idx]
+endf
+
+
+function! s:SetFlag(def, opts, idx, flag, rest, flagdefs) abort "{{{3
+    " TLogVAR a:def
+    if has_key(a:flagdefs, a:flag)
+        call s:SetOpt(a:def, a:opts, a:idx, a:flagdefs[a:flag] . a:rest)
+    else
+        let a:opts[a:flag] = s:Validate(a:def, a:flag, 1)
+    endif
+endf
+
+
+function! s:Validate(def, name, value) abort "{{{3
+    let values = get(a:def, 'values', {})
+    if has_key(values, a:name)
+        let vdef = values[a:name]
+        if has_key(vdef, 'validate')
+            if !call(vdef.validate, [a:value])
+                throw printf('tlib#arg: %s has invalid value: %s', string(a:name), string(a:value))
+            endif
+        endif
+    endif
+    return a:value
+endf
+
+
+":nodoc:
+function! tlib#arg#CComplete(def, ArgLead) abort "{{{3
+    let values = get(a:def, 'values', {})
+    let opt = matchstr(a:ArgLead, '^--\zs\w\+\ze=')
+    if has_key(values, opt)
+        let words = []
+        let vals = values[opt]
+        let complete_customlist = get(vals, 'complete_customlist', '')
+        if !empty(complete_customlist)
+            let words = eval(complete_customlist)
+        " else
+        "     let complete = get(vals, 'complete', '')
+        "     if !empty(complete)
+        "     endif
+        endif
+        if !empty(words)
+            let prefix = matchstr(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*')
+            let lead = substitute(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*', '', '')
+            " TLogVAR a:ArgLead, lead
+            if !empty(lead)
+                let nchar = len(lead)
+                call filter(words, 'strpart(v:val, 0, nchar) ==# lead')
+            endif
+            let words = map(words, 'prefix . v:val')
+            return sort(words)
+        endif
+    endif
+    let cs = {'-h': 1, '--help': 1}
+    for [name, vdef] in items(values)
+        let type = s:GetValueType(vdef)
+        if type >= 0
+            let name .= '='
+        else
+            let cs['--no-'. name] = 1
+        endif
+        let cs['--'. name] = 1
+    endfor
+    for [name, subst] in items(get(a:def, 'flags', {}))
+        let ldef = get(values, substitute(subst, '^--', '', ''), {})
+        let type = s:GetValueType(ldef)
+        if type >= 0
+            let name .= '='
+        endif
+        let cs['-'. name] = 1
+    endfor
+    if has_key(a:def, 'trace')
+        let cs['--debug'] = 1
+    endif
+    let nchar = len(a:ArgLead)
+    if nchar > 0
+        call filter(cs, 'strpart(v:key, 0, nchar) ==# a:ArgLead')
+    endif
+    return sort(keys(cs))
+endf
+
+
+
+""" Command line {{{1
+
+" :def: function! tlib#arg#Ex(arg, ?chars='%#! ')
+" Escape some characters in a string.
+"
+" Use |fnamescape()| if available.
+"
+" EXAMPLES: >
+"   exec 'edit '. tlib#arg#Ex('foo%#bar.txt')
+function! tlib#arg#Ex(arg, ...) "{{{3
+    if exists('*fnameescape') && a:0 == 0
+        return fnameescape(a:arg)
+    else
+        " let chars = '%# \'
+        let chars = '%#! '
+        if a:0 >= 1
+            let chars .= a:1
+        endif
+        return escape(a:arg, chars)
+    endif
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/assert.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/assert.vim
new file mode 100644
index 0000000..5d4dea7
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/assert.vim
@@ -0,0 +1,44 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2015-12-04
+" @Revision:    41
+
+
+" Enable tracing via |:Tlibassert|.
+function! tlib#assert#Enable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ -bang Tlibassert call tlib#assert#Assert(expand('<sfile>'), <q-args>, [<args>])
+endf
+
+
+" Disable tracing via |:Tlibassert|.
+function! tlib#assert#Disable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ -bang Tlibassert :
+endf
+
+
+function! tlib#assert#Assert(caller, check, vals) abort "{{{3
+    for val in a:vals
+        " TLogVAR val
+        if type(val) == 3
+            call tlib#assert#Assert(a:caller, a:check, val)
+        elseif !val
+            throw 'Tlibassert: '. tlib#trace#Backtrace(a:caller) .': '. a:check
+        endif
+    endfor
+endf
+
+
+function! tlib#assert#Map(vals, expr) abort "{{{3
+    return tlib#assert#All(map(a:vals, a:expr))
+endf
+
+
+function! tlib#assert#All(vals) abort "{{{3
+    " TLogVAR a:vals, empty(filter(a:vals, '!v:val'))
+    return empty(filter(a:vals, '!v:val'))
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/autocmdgroup.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/autocmdgroup.vim
new file mode 100755
index 0000000..8439524
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/autocmdgroup.vim
@@ -0,0 +1,14 @@
+" autocmdgroup.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    7
+
+augroup TLib
+    autocmd!
+augroup END
+
+
+function! tlib#autocmdgroup#Init() "{{{3
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/balloon.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/balloon.vim
new file mode 100644
index 0000000..6967523
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/balloon.vim
@@ -0,0 +1,73 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/tlib_vim/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-08-30.
+" @Last Change: 2015-11-23.
+" @Revision:    48
+
+
+function! tlib#balloon#Register(expr) "{{{3
+    if !has('balloon_eval')
+        return
+    endif
+    if !exists('b:tlib_balloons')
+        let b:tlib_balloons = []
+    endif
+    if !&ballooneval
+        setlocal ballooneval
+    endif
+    if &balloonexpr != 'tlib#balloon#Expr()'
+        if !empty(&balloonexpr)
+            call add(b:tlib_balloons, &balloonexpr)
+        endif
+        setlocal ballooneval balloonexpr=tlib#balloon#Expr()
+    endif
+    if index(b:tlib_balloons, a:expr) == -1
+        call add(b:tlib_balloons, a:expr)
+    endif
+endf
+
+
+function! tlib#balloon#Remove(expr) "{{{3
+    if exists('b:tlib_balloons')
+        call filter(b:tlib_balloons, 'v:val != a:expr')
+        if empty(b:tlib_balloons)
+            setlocal ballooneval&
+            setlocal balloonexpr&
+            unlet b:tlib_balloons
+        endif
+    endif
+endf
+
+
+function! tlib#balloon#Expr() "{{{3
+    " TLogVAR exists('b:tlib_balloons')
+    if !exists('b:tlib_balloons')
+        return ''
+    endif
+    let text = map(copy(b:tlib_balloons), 'eval(v:val)')
+    " TLogVAR b:tlib_balloons, text
+    call filter(text, '!empty(v:val)')
+    if has('balloon_multiline')
+        return join(text, "\n----------------------------------\n")
+    else
+        return get(text, 0, '')
+    endif
+endf
+
+
+function! tlib#balloon#Expand(expr) abort "{{{3
+    if v:beval_bufnr != bufnr('%')
+        " TLogVAR v:beval_bufnr, bufnr('%')
+        return ''
+    endif
+    let win = winsaveview()
+    try
+        call setpos('.', [v:beval_bufnr, v:beval_lnum, v:beval_col, 0])
+        return expand(a:expr)
+    finally
+        call winrestview(win)
+    endtry
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/bitwise.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/bitwise.vim
new file mode 100644
index 0000000..54a4258
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/bitwise.vim
@@ -0,0 +1,141 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    124
+
+
+function! tlib#bitwise#Num2Bits(num) "{{{3
+    if type(a:num) <= 1 || type(a:num) == 5
+        let bits = reverse(tlib#number#ConvertBase(a:num, 2, 'list'))
+    elseif type(a:num) == 3
+        let bits = copy(a:num)
+    else
+        throw "tlib#bitwise#Num2Bits: Must be number of list: ". string(a:num)
+    endif
+    return bits
+endf
+
+
+function! tlib#bitwise#Bits2Num(bits, ...) "{{{3
+    let base = a:0 >= 1 ? a:1 : 10
+    " TLogVAR a:bits
+    let num = 0.0
+    for i in range(len(a:bits))
+        if get(a:bits, i, 0)
+            let num += pow(2, i)
+        endif
+    endfor
+    " TLogVAR num
+    if base == 10
+        if type(base) == 5
+            return num
+        else
+            return float2nr(num)
+        endif
+    else
+        return tlib#number#ConvertBase(num, base)
+    endif
+endf
+
+
+function! tlib#bitwise#AND(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    return s:BitwiseComparison(a:num1, a:num2, rtype,
+                \ 'get(bits1, v:val) && get(bits2, v:val)')
+endf
+
+
+function! tlib#bitwise#OR(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    return s:BitwiseComparison(a:num1, a:num2, rtype,
+                \ 'get(bits1, v:val) || get(bits2, v:val)')
+endf
+
+
+function! tlib#bitwise#XOR(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    return s:BitwiseComparison(a:num1, a:num2, rtype,
+                \ 'get(bits1, v:val) ? !get(bits2, v:val) : get(bits2, v:val)')
+endf
+
+
+function! s:BitwiseComparison(num1, num2, rtype, expr) "{{{3
+    let bits1 = tlib#bitwise#Num2Bits(a:num1)
+    let bits2 = tlib#bitwise#Num2Bits(a:num2)
+    let range = range(max([len(bits1), len(bits2)]))
+    let bits = map(range, a:expr)
+    if a:rtype == 'num' || (a:rtype == 'auto' && type(a:num1) <= 1)
+        return tlib#bitwise#Bits2Num(bits)
+    else
+        return bits
+    endif
+endf
+
+
+function! tlib#bitwise#ShiftRight(bits, n) "{{{3
+    let bits = a:bits[a:n : -1]
+    if empty(bits)
+        let bits = [0]
+    endif
+    return bits
+endf
+
+
+function! tlib#bitwise#ShiftLeft(bits, n) "{{{3
+    let bits = repeat([0], a:n) + a:bits
+    return bits
+endf
+
+
+function! tlib#bitwise#Add(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    let bits1 = tlib#bitwise#Num2Bits(a:num1)
+    let bits2 = tlib#bitwise#Num2Bits(a:num2)
+    let range = range(max([len(bits1), len(bits2)]))
+    " TLogVAR bits1, bits2, range
+    let carry = 0
+    let bits  = []
+    for i in range
+        let sum = get(bits1, i) + get(bits2, i) + carry
+        if sum == 3
+            let bit = 1
+            let carry = 1
+        elseif sum == 2
+            let bit = 0
+            let carry = 1
+        elseif sum == 1
+            let bit = 1
+            let carry = 0
+        elseif sum == 0
+            let bit = 0
+            let carry = 0
+        endif
+        call add(bits, bit)
+        " TLogVAR i, bits, bit
+    endfor
+    if carry == 1
+        call add(bits, carry)
+    endif
+    if rtype == 'num' || (rtype == 'auto' && type(a:num1) <= 1)
+        return tlib#bitwise#Bits2Num(bits)
+    else
+        return bits
+    endif
+endf
+
+
+function! tlib#bitwise#Sub(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    let bits1 = tlib#bitwise#Num2Bits(a:num1)
+    let bits2 = tlib#bitwise#Num2Bits(a:num2)
+    let range = range(max([len(bits1), len(bits2)]))
+    let bits2 = map(range, '!get(bits2, v:val)')
+    let bits2 = tlib#bitwise#Add(bits2, [1], 'bits')
+    let bits3 = tlib#bitwise#Add(bits1, bits2, 'bits')
+    let bits = bits3[0 : -2]
+    if rtype == 'num' || (rtype == 'auto' && type(a:num1) <= 1)
+        return tlib#bitwise#Bits2Num(bits)
+    else
+        return bits
+    endif
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/buffer.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/buffer.vim
new file mode 100644
index 0000000..aa75545
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/buffer.vim
@@ -0,0 +1,401 @@
+" buffer.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2015-11-06.
+" @Revision:    7.1.352
+
+
+" Where to display the line when using |tlib#buffer#ViewLine|.
+" For possible values for position see |scroll-cursor|.
+TLet g:tlib_viewline_position = 'zz'
+
+
+let s:bmru = []
+
+
+function! tlib#buffer#EnableMRU() "{{{3
+    call tlib#autocmdgroup#Init()
+    autocmd TLib BufEnter * call s:BMRU_Push(bufnr('%'))
+endf
+
+
+function! tlib#buffer#DisableMRU() "{{{3
+    call tlib#autocmdgroup#Init()
+    autocmd! TLib BufEnter
+endf
+
+
+function! s:BMRU_Push(bnr) "{{{3
+    let i = index(s:bmru, a:bnr)
+    if i >= 0
+        call remove(s:bmru, i)
+    endif
+    call insert(s:bmru, a:bnr)
+endf
+
+
+function! s:CompareBuffernameByBasename(a, b) "{{{3
+    let rx = '"\zs.\{-}\ze" \+\S\+ \+\d\+$'
+    let an = matchstr(a:a, rx)
+    let an = fnamemodify(an, ':t')
+    let bn = matchstr(a:b, rx)
+    let bn = fnamemodify(bn, ':t')
+    let rv = an == bn ? 0 : an > bn ? 1 : -1
+    return rv
+endf
+
+
+function! s:CompareBufferNrByMRU(a, b) "{{{3
+    let an = matchstr(a:a, '\s*\zs\d\+\ze')
+    let bn = matchstr(a:b, '\s*\zs\d\+\ze')
+    let ai = index(s:bmru, 0 + an)
+    if ai == -1
+        return 1
+    else
+        let bi = index(s:bmru, 0 + bn)
+        if bi == -1
+            return -1
+        else
+            return ai == bi ? 0 : ai > bi ? 1 : -1
+        endif
+    endif
+endf
+
+
+" Set the buffer to buffer and return a command as string that can be 
+" evaluated by |:execute| in order to restore the original view.
+function! tlib#buffer#Set(buffer) "{{{3
+    let lazyredraw = &lazyredraw
+    set lazyredraw
+    try
+        let cb = bufnr('%')
+        let sn = bufnr(a:buffer)
+        if sn != cb
+            let ws = bufwinnr(sn)
+            if ws != -1
+                let wb = bufwinnr('%')
+                exec ws.'wincmd w'
+                return wb.'wincmd w'
+            else
+                silent exec 'sbuffer! '. sn
+                return 'wincmd c'
+            endif
+        else
+            return ''
+        endif
+    finally
+        let &lazyredraw = lazyredraw
+    endtry
+endf
+
+
+" :def: function! tlib#buffer#Eval(buffer, code)
+" Evaluate CODE in BUFFER.
+"
+" EXAMPLES: >
+"   call tlib#buffer#Eval('foo.txt', 'echo b:bar')
+function! tlib#buffer#Eval(buffer, code) "{{{3
+    " let cb = bufnr('%')
+    " let wb = bufwinnr('%')
+    " " TLogVAR cb
+    " let sn = bufnr(a:buffer)
+    " let sb = sn != cb
+    let lazyredraw = &lazyredraw
+    set lazyredraw
+    let restore = tlib#buffer#Set(a:buffer)
+    try
+        exec a:code
+        " if sb
+        "     let ws = bufwinnr(sn)
+        "     if ws != -1
+        "         try
+        "             exec ws.'wincmd w'
+        "             exec a:code
+        "         finally
+        "             exec wb.'wincmd w'
+        "         endtry
+        "     else
+        "         try
+        "             silent exec 'sbuffer! '. sn
+        "             exec a:code
+        "         finally
+        "             wincmd c
+        "         endtry
+        "     endif
+        " else
+        "     exec a:code
+        " endif
+    finally
+        exec restore
+        let &lazyredraw = lazyredraw
+    endtry
+endf
+
+
+" :def: function! tlib#buffer#GetList(?show_hidden=0, ?show_number=0, " ?order='bufnr')
+" Possible values for the "order" argument:
+"   bufnr    :: Default behaviour
+"   mru      :: Sort buffers according to most recent use
+"   basename :: Sort by the file's basename (last component)
+"
+" NOTE: MRU order works on second invocation only. If you want to always 
+" use MRU order, call tlib#buffer#EnableMRU() in your ~/.vimrc file.
+function! tlib#buffer#GetList(...)
+    TVarArg ['show_hidden', 0], ['show_number', 0], ['order', '']
+    " TLogVAR show_hidden, show_number, order
+    let ls_bang = show_hidden ? '!' : ''
+    redir => bfs
+    exec 'silent ls'. ls_bang
+    redir END
+    let buffer_list = split(bfs, '\n')
+    if order == 'mru'
+        if empty(s:bmru)
+            call tlib#buffer#EnableMRU()
+            echom 'tlib: Installed Buffer MRU logger; disable with: call tlib#buffer#DisableMRU()'
+        else
+            call sort(buffer_list, function('s:CompareBufferNrByMRU'))
+        endif
+    elseif order == 'basename'
+        call sort(buffer_list, function('s:CompareBuffernameByBasename'))
+    endif
+    let buffer_nr = map(copy(buffer_list), 'str2nr(matchstr(v:val, ''\s*\zs\d\+\ze''))')
+    " TLogVAR buffer_list, buffer_nr
+    if show_number
+        call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+.\{-}\ze\s\+\S\+ \d\+\s*$'')')
+    else
+        call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+\zs.\{-}\ze\s\+\S\+ \d\+\s*$'')')
+    endif
+    " TLogVAR buffer_list
+    " call map(buffer_list, 'matchstr(v:val, ''^.\{-}\ze\s\+line \d\+\s*$'')')
+    " TLogVAR buffer_list
+    call map(buffer_list, 'matchstr(v:val, ''^[^"]\+''). printf("%-20s   %s", fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":t"), fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":h"))')
+    " TLogVAR buffer_list
+    return [buffer_nr, buffer_list]
+endf
+
+
+" :def: function! tlib#buffer#ViewLine(line, ?position='z')
+" line is either a number or a string that begins with a number.
+" For possible values for position see |scroll-cursor|.
+" See also |g:tlib_viewline_position|.
+function! tlib#buffer#ViewLine(line, ...) "{{{3
+    if a:line
+        TVarArg 'pos'
+        let ln = matchstr(a:line, '^\d\+')
+        let lt = matchstr(a:line, '^\d\+: \zs.*')
+        " TLogVAR pos, ln, lt
+        exec ln
+        if empty(pos)
+            let pos = tlib#var#Get('tlib_viewline_position', 'wbg')
+        endif
+        " TLogVAR pos
+        if !empty(pos)
+            exec 'norm! '. pos
+        endif
+        call tlib#buffer#HighlightLine(ln)
+        " let @/ = '\%'. ln .'l.*'
+    endif
+endf
+
+
+function! s:UndoHighlightLine() "{{{3
+    2match none
+    autocmd! TLib CursorMoved,CursorMovedI <buffer>
+    autocmd! TLib CursorHold,CursorHoldI <buffer>
+    autocmd! TLib InsertEnter,InsertChange,InsertLeave <buffer>
+    autocmd! TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer>
+endf
+
+
+function! tlib#buffer#HighlightLine(...) "{{{3
+    TVarArg ['line', line('.')]
+    " exec '2match MatchParen /^\%'. a:line .'l.*/'
+    exec '2match Search /^\%'. line .'l.*/'
+    call tlib#autocmdgroup#Init()
+    exec 'autocmd TLib CursorMoved,CursorMovedI <buffer> if line(".") != '. line .' | call s:UndoHighlightLine() | endif'
+    autocmd TLib CursorHold,CursorHoldI <buffer> call s:UndoHighlightLine()
+    autocmd TLib InsertEnter <buffer> call s:UndoHighlightLine()
+    " autocmd TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer> call s:UndoHighlightLine()
+endf
+
+
+" Delete the lines in the current buffer. Wrapper for |:delete|.
+function! tlib#buffer#DeleteRange(line1, line2) "{{{3
+    let r = @t
+    try
+        exec a:line1.','.a:line2.'delete t'
+    finally
+        let @t = r
+    endtry
+endf
+
+
+" Replace a range of lines.
+function! tlib#buffer#ReplaceRange(line1, line2, lines)
+    call tlib#buffer#DeleteRange(a:line1, a:line2)
+    call append(a:line1 - 1, a:lines)
+endf
+
+
+" Initialize some scratch area at the bottom of the current buffer.
+function! tlib#buffer#ScratchStart() "{{{3
+    norm! Go
+    let b:tlib_inbuffer_scratch = line('$')
+    return b:tlib_inbuffer_scratch
+endf
+
+
+" Remove the in-buffer scratch area.
+function! tlib#buffer#ScratchEnd() "{{{3
+    if !exists('b:tlib_inbuffer_scratch')
+        echoerr 'tlib: In-buffer scratch not initalized'
+    endif
+    call tlib#buffer#DeleteRange(b:tlib_inbuffer_scratch, line('$'))
+    unlet b:tlib_inbuffer_scratch
+endf
+
+
+" Run exec on all buffers via bufdo and return to the original buffer.
+function! tlib#buffer#BufDo(exec) "{{{3
+    let bn = bufnr('%')
+    exec 'bufdo '. a:exec
+    exec 'buffer! '. bn
+endf
+
+
+" :def: function! tlib#buffer#InsertText(text, keyargs)
+" Keyargs:
+"   'shift': 0|N
+"   'col': col('.')|N
+"   'lineno': line('.')|N
+"   'indent': 0|1
+"   'pos': 'e'|'s' ... Where to locate the cursor (somewhat like s and e in {offset})
+" Insert text (a string) in the buffer.
+function! tlib#buffer#InsertText(text, ...) "{{{3
+    TVarArg ['keyargs', {}]
+    " TLogVAR a:text, keyargs
+    let keyargs = extend({
+                \ 'shift': 0, 'col': col('.'), 'lineno': line('.'), 'pos': 'e', 'indent': 0
+                \ }, keyargs)
+    " TLogVAR keyargs
+    let grow = 0
+    let post_del_last_line = line('$') == 1
+    let line = getline(keyargs.lineno)
+    if keyargs.col + keyargs.shift > 0
+        let pre  = line[0 : (keyargs.col - 1 + keyargs.shift)]
+        let post = line[(keyargs.col + keyargs.shift): -1]
+    else
+        let pre  = ''
+        let post = line
+    endif
+    " TLogVAR keyargs.lineno, line, pre, post
+    let text0 = pre . a:text . post
+    let text  = split(text0, '\n', 1)
+    " TLogVAR text
+    let icol = len(pre)
+    " exec 'norm! '. keyargs.lineno .'G'
+    call cursor(keyargs.lineno, keyargs.col)
+    if keyargs.indent && keyargs.col > 1
+		if &fo =~# '[or]'
+            " FIXME: Is the simple version sufficient?
+            " VERSION 1
+			" " This doesn't work because it's not guaranteed that the 
+			" " cursor is set.
+			" let cline = getline('.')
+			" norm! a
+			" "norm! o
+			" " TAssertExec redraw | sleep 3
+			" let idt = strpart(getline('.'), 0, keyargs.col('.') + keyargs.shift)
+			" " TLogVAR idt
+			" let idtl = len(idt)
+			" -1,.delete
+			" " TAssertExec redraw | sleep 3
+			" call append(keyargs.lineno - 1, cline)
+			" call cursor(keyargs.lineno, keyargs.col)
+			" " TAssertExec redraw | sleep 3
+			" if idtl == 0 && icol != 0
+			" 	let idt = matchstr(pre, '^\s\+')
+			" 	let idtl = len(idt)
+			" endif
+            " VERSION 2
+            let idt = matchstr(pre, '^\s\+')
+            let idtl = len(idt)
+		else
+			let [m_0, idt, iline; rest] = matchlist(pre, '^\(\s*\)\(.*\)$')
+			let idtl = len(idt)
+		endif
+		if idtl < icol
+			let idt .= repeat(' ', icol - idtl)
+		endif
+        " TLogVAR idt
+        let idtl1 = len(idt)
+        for i in range(1, len(text) - 1)
+            let text[i] = idt . text[i]
+            let grow += idtl1
+        endfor
+    endif
+    " TLogVAR text
+    " exec 'norm! '. keyargs.lineno .'Gdd'
+    call tlib#normal#WithRegister('"tdd', 't')
+    call append(keyargs.lineno - 1, text)
+    if post_del_last_line
+        call tlib#buffer#KeepCursorPosition('$delete')
+    endif
+    let tlen = len(text)
+    let posshift = matchstr(keyargs.pos, '\d\+')
+    " TLogVAR keyargs.pos
+    if keyargs.pos =~ '^e'
+        exec keyargs.lineno + tlen - 1
+        exec 'norm! 0'. (len(text[-1]) - len(post) + posshift - 1) .'l'
+    elseif keyargs.pos =~ '^s'
+        " TLogVAR keyargs.lineno, pre, posshift
+        exec keyargs.lineno
+        exec 'norm! '. len(pre) .'|'
+        if !empty(posshift)
+            exec 'norm! '. posshift .'h'
+        endif
+    endif
+    " TLogDBG getline(keyargs.lineno)
+    " TLogDBG string(getline(1, '$'))
+    return grow
+endf
+
+
+function! tlib#buffer#InsertText0(text, ...) "{{{3
+    TVarArg ['keyargs', {}]
+    let mode = get(keyargs, 'mode', 'i')
+    " TLogVAR mode
+    if !has_key(keyargs, 'shift')
+        let col = col('.')
+        " if mode =~ 'i'
+        "     let col += 1
+        " endif
+        let keyargs.shift = col >= col('$') ? 0 : -1
+        " let keyargs.shift = col('.') >= col('$') ? 0 : -1
+        " TLogVAR col
+        " TLogDBG col('.') .'-'. col('$') .': '. string(getline('.'))
+    endif
+    " TLogVAR keyargs.shift
+    return tlib#buffer#InsertText(a:text, keyargs)
+endf
+
+
+function! tlib#buffer#CurrentByte() "{{{3
+    return line2byte(line('.')) + col('.')
+endf
+
+
+" Evaluate cmd while maintaining the cursor position and jump registers.
+function! tlib#buffer#KeepCursorPosition(cmd) "{{{3
+    " let pos = getpos('.')
+    let view = winsaveview()
+    try
+        keepjumps exec a:cmd
+    finally
+        " call setpos('.', pos)
+        call winrestview(view)
+    endtry
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/cache.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/cache.vim
new file mode 100755
index 0000000..0f59f34
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/cache.vim
@@ -0,0 +1,360 @@
+" cache.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2015-11-26.
+" @Revision:    35.1.243
+
+
+" The cache directory. If empty, use |tlib#dir#MyRuntime|.'/cache'.
+" You might want to delete old files from this directory from time to 
+" time with a command like: >
+"   find ~/vimfiles/cache/ -atime +31 -type f -print -delete
+TLet g:tlib_cache = ''
+
+" |tlib#cache#Purge()|: Remove cache files older than N days.
+TLet g:tlib#cache#purge_days = 31
+
+" Purge the cache every N days. Disable automatic purging by setting 
+" this value to a negative value.
+TLet g:tlib#cache#purge_every_days = 31
+
+" The encoding used for the purge-cache script.
+" Default: 'enc'
+TLet g:tlib#cache#script_encoding = &enc
+
+" Whether to run the directory removal script:
+"    0 ... No
+"    1 ... Query user
+"    2 ... Yes
+TLet g:tlib#cache#run_script = 1
+
+" Verbosity level:
+"     0 ... Be quiet
+"     1 ... Display informative message
+"     2 ... Display detailed messages
+TLet g:tlib#cache#verbosity = 1
+
+" A list of regexps that are matched against partial filenames of the 
+" cached files. If a regexp matches, the file won't be removed by 
+" |tlib#cache#Purge()|.
+TLet g:tlib#cache#dont_purge = ['[\/]\.last_purge$']
+
+" If the cache filename is longer than N characters, use 
+" |pathshorten()|.
+TLet g:tlib#cache#max_filename = 200
+
+let s:cache = {}
+
+
+" :display: tlib#cache#Dir(?mode = 'bg')
+" The default cache directory.
+function! tlib#cache#Dir(...) "{{{3
+    TVarArg ['mode', 'bg']
+    let dir = tlib#var#Get('tlib_cache', mode)
+    if empty(dir)
+        let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'cache'])
+    endif
+    return dir
+endf
+
+
+" :def: function! tlib#cache#Filename(type, ?file=%, ?mkdir=0, ?dir='')
+function! tlib#cache#Filename(type, ...) "{{{3
+    " TLogDBG 'bufname='. bufname('.')
+    let dir0 = a:0 >= 3 && !empty(a:3) ? a:3 : tlib#cache#Dir()
+    let dir = dir0
+    if a:0 >= 1 && !empty(a:1)
+        let file  = a:1
+    else
+        if empty(expand('%:t'))
+            return ''
+        endif
+        let file  = expand('%:p')
+        let file  = tlib#file#Relative(file, tlib#file#Join([dir, '..']))
+    endif
+    " TLogVAR file, dir
+    let mkdir = a:0 >= 2 ? a:2 : 0
+    let file  = substitute(file, '\.\.\|[:&<>]\|//\+\|\\\\\+', '_', 'g')
+    let dirs  = [dir, a:type]
+    let dirf  = fnamemodify(file, ':h')
+    if dirf != '.'
+        call add(dirs, dirf)
+    endif
+    let dir   = tlib#file#Join(dirs)
+    " TLogVAR dir
+    let dir   = tlib#dir#PlainName(dir)
+    " TLogVAR dir
+    let file  = fnamemodify(file, ':t')
+    " TLogVAR file, dir, mkdir
+    let cache_file = tlib#file#Join([dir, file])
+    if len(cache_file) > g:tlib#cache#max_filename
+        if v:version >= 704
+            let shortfilename = pathshorten(file) .'_'. sha256(file)
+        else
+            let shortfilename = pathshorten(file) .'_'. tlib#hash#Adler32(file)
+        endif
+        let cache_file = tlib#cache#Filename(a:type, shortfilename, mkdir, dir0)
+    else
+        if mkdir && !isdirectory(dir)
+            try
+                call mkdir(dir, 'p')
+            catch /^Vim\%((\a\+)\)\=:E739:/
+                if filereadable(dir) && !isdirectory(dir)
+                    echoerr 'TLib: Cannot create directory for cache file because a file with the same name exists (please delete it):' dir
+                    " call delete(dir)
+                    " call mkdir(dir, 'p')
+                endif
+            endtry
+        endif
+    endif
+    " TLogVAR cache_file
+    return cache_file
+endf
+
+
+let s:timestamps = {}
+
+
+function! s:SetTimestamp(cfile, type) "{{{3
+    if !has_key(s:timestamps, a:cfile)
+        let s:timestamps[a:cfile] = {}
+    endif
+    let s:timestamps[a:cfile].atime = getftime(a:cfile)
+    let s:timestamps[a:cfile][a:type] = s:timestamps[a:cfile].atime
+endf
+
+
+function! tlib#cache#Save(cfile, dictionary, ...) "{{{3
+    TVarArg ['options', {}]
+    let in_memory = get(options, 'in_memory', 0)
+    if in_memory
+        " TLogVAR in_memory, a:cfile, localtime()
+        let s:cache[a:cfile] = {'mtime': localtime(), 'data': a:dictionary}
+    elseif !empty(a:cfile)
+        " TLogVAR a:dictionary
+        call writefile([string(a:dictionary)], a:cfile, 'b')
+        call s:SetTimestamp(a:cfile, 'write')
+    endif
+endf
+
+
+function! tlib#cache#MTime(cfile) "{{{3
+    let mtime = {'mtime': getftime(a:cfile)}
+    let mtime = extend(mtime, get(s:timestamps, a:cfile, {}))
+    return mtime
+endf
+
+
+function! tlib#cache#Get(cfile, ...) "{{{3
+    TVarArg ['default', {}], ['options', {}]
+    let in_memory = get(options, 'in_memory', 0)
+    if in_memory
+        " TLogVAR in_memory, a:cfile
+        return get(get(s:cache, a:cfile, {}), 'data', default)
+    else
+        call tlib#cache#MaybePurge()
+        if !empty(a:cfile) && filereadable(a:cfile)
+            let val = readfile(a:cfile, 'b')
+            call s:SetTimestamp(a:cfile, 'read')
+            return eval(join(val, "\n"))
+        else
+            return default
+        endif
+    endif
+endf
+
+
+" :display: tlib#cache#Value(cfile, generator, ftime, ?generator_args=[], ?options={})
+" Get a cached value from cfile. If it is outdated (compared to ftime) 
+" or does not exist, create it calling a generator function.
+function! tlib#cache#Value(cfile, generator, ftime, ...) "{{{3
+    TVarArg ['args', []], ['options', {}]
+    let in_memory = get(options, 'in_memory', 0)
+    if in_memory
+        let not_found = !has_key(s:cache, a:cfile)
+        let cftime = not_found ? -1 : s:cache[a:cfile].mtime
+    else
+        let cftime = getftime(a:cfile)
+    endif
+    " TLogVAR in_memory, cftime
+    if cftime == -1 || (a:ftime != 0 && cftime < a:ftime)
+        " TLogVAR a:generator, args
+        let val = call(a:generator, args)
+        " TLogVAR val
+        let cval = {'val': val}
+        " TLogVAR cval
+        call tlib#cache#Save(a:cfile, cval, options)
+        return val
+    else
+        let val = tlib#cache#Get(a:cfile, {}, options)
+        if !has_key(val, 'val')
+            throw 'tlib#cache#Value: Internal error: '. a:cfile
+        else
+            return val.val
+        endif
+    endif
+endf
+
+
+" Call |tlib#cache#Purge()| if the last purge was done before 
+" |g:tlib#cache#purge_every_days|.
+function! tlib#cache#MaybePurge() "{{{3
+    if g:tlib#cache#purge_every_days < 0
+        return
+    endif
+    let dir = tlib#cache#Dir('g')
+    let last_purge = tlib#file#Join([dir, '.last_purge'])
+    let last_purge_exists = filereadable(last_purge)
+    if last_purge_exists
+        let threshold = localtime() - g:tlib#cache#purge_every_days * g:tlib#date#dayshift
+        let should_purge = getftime(last_purge) < threshold
+    else
+        let should_purge = 0 " should ignore empty dirs, like the tmru one: !empty(glob(tlib#file#Join([dir, '**'])))
+    endif
+    if should_purge
+        if last_purge_exists
+            let yn = 'y'
+        else
+            let txt = "TLib: The cache directory '". dir ."' should be purged of old files.\nDelete files older than ". g:tlib#cache#purge_days ." days now?"
+            let yn = tlib#input#Dialog(txt, ['yes', 'no'], 'no')
+        endif
+        if yn =~ '^y\%[es]$'
+            call tlib#cache#Purge()
+        else
+            let g:tlib#cache#purge_every_days = -1
+            if !last_purge_exists
+                call s:PurgeTimestamp(dir)
+            endif
+            echohl WarningMsg
+            echom "TLib: Please run :call tlib#cache#Purge() to clean up ". dir
+            echohl NONE
+        endif
+    elseif !last_purge_exists
+        call s:PurgeTimestamp(dir)
+    endif
+endf
+
+
+" Delete old files.
+function! tlib#cache#Purge() "{{{3
+    let threshold = localtime() - g:tlib#cache#purge_days * g:tlib#date#dayshift
+    let dir = tlib#cache#Dir('g')
+    if g:tlib#cache#verbosity >= 1
+        echohl WarningMsg
+        echom "TLib: Delete files older than ". g:tlib#cache#purge_days ." days from ". dir
+        echohl NONE
+    endif
+    let files = tlib#cache#ListFilesInCache()
+    let deldir = []
+    let newer = []
+    let msg = []
+    let more = &more
+    set nomore
+    try
+        for file in files
+            if isdirectory(file)
+                if empty(filter(copy(newer), 'strpart(v:val, 0, len(file)) ==# file'))
+                    call add(deldir, file)
+                endif
+            else
+                if getftime(file) < threshold
+                    if delete(file)
+                        call add(msg, "TLib: Could not delete cache file: ". file)
+                    elseif g:tlib#cache#verbosity >= 2
+                        call add(msg, "TLib: Delete cache file: ". file)
+                    endif
+                else
+                    call add(newer, file)
+                endif
+            endif
+        endfor
+    finally
+        let &more = more
+    endtry
+    if !empty(msg) && g:tlib#cache#verbosity >= 1
+        echo join(msg, "\n")
+    endif
+    if !empty(deldir)
+        if &shell =~ 'sh\(\.exe\)\?$'
+            let scriptfile = 'deldir.sh'
+            let rmdir = 'rm -rf %s'
+        else
+            let scriptfile = 'deldir.bat'
+            let rmdir = 'rmdir /S /Q %s'
+        endif
+        let enc = g:tlib#cache#script_encoding
+        if has('multi_byte') && enc != &enc
+            call map(deldir, 'iconv(v:val, &enc, enc)')
+        endif
+        let scriptfile = tlib#file#Join([dir, scriptfile])
+        if filereadable(scriptfile)
+            let script = readfile(scriptfile)
+        else
+            let script = []
+        endif
+        let script += map(copy(deldir), 'printf(rmdir, shellescape(v:val, 1))')
+        let script = tlib#list#Uniq(script)
+        call writefile(script, scriptfile)
+        call inputsave()
+        if g:tlib#cache#run_script == 0
+            if g:tlib#cache#verbosity >= 1
+                echohl WarningMsg
+                if g:tlib#cache#verbosity >= 2
+                    echom "TLib: Purged cache. Need to run script to delete directories"
+                endif
+                echom "TLib: Please review and execute: ". scriptfile
+                echohl NONE
+            endif
+        else
+            try
+                let yn = g:tlib#cache#run_script == 2 ? 'y' : tlib#input#Dialog("TLib: About to delete directories by means of a shell script.\nDirectory removal script: ". scriptfile ."\nRun script to delete directories now?", ['yes', 'no', 'edit'], 'no')
+                if yn =~ '^y\%[es]$'
+                    exec 'silent cd '. fnameescape(dir)
+                    exec '! ' &shell shellescape(scriptfile, 1)
+                    exec 'silent cd -'
+                    call delete(scriptfile)
+                elseif yn =~ '^e\%[dit]$'
+                    exec 'edit '. fnameescape(scriptfile)
+                endif
+            finally
+                call inputrestore()
+            endtry
+        endif
+    endif
+    call s:PurgeTimestamp(dir)
+endf
+
+
+function! s:PurgeTimestamp(dir) "{{{3
+    let last_purge = tlib#file#Join([a:dir, '.last_purge'])
+    " TLogVAR last_purge
+    call writefile([" "], last_purge)
+endf
+
+function! tlib#cache#ListFilesInCache(...) "{{{3
+    let dir = a:0 >= 1 ? a:1 : tlib#cache#Dir('g')
+    if v:version > 702 || (v:version == 702 && has('patch51'))
+        let filess = glob(tlib#file#Join([dir, '**']), 1)
+    else
+        let filess = glob(tlib#file#Join([dir, '**']))
+    endif
+    let files = reverse(split(filess, '\n'))
+    let pos0 = len(tlib#dir#CanonicName(dir))
+    call filter(files, 's:ShouldPurge(strpart(v:val, pos0))')
+    return files
+endf
+
+
+function! s:ShouldPurge(partial_filename) "{{{3
+    " TLogVAR a:partial_filename
+    for rx in g:tlib#cache#dont_purge
+        if a:partial_filename =~ rx
+            " TLogVAR a:partial_filename, rx
+            return 0
+        endif
+    endfor
+    return 1
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/char.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/char.vim
new file mode 100755
index 0000000..d3d2cb6
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/char.vim
@@ -0,0 +1,59 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    38
+
+
+" :def: function! tlib#char#Get(?timeout=0)
+" Get a character.
+"
+" EXAMPLES: >
+"   echo tlib#char#Get()
+"   echo tlib#char#Get(5)
+function! tlib#char#Get(...) "{{{3
+    TVarArg ['timeout', 0], ['resolution', 0], ['getmod', 0]
+    let char = -1
+    let mode = 0
+    if timeout == 0 || !has('reltime')
+        let char = getchar()
+    else
+        let char = tlib#char#GetWithTimeout(timeout, resolution)
+    endif
+    if getmod
+        if char != -1
+            let mode = getcharmod()
+        endif
+        return [char, mode]
+    else
+        return char
+    endif
+endf
+
+
+function! tlib#char#IsAvailable() "{{{3
+    let ch = getchar(1)
+    return type(ch) == 0 && ch != 0
+endf
+
+
+function! tlib#char#GetWithTimeout(timeout, ...) "{{{3
+    TVarArg ['resolution', 2]
+    " TLogVAR a:timeout, resolution
+    let start = tlib#time#MSecs()
+    while 1
+        let c = getchar(0)
+        if type(c) != 0 || c != 0
+            return c
+        else
+            let now = tlib#time#MSecs()
+            let diff = tlib#time#DiffMSecs(now, start, resolution)
+            " TLogVAR diff
+            if diff > a:timeout
+                return -1
+            endif
+        endif
+    endwh
+    return -1
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/cmd.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/cmd.vim
new file mode 100755
index 0000000..f65a237
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/cmd.vim
@@ -0,0 +1,117 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    58
+
+
+let g:tlib#cmd#last_output = []
+
+
+function! tlib#cmd#OutputAsList(command) "{{{3
+    " TLogVAR a:command
+    if exists('s:redir_lines')
+        redir END
+        let cache = s:redir_lines
+    endif
+    let s:redir_lines = ''
+    redir =>> s:redir_lines
+    silent! exec a:command
+    redir END
+    let g:tlib#cmd#last_output = split(s:redir_lines, '\n')
+    unlet s:redir_lines
+    if exists('cache')
+        let s:redir_lines = cache
+        redir =>> s:redir_lines
+    endif
+    return g:tlib#cmd#last_output
+endf
+
+
+" See |:TBrowseOutput|.
+function! tlib#cmd#BrowseOutput(command) "{{{3
+    call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#DefaultBrowseOutput", a:command)
+endf
+
+" :def: function! tlib#cmd#BrowseOutputWithCallback(callback, command)
+" Execute COMMAND and present its output in a |tlib#input#List()|;
+" when a line is selected, execute the function named as the CALLBACK
+" and pass in that line as an argument.
+"
+" The CALLBACK function gives you an opportunity to massage the COMMAND output
+" and possibly act on it in a meaningful way. For example, if COMMAND listed
+" all URIs found in the current buffer, CALLBACK could validate and then open
+" the selected URI in the system's default browser.
+"
+" This function is meant to be a tool to help compose the implementations of
+" powerful commands that use |tlib#input#List()| as a common interface. See
+" |TBrowseScriptnames| as an example.
+"
+" EXAMPLES: >
+"   call tlib#cmd#BrowseOutputWithCallback('tlib#cmd#ParseScriptname', 'scriptnames')
+function! tlib#cmd#BrowseOutputWithCallback(callback, command) "{{{3
+    let list = tlib#cmd#OutputAsList(a:command)
+    let cmds = tlib#input#List('m', 'Output of: '. a:command, list)
+    if !empty(cmds)
+        for cmd in cmds
+            let Callback = function(a:callback)
+            call call(Callback, [cmd])
+        endfor
+    endif
+endf
+
+function! tlib#cmd#DefaultBrowseOutput(cmd) "{{{3
+    call feedkeys(':'. a:cmd)
+endf
+
+function! tlib#cmd#ParseScriptname(line) "{{{3
+    " let parsedValue = substitute(a:line, '^.\{-}\/', '/', '')
+    let parsedValue = matchstr(a:line, '^\s*\d\+:\s*\zs.*$')
+    exe 'drop '. fnameescape(parsedValue)
+endf
+
+
+function! tlib#cmd#TBrowseScriptnames() abort "{{{3
+   call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#ParseScriptname", "scriptnames")
+endf
+
+
+" :def: function! tlib#cmd#UseVertical(?rx='')
+" Look at the history whether the command was called with vertical. If 
+" an rx is provided check first if the last entry in the history matches 
+" this rx.
+function! tlib#cmd#UseVertical(...) "{{{3
+    TVarArg ['rx']
+    let h0 = histget(':')
+    let rx0 = '\C\<vert\%[ical]\>\s\+'
+    if !empty(rx)
+        let rx0 .= '.\{-}'.rx
+    endif
+    " TLogVAR h0, rx0
+    return h0 =~ rx0
+endf
+
+
+" Print the time in seconds or milliseconds (if your version of VIM 
+" has |+reltime|) a command takes.
+function! tlib#cmd#Time(cmd) "{{{3
+    if has('reltime')
+        let start = tlib#time#Now()
+        exec a:cmd
+        let end = tlib#time#Now()
+        let diff = string(tlib#time#Diff(end, start)) .'ms'
+    else
+        let start = localtime()
+        exec a:cmd
+        let diff = (localtime() - start) .'s'
+    endif
+    echom 'Time: '. diff .': '. a:cmd
+endf
+
+
+function! tlib#cmd#Capture(cmd) "{{{3
+    redir => s
+    silent exec a:cmd
+    redir END
+    return s
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/comments.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/comments.vim
new file mode 100755
index 0000000..879cde1
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/comments.vim
@@ -0,0 +1,26 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    25
+
+
+" function! tlib#comments#Comments(?rx='')
+function! tlib#comments#Comments(...)
+    TVarArg ['rx', '']
+    let comments = {}
+    let co = &comments
+    while !empty(co)
+        " TLogVAR co
+        let [m_0, m_key, m_val, m_val1, co0, co; rest] = matchlist(co, '^\([^:]*\):\(\(\\.\|[^,]*\)\+\)\(,\(.*\)$\|$\)')
+        " TLogVAR m_key, m_val, co
+        if empty(m_key)
+            let m_key = ':'
+        endif
+        if empty(rx) || m_key =~ rx
+            let comments[m_key] = m_val
+        endif
+    endwh
+    return comments
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/date.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/date.vim
new file mode 100755
index 0000000..8268424
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/date.vim
@@ -0,0 +1,189 @@
+" date.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-03-25.
+" @Last Change: 2016-06-06.
+" @Revision:    41.0.34
+
+
+if !exists('g:tlib#date#ShortDatePrefix') | let g:tlib#date#ShortDatePrefix = '20' | endif "{{{2
+if !exists('g:tlib#date#TimeZoneShift')   | let g:tlib#date#TimeZoneShift = 0      | endif "{{{2
+
+let g:tlib#date#dayshift = 60 * 60 * 24
+" let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\%(\s\+\(\(\d\d\):\(\d\d\)\)\)\?\>'
+let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\>'
+let g:tlib#date#date_format = '%Y-%m-%d'
+
+
+function! tlib#date#IsDate(text) abort "{{{3
+    return a:text =~# '^'. g:tlib#date#date_rx .'$' &&
+                \ !empty(tlib#date#Parse(a:text, 0, 1))
+endf
+
+
+function! tlib#date#Format(...) abort "{{{3
+    let secs1970 = a:0 >= 1 ? a:1 : localtime()
+    return strftime(g:tlib#date#date_format, secs1970)
+endf
+
+
+" :display: tlib#date#DiffInDays(date1, ?date2=localtime(), ?allow_zero=0)
+function! tlib#date#DiffInDays(date, ...)
+    let allow_zero = a:0 >= 2 ? a:2 : 0
+    let s0 = tlib#date#SecondsSince1970(a:date, 0, allow_zero)
+    let s1 = a:0 >= 1 ? tlib#date#SecondsSince1970(a:1, 0, allow_zero) : localtime()
+    let dd = (s0 - s1) / g:tlib#date#dayshift
+    " TLogVAR dd
+    return dd
+endf
+
+
+" :display: tlib#date#Parse(date, ?allow_zero=0, ?silent=0) "{{{3
+function! tlib#date#Parse(date, ...) "{{{3
+    let min = a:0 >= 1 && a:1 ? 0 : 1
+    let silent = a:0 >= 2 ? a:2 : 0
+    " TLogVAR a:date, min
+    let m = matchlist(a:date, '^\(\d\{2}\|\d\{4}\)-\(\d\{1,2}\)-\(\d\{1,2}\)$')
+    if !empty(m)
+        let year = m[1]
+        let month = m[2]
+        let days = m[3]
+    else
+        let m = matchlist(a:date, '^\(\d\+\)/\(\d\{1,2}\)/\(\d\{1,2}\)$')
+        if !empty(m)
+            let year = m[1]
+            let month = m[3]
+            let days = m[2]
+        else
+            let m = matchlist(a:date, '^\(\d\{1,2}\)\.\s*\(\d\{1,2}\)\.\s*\(\d\d\{2}\|\d\{4}\)$')
+            if !empty(m)
+                let year = m[3]
+                let month = m[2]
+                let days = m[1]
+            endif
+        endif
+    endif
+    if empty(m) || year == '' || month == '' || days == '' || 
+                \ month < min || month > 12 || days < min || days > 31
+        if !silent
+            echoerr 'TLib: Invalid date: '. a:date
+        endif
+        return []
+    endif
+    if strlen(year) == 2
+        let year = g:tlib#date#ShortDatePrefix . year
+    endif
+    return [0 + year, 0 + month, 0 + days]
+endf
+
+
+" tlib#date#SecondsSince1970(date, ?daysshift=0, ?allow_zero=0)
+function! tlib#date#SecondsSince1970(date, ...) "{{{3
+    let allow_zero = a:0 >= 2 ? a:2 : 0
+    " TLogVAR a:date, allow_zero
+    let date = tlib#date#Parse(a:date, allow_zero)
+    if empty(date)
+        return 0
+    endif
+    let [year, month, days] = date
+    if a:0 >= 1 && a:1 > 0
+        let days = days + a:1
+    end
+    let days_passed = days
+    let i = 1970
+    while i < year
+        let days_passed = days_passed + 365
+        if i % 4 == 0 || i == 2000
+            let days_passed = days_passed + 1
+        endif
+        let i = i + 1
+    endwh
+    let i = 1
+    while i < month
+        if i == 1
+            let days_passed = days_passed + 31
+        elseif i == 2
+            let days_passed = days_passed + 28
+            if year % 4 == 0 || year == 2000
+                let days_passed = days_passed + 1
+            endif
+        elseif i == 3
+            let days_passed = days_passed + 31
+        elseif i == 4
+            let days_passed = days_passed + 30
+        elseif i == 5
+            let days_passed = days_passed + 31
+        elseif i == 6
+            let days_passed = days_passed + 30
+        elseif i == 7
+            let days_passed = days_passed + 31
+        elseif i == 8
+            let days_passed = days_passed + 31
+        elseif i == 9
+            let days_passed = days_passed + 30
+        elseif i == 10
+            let days_passed = days_passed + 31
+        elseif i == 11
+            let days_passed = days_passed + 30
+        endif
+        let i = i + 1
+    endwh
+    let seconds = (days_passed - 1) * 24 * 60 * 60
+    let seconds = seconds + (strftime('%H') + g:tlib#date#TimeZoneShift) * 60 * 60
+    let seconds = seconds + strftime('%M') * 60
+    let seconds = seconds + strftime('%S')
+    return seconds
+endf
+
+
+function! tlib#date#Shift(date, shift) abort "{{{3
+    let n = str2nr(matchstr(a:shift, '\d\+'))
+    let ml = matchlist(a:date, g:tlib#date#date_rx)
+    " TLogVAR a:date, a:shift, n, ml
+    if a:shift =~ 'd$'
+        let date = tlib#date#AddDays(a:date, n)
+    elseif a:shift =~ 'b$'
+        let n1 = n
+        let secs = tlib#date#SecondsSince1970(a:date)
+        while n1 > 0
+            let n1 -= 1
+            let secs += g:tlib#date#dayshift
+            let uday = strftime('%u', secs)
+            if uday == 6
+                let secs += g:tlib#date#dayshift * 2
+            elseif uday == 7
+                let secs += g:tlib#date#dayshift
+            endif
+        endwh
+        let date = tlib#date#Format(secs)
+    elseif a:shift =~ 'w$'
+        let date = tlib#date#AddDays(a:date, n * 7)
+    elseif a:shift =~ 'm$'
+        let d = str2nr(ml[3])
+        let ms = str2nr(ml[2]) + n
+        let m = (ms - 1) % 12 + 1
+        let yr = str2nr(ml[1]) + (ms - 1) / 12
+        let date = printf('%04d-%02d-%02d', yr, m, d)
+        " TLogVAR d, ms, m, yr, date
+    elseif a:shift =~ 'y$'
+        let yr = str2nr(ml[1]) + n
+        let date = substitute(a:date, '^\d\{4}', yr, '')
+    else
+        throw 'tlib#date#Shift: Unsupported arguments: '. string(a:shift)
+    endif
+    " if !empty(ml[4]) && date !~ '\s'. ml[4] .'$'
+    "     let date .= ' '. ml[4]
+    " endif
+    " TLogVAR date
+    return date
+endf
+
+
+function! tlib#date#AddDays(date, n) abort "{{{3
+    let secs = tlib#date#SecondsSince1970(a:date) + g:tlib#date#dayshift * a:n
+    " TLogVAR secs
+    let date = tlib#date#Format(secs)
+    return date
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/dictionary.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/dictionary.vim
new file mode 100644
index 0000000..a778519
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/dictionary.vim
@@ -0,0 +1,45 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2016-04-06
+" @Revision:    22
+
+
+" :display: tlib#dictionary#Rev(dict, ?opts = {}) abort "{{{3
+function! tlib#dictionary#Rev(dict, ...) abort "{{{3
+    let opts = a:0 >= 1 ? a:1 : {}
+    Tlibtype a:dict, 'dict', opts, 'dict'
+    let rev = {}
+    let use_string = get(opts, 'use_string', 0)
+    let use_eval = get(opts, 'use_eval', 0)
+    let values_as_list = get(opts, 'values_as_list', 0)
+    for [m, f] in items(a:dict)
+        if use_string
+            let k = string(f)
+        else
+            let k = type(f) == 1 ? f : string(f)
+            if k ==# ''
+                let k = get(opts, 'empty', '')
+                if empty(k)
+                    continue
+                endif
+            endif
+        endif
+        if use_eval
+            let v = eval(m)
+        else
+            let v = m
+        endif
+        if values_as_list
+            if has_key(rev, k)
+                call add(rev[k], v)
+            else
+                let rev[k] = [v]
+            endif
+        else
+            let rev[k] = v
+        endif
+    endfor
+    return rev
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/dir.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/dir.vim
new file mode 100755
index 0000000..0208107
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/dir.vim
@@ -0,0 +1,93 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    43
+
+" TLet g:tlib#dir#sep = '/'
+TLet g:tlib#dir#sep = exists('+shellslash') && !&shellslash ? '\' : '/'
+
+
+let s:dir_stack = []
+
+" EXAMPLES: >
+"   tlib#dir#CanonicName('foo/bar')
+"   => 'foo/bar/'
+function! tlib#dir#CanonicName(dirname) "{{{3
+    let dirname = tlib#file#Canonic(a:dirname)
+    if dirname !~ '[/\\]$'
+        return dirname . g:tlib#dir#sep
+    endif
+    return dirname
+endf
+
+
+" EXAMPLES: >
+"   tlib#dir#NativeName('foo/bar/')
+"   On Windows:
+"   => 'foo\bar\'
+"   On Linux:
+"   => 'foo/bar/'
+function! tlib#dir#NativeName(dirname) "{{{3
+    let sep = tlib#rx#EscapeReplace(g:tlib#dir#sep)
+    let dirname = substitute(a:dirname, '[\/]', sep, 'g')
+    return dirname
+endf
+
+
+" EXAMPLES: >
+"   tlib#dir#PlainName('foo/bar/')
+"   => 'foo/bar'
+function! tlib#dir#PlainName(dirname) "{{{3
+    let dirname = a:dirname
+    while index(['/', '\'], dirname[-1 : -1]) != -1
+        let dirname = dirname[0 : -2]
+    endwh
+    return dirname
+    " return substitute(a:dirname, tlib#rx#Escape(g:tlib#dir#sep).'\+$', '', '')
+endf
+
+
+" Create a directory if it doesn't already exist.
+function! tlib#dir#Ensure(dir) "{{{3
+    if !isdirectory(a:dir)
+        let dir = tlib#dir#PlainName(a:dir)
+        return mkdir(dir, 'p')
+    endif
+    return 1
+endf
+
+
+" Return the first directory in &rtp.
+function! tlib#dir#MyRuntime() "{{{3
+    return get(split(&rtp, ','), 0)
+endf
+
+
+" :def: function! tlib#dir#CD(dir, ?locally=0) => CWD
+function! tlib#dir#CD(dir, ...) "{{{3
+    TVarArg ['locally', haslocaldir()]
+    let cmd = locally ? 'lcd! ' : 'cd! '
+    " let cwd = getcwd()
+    let cmd .= tlib#arg#Ex(a:dir)
+    " TLogVAR a:dir, locally, cmd
+    exec 'silent' cmd
+    " return cwd
+    return getcwd()
+endf
+
+
+" :def: function! tlib#dir#Push(dir, ?locally=0) => CWD
+function! tlib#dir#Push(dir, ...) "{{{3
+    TVarArg ['locally', haslocaldir()]
+    call add(s:dir_stack, [getcwd(), locally])
+    return tlib#dir#CD(a:dir, locally)
+endf
+
+
+" :def: function! tlib#dir#Pop() => CWD
+function! tlib#dir#Pop() "{{{3
+    let [dir, locally] = remove(s:dir_stack, -1)
+    return tlib#dir#CD(dir, locally)
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/eval.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/eval.vim
new file mode 100755
index 0000000..117209e
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/eval.vim
@@ -0,0 +1,72 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    56
+
+
+function! tlib#eval#FormatValue(value, ...) "{{{3
+    TVarArg ['indent', 0]
+    " TLogVAR a:value, indent
+    let indent1 = indent + 1
+    let indenti = repeat(' ', &sw)
+    let type = type(a:value)
+    let acc = []
+    if type == 0 || type == 1 || type == 2
+        " TLogDBG 'Use string() for type='. type
+        call add(acc, string(a:value))
+    elseif type == 3 "List
+        " TLogDBG 'List'
+        call add(acc, '[')
+        for e in a:value
+            call add(acc, printf('%s%s,', indenti, tlib#eval#FormatValue(e, indent1)))
+            unlet e
+        endfor
+        call add(acc, ']')
+    elseif type == 4 "Dictionary
+        " TLogDBG 'Dictionary'
+        call add(acc, '{')
+        let indent1 = indent + 1
+        for [k, v] in items(a:value)
+            call add(acc, printf("%s%s: %s,", indenti, string(k), tlib#eval#FormatValue(v, indent1)))
+            unlet k v
+        endfor
+        call add(acc, '}')
+    else
+        " TLogDBG 'Unknown type: '. string(a:value)
+        call add(acc, string(a:value))
+    endif
+    if indent > 0
+        let is = repeat(' ', indent * &sw)
+        for i in range(1,len(acc) - 1)
+            let acc[i] = is . acc[i]
+        endfor
+    endif
+    return join(acc, "\n")
+endf
+
+
+function! tlib#eval#Extend(a, b, ...) abort "{{{3
+    let mode = a:0 >= 1 ? a:1 : 'force'
+    if type(a:a) != type(a:b)
+        throw 'tlib#eval#Extend: Incompatible types: a='. string(a:a) .' b='. string(a:b)
+    elseif type(a:a) == 3 " list
+        return extend(a:a, a:b, mode)
+    elseif type(a:a) == 4 " dict
+        for k in keys(a:b)
+            if has_key(a:a, k)
+                if mode == 'force'
+                    let a:a[k] = tlib#eval#Extend(copy(a:a[k]), a:b[k], mode)
+                elseif mode == 'error'
+                    throw 'tlib#eval#Extend: Key already exists: '. k
+                endif
+            else
+                let a:a[k] = a:b[k]
+            endif
+            unlet! k
+        endfor
+        return a:a
+    else
+        return a:b
+    endif
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/file.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/file.vim
new file mode 100644
index 0000000..44ba044
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/file.vim
@@ -0,0 +1,283 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    169
+
+
+if !exists('g:tlib#file#drop')
+    " If true, use |:drop| to edit loaded buffers (only available with GUI).
+    let g:tlib#file#drop = has('gui')   "{{{2
+endif
+
+
+if !exists('g:tlib#file#use_tabs')
+    let g:tlib#file#use_tabs = 0   "{{{2
+endif
+
+
+if !exists('g:tlib#file#edit_cmds')
+    let g:tlib#file#edit_cmds = g:tlib#file#use_tabs ? {'buffer': 'tab split | buffer', 'edit': 'tabedit'} : {}  "{{{2
+endif
+
+
+if !exists('g:tlib#file#absolute_filename_rx')
+    let g:tlib#file#absolute_filename_rx = '^\~\?[\/]'   "{{{2
+endif
+
+""" File related {{{1
+" For the following functions please see ../../test/tlib.vim for examples.
+
+
+" EXAMPLES: >
+"   tlib#file#Split('foo/bar/filename.txt')
+"   => ['foo', 'bar', 'filename.txt']
+function! tlib#file#Split(filename) "{{{3
+    let prefix = matchstr(a:filename, '^\(\w\+:\)\?/\+')
+    " TLogVAR prefix
+    if !empty(prefix)
+        let filename = a:filename[len(prefix) : -1]
+    else
+        let filename = a:filename
+    endif
+    let rv = split(filename, '[\/]')
+    " let rv = split(filename, '[\/]', 1)
+    if !empty(prefix)
+        call insert(rv, prefix[0:-2])
+    endif
+    return rv
+endf
+
+
+" :display: tlib#file#Join(filename_parts, ?strip_slashes=1, ?maybe_absolute=0)
+" EXAMPLES: >
+"   tlib#file#Join(['foo', 'bar', 'filename.txt'])
+"   => 'foo/bar/filename.txt'
+function! tlib#file#Join(filename_parts, ...) "{{{3
+    TVarArg ['strip_slashes', 1], 'maybe_absolute'
+    " TLogVAR a:filename_parts, strip_slashes
+    if maybe_absolute
+        let filename_parts = []
+        for part in a:filename_parts
+            if part =~ g:tlib#file#absolute_filename_rx
+                let filename_parts = []
+            endif
+            call add(filename_parts, part)
+        endfor
+    else
+        let filename_parts = a:filename_parts
+    endif
+    if strip_slashes
+        " let rx    = tlib#rx#Escape(g:tlib#dir#sep) .'$'
+        let rx    = '[/\\]\+$'
+        let parts = map(copy(filename_parts), 'substitute(v:val, rx, "", "")')
+        " TLogVAR parts
+        return join(parts, g:tlib#dir#sep)
+    else
+        return join(filename_parts, g:tlib#dir#sep)
+    endif
+endf
+
+
+" EXAMPLES: >
+"   tlib#file#Relative('foo/bar/filename.txt', 'foo')
+"   => 'bar/filename.txt'
+function! tlib#file#Relative(filename, basedir) "{{{3
+    " TLogVAR a:filename, a:basedir
+    " TLogDBG getcwd()
+    " TLogDBG expand('%:p')
+    let b0 = tlib#file#Absolute(a:basedir)
+    let b  = tlib#file#Split(b0)
+    " TLogVAR b
+    let f0 = tlib#file#Absolute(a:filename)
+    let fn = fnamemodify(f0, ':t')
+    let fd = fnamemodify(f0, ':h')
+    let f  = tlib#file#Split(fd)
+    " TLogVAR f0, fn, fd, f
+    if f[0] != b[0]
+        let rv = f0
+    else
+        while !empty(f) && !empty(b)
+            if f[0] != b[0]
+                break
+            endif
+            call remove(f, 0)
+            call remove(b, 0)
+        endwh
+        " TLogVAR f, b
+        let rv = tlib#file#Join(repeat(['..'], len(b)) + f + [fn])
+    endif
+    " TLogVAR rv
+    return rv
+endf
+
+
+function! tlib#file#IsAbsolute(filename) "{{{3
+    return a:filename =~? '^\%(/\|\w\+:/\)'
+endf
+
+
+function! tlib#file#Absolute(filename, ...) "{{{3
+    if filereadable(a:filename)
+        let filename = fnamemodify(a:filename, ':p')
+    elseif a:filename =~ '^\(/\|[^\/]\+:\)'
+        let filename = a:filename
+    else
+        let cwd = a:0 >= 1 ? a:1 : getcwd()
+        let filename = tlib#file#Join([cwd, a:filename])
+    endif
+    let filename = substitute(filename, '\(^\|[\/]\)\zs\.[\/]', '', 'g')
+    let filename = substitute(filename, '[\/]\zs[^\/]\+[\/]\.\.[\/]', '', 'g')
+    return filename
+endf
+
+
+function! tlib#file#Canonic(filename, ...) "{{{3
+    TVarArg ['mode', '']
+    if a:filename =~ '^\\\\'
+        let mode = 'windows'
+    elseif a:filename =~ '^\(file\|ftp\|http\)s\?:'
+        let mode = 'url'
+    elseif (empty(mode) && g:tlib#sys#windows)
+        let mode = 'windows'
+    endif
+    let filename = a:filename
+    if mode == 'windows'
+        let filename = substitute(filename, '/', '\\', 'g')
+    else
+        let filename = substitute(filename, '\\', '/', 'g')
+    endif
+    return filename
+endf
+
+
+function! s:SetScrollBind(world) "{{{3
+    let sb = get(a:world, 'scrollbind', &scrollbind)
+    if sb != &scrollbind
+        let &scrollbind = sb
+    endif
+endf
+
+
+" :def: function! tlib#file#With(fcmd, bcmd, files, ?world={})
+function! tlib#file#With(fcmd, bcmd, files, ...) "{{{3
+    " TLogVAR a:fcmd, a:bcmd, a:files
+    exec tlib#arg#Let([['world', {}]])
+    call tlib#autocmdgroup#Init()
+    augroup TLibFileRead
+        autocmd!
+    augroup END
+    for f in a:files
+        let bn = bufnr('^'.f.'$')
+        " TLogVAR f, bn
+        let bufloaded = bufloaded(bn)
+        let ok = 0
+        let s:bufread = ""
+        if bn != -1 && buflisted(bn)
+            if !empty(a:bcmd)
+                " TLogDBG a:bcmd .' '. bn
+                exec a:bcmd .' '. bn
+                let ok = 1
+                call s:SetScrollBind(world)
+            endif
+        else
+            if filereadable(f)
+                if !empty(a:fcmd)
+                    " TLogDBG a:fcmd .' '. tlib#arg#Ex(f)
+                    exec 'autocmd TLibFileRead BufRead' escape(f, '\ ') 'let s:bufread=expand("<afile>:p")'
+                    try 
+                        exec a:fcmd .' '. tlib#arg#Ex(f)
+                    finally
+                        exec 'autocmd! TLibFileRead BufRead'
+                    endtry
+                    let ok = 1
+                    call s:SetScrollBind(world)
+                endif
+            else
+                echohl error
+                echom 'File not readable: '. f
+                echohl NONE
+            endif
+        endif
+        " TLogVAR ok, bufloaded, &filetype
+        if empty(s:bufread) && ok && !bufloaded && empty(&filetype)
+            doautocmd BufRead
+        endif
+    endfor
+    augroup! TLibFileRead
+    unlet! s:bufread
+    " TLogDBG "done"
+endf
+
+
+" Return 0 if the file isn't readable/doesn't exist.
+" Otherwise return 1.
+function! tlib#file#Edit(fileid) "{{{3
+    if type(a:fileid) == 0
+        let bn = a:fileid
+        let filename = fnamemodify(bufname(bn), ':p')
+    else
+        let filename = fnamemodify(a:fileid, ':p')
+        let bn = bufnr(filename)
+    endif
+    if filename == expand('%:p')
+        return 1
+    else
+        " TLogVAR a:fileid, bn, filename, g:tlib#file#drop, filereadable(filename)
+        if bn != -1 && buflisted(bn)
+            if g:tlib#file#drop
+                " echom "DBG" get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
+                exec get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
+            else
+                " echom "DBG" get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
+                exec get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
+            endif
+            return 1
+        elseif filereadable(filename)
+            try
+                " let file = tlib#arg#Ex(filename)
+                " " TLogVAR file
+                " echom "DBG" get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
+                exec get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
+            catch /E325/
+                " swap file exists, let the user handle it
+            catch
+                echohl error
+                echom v:exception
+                echohl NONE
+            endtry
+            return 1
+        else
+            echom "TLIB: File not readable: " . filename
+            if filename != a:fileid
+                echom "TLIB: original filename: " . a:fileid
+            endif
+        endif
+    endif
+    return 0
+endf
+
+
+if v:version > 704 || (v:version == 704 && has('patch279'))
+
+    function! tlib#file#Glob(pattern) abort "{{{3
+        return glob(a:pattern, 0, 1)
+    endf
+
+    function! tlib#file#Globpath(path, pattern) abort "{{{3
+        return globpath(a:path, a:pattern, 0, 1)
+    endf
+
+else
+
+    " :nodoc:
+    function! tlib#file#Glob(pattern) abort "{{{3
+        return split(glob(a:pattern), '\n')
+    endf
+
+    " :nodoc:
+    function! tlib#file#Globpath(path, pattern) abort "{{{3
+        return split(globpath(a:path, a:pattern), '\n')
+    endf
+
+endif
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/fixes.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/fixes.vim
new file mode 100644
index 0000000..e9247dd
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/fixes.vim
@@ -0,0 +1,14 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2013-02-22.
+" @Revision:    3
+
+
+function! tlib#fixes#Winpos() "{{{3
+    if has('gui_win32')
+        return 'winpos '. getwinposx() .' '. getwinposy()
+    else
+        return ''
+    endif
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/grep.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/grep.vim
new file mode 100644
index 0000000..894b1ee
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/grep.vim
@@ -0,0 +1,38 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2013-10-16.
+" @Revision:    31
+
+
+function! tlib#grep#Do(cmd, rx, files) "{{{3
+    " TLogVAR a:cmd, a:rx, a:files
+    let files = join(map(copy(a:files), 'tlib#arg#Ex(v:val, "")'), ' ')
+    let rx = '/'. escape(a:rx, '/') .'/j'
+    " TLogVAR rx, files
+    silent exec a:cmd rx files
+endf
+
+
+function! tlib#grep#LocList(rx, files) "{{{3
+    return tlib#grep#Do('noautocmd lvimgrep', a:rx, a:files)
+endf
+
+
+function! tlib#grep#QuickFixList(rx, files) "{{{3
+    return tlib#grep#Do('noautocmd vimgrep', a:rx, a:files)
+endf
+
+
+function! tlib#grep#List(rx, files) "{{{3
+    call setqflist([])
+    call tlib#grep#Do('noautocmd vimgrepadd', a:rx, a:files)
+    let qfl = getqflist()
+    " TLogVAR qfl
+    " try
+        silent! colder
+    " catch
+    "     call setqflist([], 'r')
+    " endtry
+    return qfl
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/hash.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/hash.vim
new file mode 100644
index 0000000..29c9ef6
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/hash.vim
@@ -0,0 +1,145 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    276
+
+
+if !exists('g:tlib#hash#use_crc32')
+    let g:tlib#hash#use_crc32 = ''   "{{{2
+endif
+
+
+if !exists('g:tlib#hash#use_adler32')
+    let g:tlib#hash#use_adler32 = ''   "{{{2
+endif
+
+
+function! tlib#hash#CRC32B(chars) "{{{3
+    if !empty(g:tlib#hash#use_crc32)
+        let use = g:tlib#hash#use_crc32
+    elseif has('ruby')
+        let use = 'ruby'
+    else
+        let use = 'vim'
+    endif
+    if exists('*tlib#hash#CRC32B_'. use)
+        return tlib#hash#CRC32B_{use}(a:chars)
+    else
+        throw "Unknown version of tlib#hash#CRC32B: ". use
+    endif
+endf
+
+
+function! tlib#hash#CRC32B_ruby(chars) "{{{3
+    if has('ruby')
+        let rv = ''
+        if !exists('s:loaded_ruby_zlib')
+            ruby require 'zlib'
+            let s:loaded_ruby_zlib = 1
+        endif
+        ruby VIM::command('let rv = "%08X"' % Zlib.crc32(VIM::evaluate("a:chars")))
+        return rv
+    else
+        throw "tlib#hash#CRC32B_ruby not supported in this version of vim"
+    endif
+endf
+
+
+function! tlib#hash#CRC32B_vim(chars) "{{{3
+    if !exists('s:crc_table')
+        let cfile = tlib#persistent#Filename('tlib', 'crc_table', 1)
+        let s:crc_table = tlib#persistent#Value(cfile, 'tlib#hash#CreateCrcTable', 0)
+    endif
+    let xFFFF_FFFF = repeat([1], 32)
+    let crc = tlib#bitwise#XOR([0], xFFFF_FFFF, 'bits')
+    for char in split(a:chars, '\zs')
+        let octet = char2nr(char)
+        let r1 = tlib#bitwise#ShiftRight(crc, 8)
+        let i0 = tlib#bitwise#AND(crc, xFFFF_FFFF, 'bits')
+        let i1 = tlib#bitwise#XOR(i0, octet, 'bits')
+        let i2 = tlib#bitwise#Bits2Num(tlib#bitwise#AND(i1, 0xff, 'bits'))
+        let r2 = s:crc_table[i2]
+        let crc = tlib#bitwise#XOR(r1, r2, 'bits')
+    endfor
+    let crc = tlib#bitwise#XOR(crc, xFFFF_FFFF, 'bits')
+    let rv = tlib#bitwise#Bits2Num(crc, 16)
+    if len(rv) < 8
+        let rv = repeat('0', 8 - len(rv)) . rv
+    endif
+    return rv
+endf
+
+
+" :nodoc:
+function! tlib#hash#CreateCrcTable() "{{{3
+    let sum = 0.0
+    for exponent in [0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26, 32]
+        let exp = tlib#bitwise#Bits2Num(repeat([0], 32 - exponent) + [1], 10.0)
+        let sum += exp
+    endfor
+    let divisor = tlib#bitwise#Num2Bits(sum)
+    let crc_table = []
+    for octet in range(256)
+        let remainder = tlib#bitwise#Num2Bits(octet)
+        for i in range(8)
+            if get(remainder, i) != 0
+                let remainder = tlib#bitwise#XOR(remainder, tlib#bitwise#ShiftLeft(divisor, i), "bits")
+            endif
+        endfor
+        let remainder = tlib#bitwise#ShiftRight(remainder, 8)
+        call add(crc_table, remainder)
+    endfor
+    return crc_table
+endf
+
+
+function! tlib#hash#Adler32(chars) "{{{3
+    if !empty(g:tlib#hash#use_adler32)
+        let use = g:tlib#hash#use_adler32
+    elseif exists('*or')
+        let use = 'vim'
+    else
+        let use = 'tlib'
+    endif
+    if exists('*tlib#hash#Adler32_'. use)
+        return tlib#hash#Adler32_{use}(a:chars)
+    else
+        throw "Unknown version of tlib#hash#Adler32_: ". use
+    endif
+endf
+
+
+function! tlib#hash#Adler32_vim(chars) "{{{3
+    if exists('*or')
+        let mod_adler = 65521
+        let a = 1
+        let b = 0
+        for index in range(len(a:chars))
+            let c = char2nr(a:chars[index])
+            let a = (a + c) % mod_adler
+            let b = (b + a) % mod_adler
+        endfor
+        let bb = b * float2nr(pow(2, 16))
+        let checksum = or(bb, a)
+        " TLogVAR checksum, a, b, bb
+        return printf("%08X", checksum)
+    else
+        throw "TLIB: Vim version doesn't support bitwise or()"
+    endif
+endf
+
+
+function! tlib#hash#Adler32_tlib(chars) "{{{3
+    let mod_adler = 65521
+    let a = 1
+    let b = 0
+    for index in range(len(a:chars))
+        let c = char2nr(a:chars[index])
+        let a = (a + c) % mod_adler
+        let b = (b + a) % mod_adler
+    endfor
+    let bb = tlib#bitwise#ShiftLeft(tlib#bitwise#Num2Bits(b), 16)
+    let checksum = tlib#bitwise#OR(bb, a, "bits")
+    return printf('%08s', tlib#bitwise#Bits2Num(checksum, 16))
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/hook.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/hook.vim
new file mode 100755
index 0000000..07d0504
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/hook.vim
@@ -0,0 +1,25 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    11
+
+
+" :def: function! tlib#hook#Run(hook, ?dict={})
+" Execute dict[hook], w:{hook}, b:{hook}, or g:{hook} if existent.
+function! tlib#hook#Run(hook, ...) "{{{3
+    TVarArg ['dict', {}]
+    if has_key(dict, a:hook)
+        let hook = dict[a:hook]
+    else
+        let hook = tlib#var#Get(a:hook, 'wbg')
+    endif
+    if empty(hook)
+        return 0
+    else
+        let world = dict
+        exec hook
+        return 1
+    endif
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/input.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/input.vim
new file mode 100644
index 0000000..e8f892b
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/input.vim
@@ -0,0 +1,1336 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    1366
+
+
+" :filedoc:
+" Input-related, select from a list etc.
+
+" If a list is bigger than this value, don't try to be smart when 
+" selecting an item. Be slightly faster instead.
+" See |tlib#input#List()|.
+TLet g:tlib#input#sortprefs_threshold = 200
+
+
+" If a list contains more items, |tlib#input#List()| does not perform an 
+" incremental "live search" but uses |input()| to query the user for a 
+" filter. This is useful on slower machines or with very long lists.
+TLet g:tlib#input#livesearch_threshold = 1000
+
+
+" Determine how |tlib#input#List()| and related functions work.
+" Can be "glob", "cnf", "cnfd", "seq", or "fuzzy". See:
+"   glob ... Like cnf but "*" and "?" (see |g:tlib#Filter_glob#seq|, 
+"       |g:tlib#Filter_glob#char|) are interpreted as glob-like 
+"       |wildcards| (this is the default method)
+"     - Examples:
+"         - "f*o" matches "fo", "fxo", and "fxxxoo", but doesn't match 
+"           "far".
+"     - Otherwise it is a derivate of the cnf method (see below).
+"     - See also |tlib#Filter_glob#New()|.
+"   cnfd ... Like cnf but "." is interpreted as a wildcard, i.e. it is 
+"            expanded to "\.\{-}"
+"     - A period character (".") acts as a wildcard as if ".\{-}" (see 
+"       |/\{-|) were entered.
+"     - Examples:
+"         - "f.o" matches "fo", "fxo", and "fxxxoo", but doesn't match 
+"           "far".
+"     - Otherwise it is a derivate of the cnf method (see below).
+"     - See also |tlib#Filter_cnfd#New()|.
+"   cnf .... Match substrings
+"     - A blank creates an AND conjunction, i.e. the next pattern has to 
+"       match too.
+"     - A pipe character ("|") creates an OR conjunction, either this or 
+"       the next next pattern has to match.
+"     - Patterns are very 'nomagic' |regexp| with a |\V| prefix.
+"     - A pattern starting with "-" makes the filter exclude items 
+"       matching that pattern.
+"     - Examples:
+"         - "foo bar" matches items that contain the strings "foo" AND 
+"           "bar".
+"         - "foo|bar boo|far" matches items that contain either ("foo" OR 
+"           "bar") AND ("boo" OR "far").
+"     - See also |tlib#Filter_cnf#New()|.
+"   seq .... Match sequences of characters
+"     - |tlib#Filter_seq#New()|
+"   fuzzy .. Match fuzzy character sequences
+"     - |tlib#Filter_fuzzy#New()|
+TLet g:tlib#input#filter_mode = 'glob'
+
+
+" The highlight group to use for showing matches in the input list 
+" window.
+" See |tlib#input#List()|.
+TLet g:tlib#input#higroup = 'IncSearch'
+
+" When 1, automatically select the last remaining item only if the list 
+" had only one item to begin with.
+" When 2, automatically select a last remaining item after applying 
+" any filters.
+" See |tlib#input#List()|.
+TLet g:tlib_pick_last_item = 1
+
+
+" :doc:
+" Keys for |tlib#input#List|~
+
+TLet g:tlib#input#and = ' '
+TLet g:tlib#input#or  = '|'
+TLet g:tlib#input#not = '-'
+
+" When editing a list with |tlib#input#List|, typing these numeric chars 
+" (as returned by getchar()) will select an item based on its index, not 
+" based on its name. I.e. in the default setting, typing a "4" will 
+" select the fourth item, not the item called "4".
+" In order to make keys 0-9 filter the items in the list and make 
+" <m-[0-9]> select an item by its index, remove the keys 48 to 57 from 
+" this dictionary.
+" Format: [KEY] = BASE ... the number is calculated as KEY - BASE.
+" :nodefault:
+TLet g:tlib#input#numeric_chars = {
+            \ 176: 176,
+            \ 177: 176,
+            \ 178: 176,
+            \ 179: 176,
+            \ 180: 176,
+            \ 181: 176,
+            \ 182: 176,
+            \ 183: 176,
+            \ 184: 176,
+            \ 185: 176,
+            \}
+            " \ 48: 48,
+            " \ 49: 48,
+            " \ 50: 48,
+            " \ 51: 48,
+            " \ 52: 48,
+            " \ 53: 48,
+            " \ 54: 48,
+            " \ 55: 48,
+            " \ 56: 48,
+            " \ 57: 48,
+
+
+" :nodefault:
+" The default key bindings for single-item-select list views.
+"
+" This variable is best customized via the variable 
+" g:tlib_extend_keyagents_InputList_s. If you want to use <c-j>, <c-k> 
+" to move the cursor up and down, add these two lines to your |vimrc| 
+" file:
+"
+"   let g:tlib_extend_keyagents_InputList_s = {
+"       \ 10: 'tlib#agent#Down',
+"       \ 11: 'tlib#agent#Up'
+"       \ }
+TLet g:tlib#input#keyagents_InputList_s = {
+            \ "\<PageUp>":   'tlib#agent#PageUp',
+            \ "\<PageDown>": 'tlib#agent#PageDown',
+            \ "\<Home>":     'tlib#agent#Home',
+            \ "\<End>":      'tlib#agent#End',
+            \ "\<Up>":       'tlib#agent#Up',
+            \ "\<Down>":     'tlib#agent#Down',
+            \ 9:             'tlib#agent#Complete',
+            \ "\<c-Up>":     'tlib#agent#UpN',
+            \ "\<c-Down>":   'tlib#agent#DownN',
+            \ "\<Left>":     'tlib#agent#ShiftLeft',
+            \ "\<Right>":    'tlib#agent#ShiftRight',
+            \ 18:            'tlib#agent#Reset',
+            \ 242:           'tlib#agent#Reset',
+            \ 17:            'tlib#agent#Input',
+            \ 241:           'tlib#agent#Input',
+            \ 27:            'tlib#agent#Exit',
+            \ 26:            'tlib#agent#Suspend',
+            \ 250:           'tlib#agent#Suspend',
+            \ 15:            'tlib#agent#SuspendToParentWindow',  
+            \ "\<F1>":       'tlib#agent#Help',
+            \ "\<F10>":      'tlib#agent#ExecAgentByName',
+            \ "\<S-Esc>":    'tlib#agent#ExecAgentByName',
+            \ "\<bs>":       'tlib#agent#ReduceFilter',
+            \ "\<del>":      'tlib#agent#ReduceFilter',
+            \ "\<c-bs>":     'tlib#agent#PopFilter',
+            \ "\<m-bs>":     'tlib#agent#PopFilter',
+            \ "\<c-del>":    'tlib#agent#PopFilter',
+            \ "\<m-del>":    'tlib#agent#PopFilter',
+            \ "\<s-space>":  'tlib#agent#Wildcard',
+            \ 191:           'tlib#agent#Debug',
+            \ char2nr(g:tlib#input#or):  'tlib#agent#OR',
+            \ char2nr(g:tlib#input#and): 'tlib#agent#AND',
+            \ }
+            " \ 63:            'tlib#agent#Help',
+
+if exists('g:tlib_extend_keyagents_InputList_s')
+    let g:tlib#input#keyagents_InputList_s = extend(g:tlib#input#keyagents_InputList_s, g:tlib_extend_keyagents_InputList_s)
+endif
+
+
+" :nodefault:
+TLet g:tlib#input#keyagents_InputList_m = {
+            \ 35:          'tlib#agent#Select',
+            \ "\<s-up>":   'tlib#agent#SelectUp',
+            \ "\<s-down>": 'tlib#agent#SelectDown',
+            \ 1:           'tlib#agent#SelectAll',
+            \ 225:         'tlib#agent#SelectAll',
+            \ "\<F9>":     'tlib#agent#ToggleRestrictView',
+            \ }
+" "\<c-space>": 'tlib#agent#Select'
+
+if exists('g:tlib_extend_keyagents_InputList_m')
+    let g:tlib#input#keyagents_InputList_m = extend(g:tlib#input#keyagents_InputList_m, g:tlib_extend_keyagents_InputList_m)
+endif
+
+
+
+" :nodefault:
+TLet g:tlib#input#handlers_EditList = [
+            \ {'key': 5,  'agent': 'tlib#agent#EditItem',    'key_name': '<c-e>', 'help': 'Edit item'},
+            \ {'key': 4,  'agent': 'tlib#agent#DeleteItems', 'key_name': '<c-d>', 'help': 'Delete item(s)'},
+            \ {'key': 14, 'agent': 'tlib#agent#NewItem',     'key_name': '<c-n>', 'help': 'New item'},
+            \ {'key': 24, 'agent': 'tlib#agent#Cut',         'key_name': '<c-x>', 'help': 'Cut item(s)'},
+            \ {'key':  3, 'agent': 'tlib#agent#Copy',        'key_name': '<c-c>', 'help': 'Copy item(s)'},
+            \ {'key': 22, 'agent': 'tlib#agent#Paste',       'key_name': '<c-v>', 'help': 'Paste item(s)'},
+            \ {'pick_last_item': 0},
+            \ {'return_agent': 'tlib#agent#EditReturnValue'},
+            \ {'help_extra': [
+            \      'Submit changes by pressing ENTER or <c-s> or <c-w><cr>',
+            \      'Cancel editing by pressing <c-w>c'
+            \ ]},
+            \ ]
+
+
+" A dictionary KEY => {'agent': AGENT, 'key_name': KEY_NAME} to 
+" customize keyboard shortcuts in the list view.
+TLet g:tlib#input#user_shortcuts = {}
+
+
+" If true, define a popup menu for |tlib#input#List()| and related 
+" functions.
+TLet g:tlib#input#use_popup = has('menu') && (has('gui_gtk') || has('gui_gtk2') || has('gui_win32'))
+
+
+" How to format filenames:
+"     l ... Show basenames on the left side, separated from the 
+"           directory names
+"     r ... Show basenames on the right side
+TLet g:tlib#input#format_filename = 'l'
+
+
+" If g:tlib#input#format_filename == 'r', how much space should be kept 
+" free on the right side.
+TLet g:tlib#input#filename_padding_r = '&co / 10'
+
+
+" If g:tlib#input#format_filename == 'l', an expression that 
+" |eval()|uates to the maximum display width of filenames.
+TLet g:tlib#input#filename_max_width = '&co / 2'
+
+
+" Functions related to tlib#input#List(type, ...) "{{{2
+
+" :def: function! tlib#input#List(type. ?query='', ?list=[], ?handlers=[], ?default="", ?timeout=0)
+" Select a single or multiple items from a list. Return either the list 
+" of selected elements or its indexes.
+"
+" By default, typing numbers will select an item by its index. See 
+" |g:tlib#input#numeric_chars| to find out how to change this.
+"
+" The item is automatically selected if the numbers typed equals the 
+" number of digits of the list length. I.e. if a list contains 20 items, 
+" typing 1 will first highlight item 1 but it won't select/use it 
+" because 1 is an ambiguous input in this context. If you press enter, 
+" the first item will be selected. If you press another digit (e.g. 0), 
+" item 10 will be selected. Another way to select item 1 would be to 
+" type 01. If the list contains only 9 items, typing 1 would select the 
+" first item right away.
+"
+" type can be:
+"     s  ... Return one selected element
+"     si ... Return the index of the selected element
+"     m  ... Return a list of selected elements
+"     mi ... Return a list of indexes
+"
+" Several pattern matching styles are supported. See 
+" |g:tlib#input#filter_mode|.
+"
+" Users can type <Tab> to complete the current filter with the longest 
+" match.
+"
+" EXAMPLES: >
+"   echo tlib#input#List('s', 'Select one item', [100,200,300])
+"   echo tlib#input#List('si', 'Select one item', [100,200,300])
+"   echo tlib#input#List('m', 'Select one or more item(s)', [100,200,300])
+"   echo tlib#input#List('mi', 'Select one or more item(s)', [100,200,300])
+"
+" See ../samples/tlib/input/tlib_input_list.vim (move the cursor over 
+" the filename and press gf) for a more elaborated example.
+function! tlib#input#List(type, ...) "{{{3
+    exec tlib#arg#Let([
+        \ ['query', ''],
+        \ ['list', []],
+        \ ['handlers', []],
+        \ ['rv', ''],
+        \ ['timeout', 0],
+        \ ])
+    " let handlers = a:0 >= 1 ? a:1 : []
+    " let rv       = a:0 >= 2 ? a:2 : ''
+    " let timeout  = a:0 >= 3 ? a:3 : 0
+    " let backchar = ["\<bs>", "\<del>"]
+
+    if a:type =~ '^resume'
+        let world = b:tlib_{matchstr(a:type, ' \zs.\+')}
+    else
+        let world = tlib#World#New({
+                    \ 'type': a:type,
+                    \ 'base': list,
+                    \ 'query': query,
+                    \ 'timeout': timeout,
+                    \ 'rv': rv,
+                    \ 'handlers': handlers,
+                    \ })
+        let scratch_name     = tlib#list#Find(handlers, 'has_key(v:val, "scratch_name")', '', 'v:val.scratch_name')
+        if !empty(scratch_name)
+            let world.scratch = scratch_name
+        endif
+        let world.scratch_vertical = tlib#list#Find(handlers, 'has_key(v:val, "scratch_vertical")', 0, 'v:val.scratch_vertical')
+        call world.Set_display_format(tlib#list#Find(handlers, 'has_key(v:val, "display_format")', '', 'v:val.display_format'))
+        let world.initial_index    = tlib#list#Find(handlers, 'has_key(v:val, "initial_index")', 1, 'v:val.initial_index')
+        let world.index_table      = tlib#list#Find(handlers, 'has_key(v:val, "index_table")', [], 'v:val.index_table')
+        let world.state_handlers   = filter(copy(handlers),   'has_key(v:val, "state")')
+        let world.post_handlers    = filter(copy(handlers),   'has_key(v:val, "postprocess")')
+        let world.filter_format    = tlib#list#Find(handlers, 'has_key(v:val, "filter_format")', '', 'v:val.filter_format')
+        let world.return_agent     = tlib#list#Find(handlers, 'has_key(v:val, "return_agent")', '', 'v:val.return_agent')
+        let world.help_extra       = tlib#list#Find(handlers, 'has_key(v:val, "help_extra")', '', 'v:val.help_extra')
+        let world.resize           = tlib#list#Find(handlers, 'has_key(v:val, "resize")', '', 'v:val.resize')
+        let world.show_empty       = tlib#list#Find(handlers, 'has_key(v:val, "show_empty")', 0, 'v:val.show_empty')
+        let world.pick_last_item   = tlib#list#Find(handlers, 'has_key(v:val, "pick_last_item")', 
+                    \ tlib#var#Get('tlib_pick_last_item', 'bg'), 'v:val.pick_last_item')
+        let world.numeric_chars    = tlib#list#Find(handlers, 'has_key(v:val, "numeric_chars")', 
+                    \ g:tlib#input#numeric_chars, 'v:val.numeric_chars')
+        let world.key_handlers     = filter(copy(handlers), 'has_key(v:val, "key")')
+        let filter                 = tlib#list#Find(handlers, 'has_key(v:val, "filter")', '', 'v:val.filter')
+        if !empty(filter)
+            " let world.initial_filter = [[''], [filter]]
+            " let world.initial_filter = [[filter]]
+            " TLogVAR world.initial_filter
+            call world.SetInitialFilter(filter)
+        endif
+    endif
+    return tlib#input#ListW(world)
+endf
+
+
+" A wrapper for |tlib#input#ListW()| that builds |tlib#World#New| from 
+" dict.
+function! tlib#input#ListD(dict) "{{{3
+    return tlib#input#ListW(tlib#World#New(a:dict))
+endf
+
+
+" :def: function! tlib#input#ListW(world, ?command='')
+" The second argument (command) is meant for internal use only.
+" The same as |tlib#input#List| but the arguments are packed into world 
+" (an instance of tlib#World as returned by |tlib#World#New|).
+function! tlib#input#ListW(world, ...) "{{{3
+    TVarArg 'cmd'
+    " let time0 = str2float(reltimestr(reltime()))  " DBG
+    " TLogVAR time0
+    let world = a:world
+    if world.pick_last_item >= 1 && stridx(world.type, 'e') == -1 && len(world.base) <= 1
+        let rv = get(world.base, 0, world.rv)
+        if stridx(world.type, 'm') != -1
+            return [rv]
+        else
+            return rv
+        endif
+    endif
+    call s:Init(world, cmd)
+    " TLogVAR world.state, world.sticky, world.initial_index
+    " let statusline  = &l:statusline
+    " let laststatus  = &laststatus
+    let showmode = &showmode
+    set noshowmode
+    let lastsearch  = @/
+    let scrolloff = &l:scrolloff
+    let &l:scrolloff = 0
+    let @/ = ''
+    let dlist = []
+    let post_keys = ''
+    " let &laststatus = 2
+
+    try
+        while !empty(world.state) && world.state !~ '^exit' && (world.show_empty || !empty(world.base))
+            let post_keys = ''
+            " TLogDBG 'while'
+            " TLogVAR world.state
+            " let time01 = str2float(reltimestr(reltime()))  " DBG
+            " TLogVAR time01, time01 - time0
+            try
+                let world = s:RunStateHandlers(world)
+
+                " if exists('b:tlib_world_event')
+                "     let event = b:tlib_world_event
+                "     unlet! b:tlib_world_event
+                "     if event == 'WinLeave'
+                "         " let world.resume_state = world.state
+                "         let world = tlib#agent#Suspend(world, world.rv)
+                "         break
+                "     endif
+                " endif
+
+                " let time02 = str2float(reltimestr(reltime()))  " DBG
+                " TLogVAR time02, time02 - time0
+                if world.state =~ '\<reset\>'
+                    " TLogDBG 'reset'
+                    " call world.Reset(world.state =~ '\<initial\>')
+                    call world.Reset()
+                    continue
+                endif
+
+                call s:SetOffset(world)
+
+                " let time02 = str2float(reltimestr(reltime()))  " DBG
+                " TLogVAR time02, time02 - time0
+                " TLogDBG 1
+                " TLogVAR world.state
+                if world.state == 'scroll'
+                    let world.prefidx = world.offset
+                    let world.state = 'redisplay'
+                endif
+
+                if world.state =~ '\<sticky\>'
+                    let world.sticky = 1
+                endif
+
+                " TLogVAR world.filter
+                " TLogVAR world.sticky
+                if world.state =~ '\<picked\>'
+                    " TLogVAR world.rv
+                    throw 'picked'
+                elseif world.state =~ '\<pick\>'
+                    let world.rv = world.CurrentItem()
+                    " TLogVAR world.rv
+                    throw 'picked'
+                elseif world.state =~ 'display'
+                    if world.state =~ '^display'
+                        " let time03 = str2float(reltimestr(reltime()))  " DBG
+                        " TLogVAR time03, time03 - time0
+                        if world.IsValidFilter()
+
+                            " let time1 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time1, time1 - time0
+                            call world.BuildTableList()
+                            " let time2 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time2, time2 - time0
+                            " TLogDBG 2
+                            " TLogDBG len(world.table)
+                            " TLogVAR world.table
+                            " let world.list  = map(copy(world.table), 'world.GetBaseItem(v:val)')
+                            " TLogDBG 3
+                            let world.llen = len(world.list)
+                            " TLogVAR world.index_table
+                            if empty(world.index_table)
+                                let dindex = range(1, world.llen)
+                                let world.index_width = len(world.llen)
+                            else
+                                let dindex = world.index_table
+                                let world.index_width = len(max(dindex))
+                            endif
+                            " let time3 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time3, time3 - time0
+                            if world.llen == 0 && !world.show_empty
+                                call world.ReduceFilter()
+                                let world.offset = 1
+                                " TLogDBG 'ReduceFilter'
+                                continue
+                            else
+                                if world.llen == 1
+                                    let world.last_item = world.list[0]
+                                    if world.pick_last_item >= 2
+                                        " echom 'Pick last item: '. world.list[0]
+                                        let world.prefidx = '1'
+                                        " TLogDBG 'pick last item'
+                                        throw 'pick'
+                                    endif
+                                else
+                                    let world.last_item = ''
+                                endif
+                            endif
+                            " let time4 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time4, time4 - time0
+                            " TLogDBG 4
+                            " TLogVAR world.idx, world.llen, world.state
+                            " TLogDBG world.FilterIsEmpty()
+                            if world.state == 'display'
+                                if world.idx == '' && world.llen < g:tlib#input#sortprefs_threshold && !world.FilterIsEmpty()
+                                    call world.SetPrefIdx()
+                                else
+                                    let world.prefidx = world.idx == '' ? world.initial_index : world.idx
+                                endif
+                                if world.prefidx > world.llen
+                                    let world.prefidx = world.llen
+                                elseif world.prefidx < 1
+                                    let world.prefidx = 1
+                                endif
+                            endif
+                            " let time5 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time5, time5 - time0
+                            " TLogVAR world.initial_index, world.prefidx
+                            " TLogDBG 5
+                            " TLogDBG len(world.list)
+                            " TLogVAR world.list
+                            let dlist = world.DisplayFormat(world.list)
+                            " TLogVAR world.prefidx
+                            " TLogDBG 6
+                            " let time6 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time6, time6 - time0
+                            if world.offset_horizontal > 0
+                                call map(dlist, 'v:val[world.offset_horizontal:-1]')
+                            endif
+                            " let time7 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time7, time7 - time0
+                            " TLogVAR dindex
+                            let dlist = map(range(0, world.llen - 1), 'printf("%0'. world.index_width .'d", dindex[v:val]) .": ". dlist[v:val]')
+                            " TLogVAR dlist
+                            " let time8 = str2float(reltimestr(reltime()))  " DBG
+                            " TLogVAR time8, time8 - time0
+
+                        else
+
+                            let dlist = ['Malformed filter']
+
+                        endif
+                    else
+                        if world.prefidx == 0
+                            let world.prefidx = 1
+                        endif
+                    endif
+                    " TLogVAR world.idx, world.prefidx
+
+                    " TLogDBG 7
+                    " TLogVAR world.prefidx, world.offset
+                    " TLogDBG (world.prefidx > world.offset + winheight(0) - 1)
+                    " if world.prefidx > world.offset + winheight(0) - 1
+                    "     let listtop = world.llen - winheight(0) + 1
+                    "     let listoff = world.prefidx - winheight(0) + 1
+                    "     let world.offset = min([listtop, listoff])
+                    "     TLogVAR world.prefidx
+                    "     TLogDBG len(list)
+                    "     TLogDBG winheight(0)
+                    "     TLogVAR listtop, listoff, world.offset
+                    " elseif world.prefidx < world.offset
+                    "     let world.offset = world.prefidx
+                    " endif
+                    " TLogDBG 8
+                    " TLogVAR world.initial_display, !tlib#char#IsAvailable()
+                    if world.state =~ '\<update\>' || world.initial_display || !tlib#char#IsAvailable()
+                        " TLogDBG len(dlist)
+                        call world.DisplayList(world.Query(), dlist)
+                        call world.FollowCursor()
+                        let world.initial_display = 0
+                        " TLogDBG 9
+                    endif
+                    if world.state =~ '\<hibernate\>'
+                        let world.state = 'suspend'
+                    else
+                        let world.state = ''
+                    endif
+                else
+                    " if world.state == 'scroll'
+                    "     let world.prefidx = world.offset
+                    " endif
+                    call world.DisplayList()
+                    if world.state == 'help' || world.state == 'printlines'
+                        let world.state = 'display'
+                    else
+                        let world.state = ''
+                        call world.FollowCursor()
+                    endif
+                endif
+                " TAssert IsNotEmpty(world.scratch)
+                let world.list_wnr = winnr()
+
+                " TLogVAR world.state, world.next_state
+                if !empty(world.next_state)
+                    let world.state = world.next_state
+                    let world.next_state = ''
+                endif
+
+                if world.state =~ '\<suspend\>'
+                    let world = tlib#agent#SuspendToParentWindow(world, world.rv)
+                    continue
+                endif
+
+                if world.state =~ '\<eval\>'
+                    let query = matchstr(world.state, '\<eval\[\zs.\{-}\ze\]')
+                    if empty(query)
+                        let query = 'Waiting for input ... Press ESC to continue'
+                    endif
+                    if has('gui_win32')
+                        let exec_cmd = input(query, '')
+                        " TLogVAR exec_cmd
+                        if exec_cmd == ''
+                            let world.state = 'redisplay'
+                        else
+                            exec exec_cmd
+                        endif
+                    elseif has('gui_gtk') || has('gui_gtk2')
+                        let c = s:GetModdedChar(world)
+                        " TLogVAR c
+                    endif
+                else
+                    " TLogVAR world.timeout
+                    let c = s:GetModdedChar(world)
+                    " TLogVAR c, has_key(world.key_map[world.key_mode],c)
+                endif
+                " TLogVAR c
+                " TLogDBG string(sort(keys(world.key_map[world.key_mode])))
+
+                " TLogVAR world.next_agent, world.next_eval
+                if !empty(world.next_agent)
+                    let nagent = world.next_agent
+                    let world.next_agent = ''
+                    " let world = call(nagent, [world, world.GetSelectedItems(world.CurrentItem())])
+                    " call s:CheckAgentReturnValue(nagent, world)
+                    let world = s:CallAgent({'agent': nagent}, world, world.GetSelectedItems(world.CurrentItem()))
+                elseif !empty(world.next_eval)
+                    let selected = world.GetSelectedItems(world.CurrentItem())
+                    let neval = world.next_eval
+                    let world.next_eval = ''
+                    exec neval
+                    call s:CheckAgentReturnValue(neval, world)
+                elseif world.state != ''
+                    " continue
+                elseif has_key(world.key_map[world.key_mode], c)
+                    let sr = @/
+                    silent! let @/ = lastsearch
+                    " TLogVAR c, world.key_map[world.key_mode][c]
+                    " TLog "Agent: ". string(world.key_map[world.key_mode][c])
+                    let handler = world.key_map[world.key_mode][c]
+                    " " TLogVAR handler
+                    " let world = call(handler.agent, [world, world.GetSelectedItems(world.CurrentItem())])
+                    " call s:CheckAgentReturnValue(c, world)
+                    let world = s:CallAgent(handler, world, world.GetSelectedItems(world.CurrentItem()))
+                    silent! let @/ = sr
+                    " continue
+                elseif c == 13
+                    throw 'pick'
+                elseif c == 27
+                    " TLogVAR c, world.key_mode
+                    if world.key_mode != 'default'
+                        let world.key_mode = 'default'
+                        let world.state = 'redisplay'
+                    else
+                        let world.state = 'exit empty'
+                    endif
+                elseif c == "\<LeftMouse>"
+                    if v:mouse_win == world.list_wnr
+                        let world.prefidx = world.GetLineIdx(v:mouse_lnum)
+                        " let world.offset  = world.prefidx
+                        if empty(world.prefidx)
+                            " call feedkeys(c, 't')
+                            let c = s:GetModdedChar(world)
+                            let world.state = 'help'
+                            continue
+                        endif
+                        throw 'pick'
+                    else
+                        let post_keys = v:mouse_lnum .'gg'. v:mouse_col .'|'. c
+                        if world.allow_suspend
+                            let world = tlib#agent#SuspendToParentWindow(world, world.rv)
+                        else
+                            let world.state = 'exit empty'
+                        endif
+                    endif
+                elseif c == "\<RightMouse>"
+                    if v:mouse_win == world.list_wnr
+                        call s:BuildMenu(world)
+                        let world.state = 'redisplay'
+                        if s:PopupmenuExists() == 1
+                            " if v:mouse_lnum != line('.')
+                            " endif
+                            let world.prefidx = world.GetLineIdx(v:mouse_lnum)
+                            let world.next_state = 'eval[Waiting for popup menu ... Press ESC to continue]'
+                            call world.DisplayList()
+                            if line('w$') - v:mouse_lnum < 6
+                                popup ]TLibInputListPopupMenu
+                            else
+                                popup! ]TLibInputListPopupMenu
+                            endif
+                        endif
+                    else
+                        let post_keys = v:mouse_lnum .'gg'. v:mouse_col .'|'. c
+                        if world.allow_suspend
+                            let world = tlib#agent#SuspendToParentWindow(world, world.rv)
+                        else
+                            let world.state = 'exit empty'
+                        endif
+                    endif
+                    " TLogVAR world.prefidx, world.state
+                elseif has_key(world.key_map[world.key_mode], 'unknown_key')
+                    let agent = world.key_map[world.key_mode].unknown_key.agent
+                    " let world = call(agent, [world, c])
+                    " call s:CheckAgentReturnValue(agent, world)
+                    let world = s:CallAgent({'agent': agent}, world, c)
+                elseif c >= 32
+                    let world.state = 'display'
+                    let numbase = get(world.numeric_chars, c, -99999)
+                    " TLogVAR numbase, world.numeric_chars, c
+                    if numbase != -99999
+                        let world.idx .= (c - numbase)
+                        if len(world.idx) == world.index_width
+                            let world.prefidx = world.idx
+                            " TLogVAR world.prefidx
+                            throw 'pick'
+                        endif
+                    else
+                        let world.idx = ''
+                        " TLogVAR world.filter
+                        if world.llen > g:tlib#input#livesearch_threshold
+                            let pattern = input('Filter: ', world.CleanFilter(world.filter[0][0]) . nr2char(c))
+                            if empty(pattern)
+                                let world.state = 'exit empty'
+                            else
+                                call world.SetFrontFilter(pattern)
+                                echo
+                            endif
+                        elseif c == 124
+                            call insert(world.filter[0], [])
+                        else
+                            call world.PushFrontFilter(c)
+                        endif
+                        " continue
+                        if c == 45 && world.filter[0][0] == '-'
+                            let world.state = 'redisplay'
+                        end
+                    endif
+                else
+                    let world.state = 'redisplay'
+                    " let world.state = 'continue'
+                endif
+
+            catch /^picked$/
+                call world.ClearAllMarks()
+                call world.MarkCurrent(world.prefidx)
+                let world.state = 'exit'
+
+            catch /^pick$/
+                call world.ClearAllMarks()
+                call world.MarkCurrent(world.prefidx)
+                let world.state = ''
+                " TLogDBG 'Pick item #'. world.prefidx
+
+            finally
+                " TLogDBG 'finally 1', world.state
+                if world.state =~ '\<suspend\>'
+                    " if !world.allow_suspend
+                    "     echom "Cannot be suspended"
+                    "     let world.state = 'redisplay'
+                    " endif
+                elseif !empty(world.list) && !empty(world.base)
+                    " TLogVAR world.list
+                    if empty(world.state)
+                        let world.rv = world.CurrentItem()
+                        " TLogVAR world.state, world.rv
+                    endif
+                    " TLogVAR "postprocess"
+                    for handler in world.post_handlers
+                        let state = get(handler, 'postprocess', '')
+                        " TLogVAR handler
+                        " TLogVAR state
+                        " TLogVAR world.state
+                        if state == world.state
+                            let agent = handler.agent
+                            let [world, world.rv] = call(agent, [world, world.rv])
+                            " TLogVAR world.state, world.rv
+                            call s:CheckAgentReturnValue(agent, world)
+                        endif
+                    endfor
+                endif
+                " TLogDBG 'state0='. world.state
+            endtry
+            " TLogDBG 'state1='. world.state
+        endwh
+
+        " TLogVAR world.state
+        " TLogDBG string(tlib#win#List())
+        " TLogDBG 'exit while loop'
+        " TLogVAR world.list
+        " TLogVAR world.sel_idx
+        " TLogVAR world.idx
+        " TLogVAR world.prefidx
+        " TLogVAR world.rv
+        " TLogVAR world.type, world.state, world.return_agent, world.index_table, world.rv
+        if world.state =~ '\<\(empty\|escape\)\>'
+            let world.sticky = 0
+        endif
+        if world.state =~ '\<suspend\>'
+            " TLogDBG 'return suspended'
+            " TLogVAR world.prefidx
+            " exec world.prefidx
+            return
+        elseif world.state =~ '\<empty\>'
+            " TLog "empty"
+            " TLogDBG 'return empty'
+            " TLogVAR world.type
+            if stridx(world.type, 'm') != -1
+                return []
+            elseif stridx(world.type, 'i') != -1
+                return 0
+            else
+                return ''
+            endif
+        elseif !empty(world.return_agent)
+            " TLogDBG 'return agent'
+            " TLogVAR world.return_agent
+            call world.CloseScratch()
+            " TLogDBG "return_agent ". string(tlib#win#List())
+            " TAssert IsNotEmpty(world.scratch)
+            return call(world.return_agent, [world, world.GetSelectedItems(world.rv)])
+        elseif stridx(world.type, 'w') != -1
+            " TLog "return_world"
+            " TLogDBG 'return world'
+            return world
+        elseif stridx(world.type, 'm') != -1
+            " TLog "return_multi"
+            " TLogDBG 'return multi'
+            return world.GetSelectedItems(world.rv)
+        elseif stridx(world.type, 'i') != -1
+            " TLog "return_index"
+            " TLogDBG 'return index'
+            if empty(world.index_table)
+                return world.rv
+            else
+                return world.index_table[world.rv - 1]
+            endif
+        else
+            " TLog "return_else"
+            " TLogDBG 'return normal'
+            return world.rv
+        endif
+
+    finally
+        call world.Leave()
+
+        " TLogVAR statusline
+        " let &l:statusline = statusline
+        " let &laststatus = laststatus
+        if &showmode != showmode
+            let &showmode = showmode
+        endif
+        silent! let @/  = lastsearch
+        let &l:scrolloff = scrolloff
+        if s:PopupmenuExists() == 1
+            silent! aunmenu ]TLibInputListPopupMenu
+        endif
+
+        " TLogDBG 'finally 2'
+        " TLogDBG string(world.Methods())
+        " TLogVAR world.state
+        " TLogDBG string(tlib#win#List())
+        if world.state !~ '\<suspend\>'
+            " redraw
+            " TLogVAR world.sticky, bufnr("%")
+            if world.sticky
+                " TLogDBG "sticky"
+                " TLogVAR world.bufnr
+                " TLogDBG bufwinnr(world.bufnr)
+                if world.scratch_split > 0
+                    if bufwinnr(world.bufnr) == -1
+                        " TLogDBG "UseScratch"
+                        call world.UseScratch()
+                    endif
+                    let world = tlib#agent#SuspendToParentWindow(world, world.GetSelectedItems(world.rv))
+                endif
+            else
+                " TLogDBG "non sticky"
+                " TLogVAR world.state, world.win_wnr, world.bufnr
+                if world.CloseScratch()
+                    " TLogVAR world.winview
+                    call tlib#win#SetLayout(world.winview)
+                endif
+            endif
+        endif
+        " for i in range(0,5)
+        "     call getchar(0)
+        " endfor
+        echo
+        redraw!
+        if !empty(post_keys)
+            " TLogVAR post_keys
+            call feedkeys(post_keys)
+        endif
+    endtry
+endf
+
+
+function! s:CallAgent(handler, world, list) abort "{{{3
+    let agent = a:handler.agent
+    let args = [a:world, a:list]
+    if has_key(a:handler, 'args')
+        let args += a:handler.args
+    endif
+    let world = call(agent, args)
+    " TLogVAR world.state, world.rv
+    call s:CheckAgentReturnValue(agent, world)
+    return world
+endf
+
+function! s:GetModdedChar(world) "{{{3
+    let [char, mode] = tlib#char#Get(a:world.timeout, a:world.timeout_resolution, 1)
+    if char !~ '\D' && char > 0 && mode != 0
+        return printf("<%s-%s>", mode, char)
+    else
+        return char
+    endif
+endf
+
+
+function! s:Init(world, cmd) "{{{3
+    " TLogVAR a:cmd
+    let a:world.initial_display = 1
+    if a:cmd =~ '\<sticky\>'
+        let a:world.sticky = 1
+    endif
+    if a:cmd =~ '^resume'
+        call a:world.UseInputListScratch()
+        let a:world.initial_index = line('.')
+        if a:cmd =~ '\<pick\>'
+            let a:world.state = 'pick'
+            let a:world.prefidx = a:world.initial_index
+        else
+            call a:world.Retrieve(1)
+        endif
+        " if !empty(a:world.resume_state)
+        "     let a:world.state = a:world.resume_state
+        " endif
+    elseif !a:world.initialized
+        " TLogVAR a:world.initialized, a:world.win_wnr, a:world.bufnr
+        let a:world.filetype = &filetype
+        let a:world.fileencoding = &fileencoding
+        call a:world.SetMatchMode(tlib#var#Get('tlib#input#filter_mode', 'wb'))
+        call a:world.Initialize()
+        if !has_key(a:world, 'key_mode')
+            let a:world.key_mode = 'default'
+        endif
+        " TLogVAR has_key(a:world,'key_map')
+        if has_key(a:world, 'key_map')
+            " TLogVAR has_key(a:world.key_map,a:world.key_mode)
+            if has_key(a:world.key_map, a:world.key_mode)
+                let a:world.key_map[a:world.key_mode] = extend(
+                            \ a:world.key_map[a:world.key_mode],
+                            \ copy(g:tlib#input#keyagents_InputList_s),
+                            \ 'keep')
+            else
+                let a:world.key_map[a:world.key_mode] = copy(g:tlib#input#keyagents_InputList_s)
+            endif
+        else
+            let a:world.key_map = {
+                        \ a:world.key_mode : copy(g:tlib#input#keyagents_InputList_s)
+                        \ }
+        endif
+        " TLogVAR a:world.type
+        if stridx(a:world.type, 'm') != -1
+            call extend(a:world.key_map[a:world.key_mode], g:tlib#input#keyagents_InputList_m, 'force')
+        endif
+        for key_mode in keys(a:world.key_map)
+            let a:world.key_map[key_mode] = map(a:world.key_map[key_mode], 'type(v:val) == 4 ? v:val : {"agent": v:val}')
+        endfor
+        " TLogVAR a:world.key_mode
+        if type(a:world.key_handlers) == 3
+            call s:ExtendKeyMap(a:world, a:world.key_mode, a:world.key_handlers)
+        elseif type(a:world.key_handlers) == 4
+            for [world_key_mode, world_key_handlers] in items(a:world.key_handlers)
+                call s:ExtendKeyMap(a:world, world_key_mode, world_key_handlers)
+            endfor
+        else
+            throw "tlib#input#ListW: key_handlers must be either a list or a dictionary"
+        endif
+        " TLogVAR a:world.type, a:world.key_map
+        if !empty(a:cmd)
+            let a:world.state .= ' '. a:cmd
+        endif
+    endif
+    " TLogVAR a:world.state, a:world.sticky
+endf
+
+
+function! s:ExtendKeyMap(world, key_mode, key_handlers) "{{{3
+    for handler in a:key_handlers
+        let k = get(handler, 'key', '')
+        if !empty(k)
+            let a:world.key_map[a:key_mode][k] = handler
+        endif
+    endfor
+endf
+
+
+function! s:PopupmenuExists()
+    if !g:tlib#input#use_popup
+                \ || exists(':popup') != 2
+                \ || !(has('gui_win32') || has('gui_gtk') || has('gui_gtk2'))
+                " \ || !has('gui_win32')
+        let rv = -1
+    else
+        try
+            let rv = 1
+            silent amenu ]TLibInputListPopupMenu
+        catch
+            let rv = 0
+        endtry
+    endif
+    " TLogVAR rv
+    return rv
+endf
+
+
+function! s:BuildMenu(world) "{{{3
+    if g:tlib#input#use_popup && s:PopupmenuExists() == 0
+        call s:BuildItem('Pick\ selected\ item', {'key_name': '<cr>', 'eval': 'let world.state = "pick"'})
+        call s:BuildItem('Cancel', {'key_name': '<esc>', 'agent': 'tlib#agent#Exit'})
+        call s:BuildItem('Select', {'key_name': '#', 'agent': 'tlib#agent#Select'})
+        call s:BuildItem('Select\ all', {'key_name': '<c-a>', 'agent': 'tlib#agent#SelectAll'})
+        call s:BuildItem('Reset\ list', {'key_name': '<c-r>', 'agent': 'tlib#agent#Reset'})
+        call s:BuildItem('-StandardEntries-', {'key': ":", 'eval': 'let world.state = "redisplay"'})
+        for [key_mode, key_handlers] in items(a:world.key_map)
+            let keys = sort(keys(key_handlers))
+            let mitems = {}
+            for key in keys
+                let handler = key_handlers[key]
+                let k = get(handler, 'key', '')
+                if !empty(k) && has_key(handler, 'help') && !empty(handler.help)
+                    if empty(key_mode) || key_mode == 'default'
+                        let mname = ''
+                    else
+                        let mname = escape(key_mode, ' .\') .'.'
+                    endif
+                    if has_key(handler, 'submenu')
+                        let submenu = escape(handler.submenu, ' .\')
+                    else
+                        let submenu = '~'
+                    endif
+                    for mfield in ['menu', 'help', 'key_name', 'agent']
+                        if has_key(handler, mfield)
+                            let mname .= escape(handler[mfield], ' .\')
+                            break
+                        endif
+                    endfor
+                    if !has_key(mitems, submenu)
+                        let mitems[submenu] = {}
+                    endif
+                    let mitems[submenu][mname] = handler
+                endif
+            endfor
+            for msubname in sort(keys(mitems))
+                let msubitems = mitems[msubname]
+                if msubname == '~'
+                    let msubmname = ''
+                else
+                    let msubmname = msubname .'.'
+                endif
+                for mname in sort(keys(msubitems))
+                    let msname = msubmname . mname
+                    let handler = msubitems[mname]
+                    call s:BuildItem(msname, handler)
+                    " if has_key(handler, 'agent')
+                    "     call s:BuildItem(msname, {'agent': handler.agent})
+                    " else
+                    "     call s:BuildItem(msname, {'key': handler.key_name})
+                    " endif
+                endfor
+            endfor
+        endfor
+    endif
+endf
+
+
+function! s:BuildItem(menu, def) "{{{3
+    if has('gui_win32')
+        let key_mode = 'c'
+    elseif has('gui_gtk') || has('gui_gtk2')
+        let key_mode = 'raw'
+    endif
+    for k in ['agent', 'eval', 'key_name', 'key']
+        if has('gui_win32')
+        elseif has('gui_gtk') || has('gui_gtk')
+            if k == 'agent' || k == 'eval'
+                continue
+            endif
+        endif
+        try 
+            if has_key(a:def, k)
+                let v = a:def[k]
+                if k == 'key'
+                    if key_mode == 'c'
+                        " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "'. v .'"<cr>'
+                        exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "'. v .'"<cr>'
+                    else
+                        " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) v
+                        exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) v
+                    endif
+                elseif k == 'key_name'
+                    if key_mode == 'c'
+                        " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "\'. v .'"<cr>'
+                        exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "\'. v .'"<cr>'
+                    else
+                        let key = v
+                        " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) key
+                        exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) key
+                    endif
+                elseif k == 'agent'
+                    " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_agent ='. string(v) .'<cr>'
+                    exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_agent ='. string(v) .'<cr>'
+                elseif k == 'eval'
+                    " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_eval ='. string(v) .'<cr>'
+                    exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_eval ='. string(v) .'<cr>'
+                endif
+                return
+            endif
+        catch
+        endtry
+    endfor
+endf
+
+
+function! s:RunStateHandlers(world) "{{{3
+    " Provide the variable "world" in the environment of an "exec" 
+    " handler (ea).
+    let world = a:world
+    for handler in a:world.state_handlers
+        let eh = get(handler, 'state', '')
+        if !empty(eh) && a:world.state =~ eh
+            let ea = get(handler, 'exec', '')
+            if !empty(ea)
+                exec ea
+            else
+                let agent = get(handler, 'agent', '')
+                " let world = call(agent, [a:world, a:world.GetSelectedItems(a:world.CurrentItem())])
+                " call s:CheckAgentReturnValue(agent, a:world)
+                let world = s:CallAgent({'agent': agent}, world, world.GetSelectedItems(world.CurrentItem()))
+            endif
+        endif
+    endfor
+    return world
+endf
+
+
+function! s:CheckAgentReturnValue(name, value) "{{{3
+    if type(a:value) != 4 && !has_key(a:value, 'state')
+        echoerr 'Malformed agent: '. a:name
+    endif
+    return a:value
+endf
+
+
+function! s:SetOffset(world) "{{{3
+    let llenw = len(a:world.base) - winheight(0) + 1
+    if a:world.offset > llenw
+        let a:world.offset = llenw
+    endif
+    if a:world.offset < 1
+        let a:world.offset = 1
+    endif
+endf
+
+
+" Functions related to tlib#input#EditList(type, ...) "{{{2
+
+" :def: function! tlib#input#EditList(query, list, ?timeout=0)
+" Edit a list.
+"
+" EXAMPLES: >
+"   echo tlib#input#EditList('Edit:', [100,200,300])
+function! tlib#input#EditList(query, list, ...) "{{{3
+    let handlers = a:0 >= 1 && !empty(a:1) ? a:1 : g:tlib#input#handlers_EditList
+    let default  = a:0 >= 2 ? a:2 : []
+    let timeout  = a:0 >= 3 ? a:3 : 0
+    " TLogVAR handlers
+    let rv = tlib#input#List('me', a:query, copy(a:list), handlers, default, timeout)
+    " TLogVAR rv
+    if empty(rv)
+        return a:list
+    else
+        let [success, list] = rv
+        return success ? list : a:list
+    endif
+endf
+
+
+function! tlib#input#Resume(name, pick, bufnr) "{{{3
+    " TLogVAR a:name, a:pick
+    echo
+    if bufnr('%') != a:bufnr
+        if g:tlib#debug
+            echohl WarningMsg
+            echom "tlib#input#Resume: Internal error: Not in scratch buffer:" bufname('%')
+            echohl NONE
+        endif
+        let br = tlib#buffer#Set(a:bufnr)
+    endif
+    if !exists('b:tlib_'. a:name)
+        if g:tlib#debug
+            echohl WarningMsg
+            echom "tlib#input#Resume: Internal error: b:tlib_". a:name ." does not exist:" bufname('%')
+            echohl NONE
+            redir => varss
+            silent let b:
+            redir END
+            let vars = split(varss, '\n')
+            call filter(vars, 'v:val =~ "^b:tlib_"')
+            echom "DEBUG tlib#input#Resume" string(vars)
+        endif
+    else
+        call tlib#autocmdgroup#Init()
+        autocmd! TLib BufEnter <buffer>
+        if b:tlib_{a:name}.state =~ '\<suspend\>'
+            let b:tlib_{a:name}.state = 'redisplay'
+        else
+            let b:tlib_{a:name}.state .= ' redisplay'
+        endif
+        " call tlib#input#List('resume '. a:name)
+        let cmd = 'resume '. a:name
+        if a:pick >= 1
+            let cmd .= ' pick'
+            if a:pick >= 2
+                let cmd .= ' sticky'
+            end
+        endif
+        call tlib#input#ListW(b:tlib_{a:name}, cmd)
+    endif
+endf
+
+
+" :def: function! tlib#input#CommandSelect(command, ?keyargs={})
+" Take a command, view the output, and let the user select an item from 
+" its output.
+"
+" EXAMPLE: >
+"     command! TMarks exec 'norm! `'. matchstr(tlib#input#CommandSelect('marks'), '^ \+\zs.')
+"     command! TAbbrevs exec 'norm i'. matchstr(tlib#input#CommandSelect('abbrev'), '^\S\+\s\+\zs\S\+')
+function! tlib#input#CommandSelect(command, ...) "{{{3
+    TVarArg ['args', {}]
+    if has_key(args, 'retrieve')
+        let list = call(args.retrieve)
+    elseif has_key(args, 'list')
+        let list = args.list
+    else
+        let list = tlib#cmd#OutputAsList(a:command)
+    endif
+    if has_key(args, 'filter')
+        call map(list, args.filter)
+    endif
+    let type     = has_key(args, 'type') ? args.type : 's'
+    let handlers = has_key(args, 'handlers') ? args.handlers : []
+    let rv = tlib#input#List(type, 'Select', list, handlers)
+    if !empty(rv)
+        if has_key(args, 'process')
+            let rv = call(args.process, [rv])
+        endif
+    endif
+    return rv
+endf
+
+
+" :def: function! tlib#input#Edit(name, value, callback, ?cb_args=[])
+"
+" Edit a value (asynchronously) in a scratch buffer. Use name for 
+" identification. Call callback when done (or on cancel).
+" In the scratch buffer:
+" Press <c-s> or <c-w><cr> to enter the new value, <c-w>c to cancel 
+" editing.
+" EXAMPLES: >
+"   fun! FooContinue(success, text)
+"       if a:success
+"           let b:var = a:text
+"       endif
+"   endf
+"   call tlib#input#Edit('foo', b:var, 'FooContinue')
+function! tlib#input#Edit(name, value, callback, ...) "{{{3
+    " TLogVAR a:value
+    TVarArg ['args', []]
+    let sargs = {'scratch': '__EDIT__'. a:name .'__', 'win_wnr': winnr()}
+    let scr = tlib#scratch#UseScratch(sargs)
+
+    " :nodoc:
+    map <buffer> <c-w>c :call <SID>EditCallback(0)<cr>
+    " :nodoc:
+    imap <buffer> <c-w>c <c-o>call <SID>EditCallback(0)<cr>
+    " :nodoc:
+    map <buffer> <c-s> :call <SID>EditCallback(1)<cr>
+    " :nodoc:
+    imap <buffer> <c-s> <c-o>call <SID>EditCallback(1)<cr>
+    " :nodoc:
+    map <buffer> <c-w><cr> :call <SID>EditCallback(1)<cr>
+    " :nodoc:
+    imap <buffer> <c-w><cr> <c-o>call <SID>EditCallback(1)<cr>
+    
+    call tlib#normal#WithRegister('gg"tdG', 't')
+    call append(1, split(a:value, "\<c-j>", 1))
+    " let hrm = 'DON''T DELETE THIS HEADER'
+    " let hr3 = repeat('"', (tlib#win#Width(0) - len(hrm)) / 2)
+    let s:horizontal_line = repeat('`', tlib#win#Width(0))
+    " hr3.hrm.hr3
+    let hd  = ['Keys: <c-s>, <c-w><cr> ... save/accept; <c-w>c ... cancel', s:horizontal_line]
+    call append(1, hd)
+    call tlib#normal#WithRegister('gg"tdd', 't')
+    syntax match TlibEditComment /^\%1l.*/
+    syntax match TlibEditComment /^```.*/
+    hi link TlibEditComment Comment
+    exec len(hd) + 1
+    if type(a:callback) == 4
+        let b:tlib_scratch_edit_callback = get(a:callback, 'submit', '')
+        call call(get(a:callback, 'init', ''), [])
+    else
+        let b:tlib_scratch_edit_callback = a:callback
+    endif
+    let b:tlib_scratch_edit_args     = args
+    let b:tlib_scratch_edit_scratch  = sargs
+    " exec 'autocmd BufDelete,BufHidden,BufUnload <buffer> call s:EditCallback('. string(a:name) .')'
+    " echohl MoreMsg
+    " echom 'Press <c-s> to enter, <c-w>c to cancel editing.'
+    " echohl NONE
+endf
+
+
+function! s:EditCallback(...) "{{{3
+    TVarArg ['ok', -1]
+    " , ['bufnr', -1]
+    " autocmd! BufDelete,BufHidden,BufUnload <buffer>
+    if ok == -1
+        let ok = confirm('Use value')
+    endif
+    let start = getline(2) == s:horizontal_line ? 3 : 1
+    let text = ok ? join(getline(start, '$'), "\n") : ''
+    let cb   = b:tlib_scratch_edit_callback
+    let args = b:tlib_scratch_edit_args
+    let sargs = b:tlib_scratch_edit_scratch
+    " TLogVAR cb, args, sargs
+    call tlib#scratch#CloseScratch(b:tlib_scratch_edit_scratch)
+    call tlib#win#Set(sargs.win_wnr)
+    call call(cb, args + [ok, text])
+endf
+
+
+function! tlib#input#Dialog(text, options, default) "{{{3
+    if has('dialog_con') || has('dialog_gui')
+        let opts = join(map(a:options, '"&". v:val'), "\n")
+        let val = confirm(a:text, opts)
+        if val
+            let yn = a:options[val - 1]
+        else
+            let yn = a:default
+        endif
+    else
+        let oi = index(a:options, a:default)
+        if oi == -1
+            let opts = printf("(%s|%s)", join(a:options, '/'), a:default)
+        else
+            let options = copy(a:options)
+            let options[oi] = toupper(options[oi])
+            let opts = printf("(%s)", join(a:options, '/'))
+        endif
+        let yn = inputdialog(a:text .' '. opts)
+    endif
+    return yn
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/list.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/list.vim
new file mode 100755
index 0000000..a18f27f
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/list.vim
@@ -0,0 +1,194 @@
+" list.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2016-03-22.
+" @Revision:    68
+
+
+""" List related functions {{{1
+" For the following functions please see ../../test/tlib.vim for examples.
+
+" :def: function! tlib#list#Inject(list, initial_value, funcref)
+" EXAMPLES: >
+"   echo tlib#list#Inject([1,2,3], 0, function('Add')
+"   => 6
+function! tlib#list#Inject(list, value, Function) "{{{3
+    if empty(a:list)
+        return a:value
+    else
+        let item  = a:list[0]
+        let rest  = a:list[1:-1]
+        let value = call(a:Function, [a:value, item])
+        return tlib#list#Inject(rest, value, a:Function)
+    endif
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Compact([0,1,2,3,[], {}, ""])
+"   => [1,2,3]
+function! tlib#list#Compact(list) "{{{3
+    return filter(copy(a:list), '!empty(v:val)')
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Flatten([0,[1,2,[3,""]]])
+"   => [0,1,2,3,""]
+function! tlib#list#Flatten(list) "{{{3
+    let acc = []
+    for e in a:list
+        if type(e) == 3
+            let acc += tlib#list#Flatten(e)
+        else
+            call add(acc, e)
+        endif
+        unlet e
+    endfor
+    return acc
+endf
+
+
+" :def: function! tlib#list#FindAll(list, filter, ?process_expr="")
+" Basically the same as filter()
+"
+" EXAMPLES: >
+"   tlib#list#FindAll([1,2,3], 'v:val >= 2')
+"   => [2, 3]
+function! tlib#list#FindAll(list, filter, ...) "{{{3
+    let rv   = filter(copy(a:list), a:filter)
+    if a:0 >= 1 && a:1 != ''
+        let rv = map(rv, a:1)
+    endif
+    return rv
+endf
+
+
+" :def: function! tlib#list#Find(list, filter, ?default="", ?process_expr="")
+"
+" EXAMPLES: >
+"   tlib#list#Find([1,2,3], 'v:val >= 2')
+"   => 2
+function! tlib#list#Find(list, filter, ...) "{{{3
+    let default = a:0 >= 1 ? a:1 : ''
+    let expr    = a:0 >= 2 ? a:2 : ''
+    return get(tlib#list#FindAll(a:list, a:filter, expr), 0, default)
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Any([1,2,3], 'v:val >= 2')
+"   => 1
+function! tlib#list#Any(list, expr) "{{{3
+    return !empty(tlib#list#FindAll(a:list, a:expr))
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#All([1,2,3], 'v:val >= 2')
+"   => 0
+function! tlib#list#All(list, expr) "{{{3
+    return len(tlib#list#FindAll(a:list, a:expr)) == len(a:list)
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Remove([1,2,1,2], 2)
+"   => [1,1,2]
+function! tlib#list#Remove(list, element) "{{{3
+    let idx = index(a:list, a:element)
+    if idx != -1
+        call remove(a:list, idx)
+    endif
+    return a:list
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#RemoveAll([1,2,1,2], 2)
+"   => [1,1]
+function! tlib#list#RemoveAll(list, element) "{{{3
+    call filter(a:list, 'v:val != a:element')
+    return a:list
+endf
+
+
+" :def: function! tlib#list#Zip(lists, ?default='')
+" EXAMPLES: >
+"   tlib#list#Zip([[1,2,3], [4,5,6]])
+"   => [[1,4], [2,5], [3,6]]
+function! tlib#list#Zip(lists, ...) "{{{3
+    TVarArg 'default'
+    let lists = copy(a:lists)
+    let max   = 0
+    for l in lists
+        let ll = len(l)
+        if ll > max
+            let max = ll
+        endif
+    endfor
+    " TLogVAR default, max
+    return map(range(0, max - 1), 's:GetNthElement(v:val, lists, default)')
+endf
+
+function! s:GetNthElement(n, lists, default) "{{{3
+    " TLogVAR a:n, a:lists, a:default
+    return map(copy(a:lists), 'get(v:val, a:n, a:default)')
+endf
+
+
+function! tlib#list#Uniq(list, ...) "{{{3
+    " TLogVAR a:list
+    TVarArg ['get_value', ''], ['remove_empty', 0]
+    if remove_empty
+        call filter(a:list, 'type(v:val) == 0 || !empty(v:val)')
+    endif
+    " CREDITS: Based on syntastic#util#unique(list) by scrooloose
+    let emptystring = 0
+    let seen = {}
+    let uniques = []
+    if empty(get_value)
+        for e in a:list
+            if e == ''
+                if !emptystring
+                    let emptystring = 1
+                    call add(uniques, e)
+                endif
+            elseif !has_key(seen, e)
+                let seen[e] = 1
+                call add(uniques, e)
+            endif
+            unlet e
+        endfor
+    else
+        for e in a:list
+            let v = eval(printf(get_value, string(e)))
+            if v == ''
+                if !emptystring
+                    let emptystring = 1
+                    call add(uniques, v)
+                endif
+            elseif !has_key(seen, v)
+                let seen[v] = 1
+                call add(uniques, v)
+            endif
+            unlet e v
+        endfor
+    endif
+    return uniques
+endf
+
+
+function! tlib#list#ToDictionary(list, default, ...) "{{{3
+    TVarArg ['generator', '']
+    let dict = {}
+    for item in a:list
+        if !empty(item)
+            let dict[item] = empty(generator) ? a:default : call(generator, [item, a:default])
+        endif
+    endfor
+    return dict
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/loclist.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/loclist.vim
new file mode 100644
index 0000000..198dd1b
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/loclist.vim
@@ -0,0 +1,13 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2015-10-24
+" @Revision:    2
+
+
+function! tlib#loclist#Browse(...) abort "{{{3
+    let list = getloclist(0)
+    return call(function('tlib#qfl#QflList'), [list] + a:000)
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/map.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/map.vim
new file mode 100755
index 0000000..c1af13f
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/map.vim
@@ -0,0 +1,23 @@
+" map.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-08-23.
+" @Last Change: 2009-08-23.
+" @Revision:    0.0.4
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" If |pumvisible()| is true, return "\<c-y>". Otherwise return a:key.
+" For use in maps like: >
+"   imap <expr> <cr> tlib#map#PumAccept("\<cr>")
+function! tlib#map#PumAccept(key) "{{{3
+    return pumvisible() ? "\<c-y>" : a:key
+endf
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/normal.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/normal.vim
new file mode 100755
index 0000000..faaa444
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/normal.vim
@@ -0,0 +1,34 @@
+" normal.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-10-06.
+" @Last Change: 2010-09-22.
+" @Revision:    28
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :display: tlib#normal#WithRegister(cmd, ?register='t', ?norm_cmd='norm!')
+" Execute a normal command while maintaining all registers.
+function! tlib#normal#WithRegister(cmd, ...) "{{{3
+    TVarArg ['register', 't'], ['norm_cmd', 'norm!']
+    let registers = {}
+    for reg in split('123456789'. register, '\zs')
+        exec 'let registers[reg] = @'. reg
+    endfor
+    exec 'let reg = @'. register
+    try
+        exec norm_cmd .' '. a:cmd
+        exec 'return @'. register
+    finally
+        for [reg, value] in items(registers)
+            exec 'let @'. reg .' = value'
+        endfor
+    endtry
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/notify.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/notify.vim
new file mode 100755
index 0000000..541dbd0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/notify.vim
@@ -0,0 +1,113 @@
+" notify.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-09-19.
+" @Last Change: 2016-06-28.
+" @Revision:    2.3.19
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :display: tlib#notify#Echo(text, ?style='')
+" Print text in the echo area. Temporarily disable 'ruler' and 'showcmd' 
+" in order to prevent |press-enter| messages.
+function! tlib#notify#Echo(text, ...)
+    TVarArg 'style'
+    let ruler = &ruler
+    let showcmd = &showcmd
+    let text = substitute(a:text, '\n', '|', 'g')
+    try
+        set noruler
+        set noshowcmd
+        if !empty(style)
+            exec 'echohl' style
+        endif
+        echo strpart(text, 0, &columns - 1)
+    finally
+        if !empty(style)
+            echohl None
+        endif
+        let &ruler = ruler
+        let &showcmd = showcmd
+    endtry
+endf
+
+
+" Contributed by Erik Falor:
+" If the line containing the message is too long, echoing it will cause 
+" a 'Hit ENTER' prompt to appear.  This function cleans up the line so 
+" that does not happen.
+" The echoed line is too long if it is wider than the width of the 
+" window, minus cmdline space taken up by the ruler and showcmd 
+" features.
+function! tlib#notify#TrimMessage(message) "{{{3
+    let filler = '...'
+
+    " If length of message with tabs converted into spaces + length of 
+    " line number + 2 (for the ': ' that follows the line number) is 
+    " greater than the width of the screen, truncate in the middle
+    let to_fill = &columns
+    " TLogVAR to_fill
+
+    " Account for space used by elements in the command-line to avoid 
+    " 'Hit ENTER' prompts.
+    " If showcmd is on, it will take up 12 columns.
+    " If the ruler is enabled, but not displayed in the statusline, it 
+    " will in its default form take 17 columns.  If the user defines a 
+    " custom &rulerformat, they will need to specify how wide it is.
+    if has('cmdline_info')
+        if &showcmd
+            let to_fill -= 12
+        else
+            let to_fill -= 1
+        endif
+        " TLogVAR &showcmd, to_fill
+
+        " TLogVAR &laststatus, &ruler, &rulerformat
+        if &ruler
+            if &laststatus == 0 || winnr('$') == 1
+                if has('statusline')
+                    if &rulerformat == ''
+                        " default ruler is 17 chars wide
+                        let to_fill -= 17
+                    elseif exists('g:MP_rulerwidth')
+                        let to_fill -= g:MP_rulerwidth
+                    else
+                        " tml: fallback: guess length
+                        let to_fill -= strlen(&rulerformat)
+                    endif
+                else
+                endif
+            endif
+        else
+        endif
+    else
+        let to_fill -= 1
+    endif
+
+    " TLogVAR to_fill
+    " TLogDBG strlen(a:message)
+    if strlen(a:message) > to_fill
+        let front = to_fill / 2 - 1
+        let back  = front 
+        if to_fill % 2 == 0 | let back -= 1 | endif
+        return strpart(a:message, 0, front) . filler .
+                    \strpart(a:message, strlen(a:message) - back)
+    else
+        return a:message
+    endif
+endfunction
+
+
+function! tlib#notify#PrintError() abort "{{{3
+    echohl ErrorMsg
+    echom v:exception
+    echom v:throwpoint
+    echohl NONE
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/number.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/number.vim
new file mode 100644
index 0000000..94fde02
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/number.vim
@@ -0,0 +1,30 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    14
+
+
+function! tlib#number#ConvertBase(num, base, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'string'
+    " TLogVAR a:num, a:base, rtype
+    let rv = []
+    let num = 0.0 + a:num
+    while floor(num) > 0.0
+        let div = floor(num / a:base)
+        let num1 = float2nr(num - a:base * div)
+        if a:base <= 10
+            call insert(rv, num1)
+        elseif a:base == 16
+            let char = "0123456789ABCDEF"[num1]
+            call insert(rv, char)
+        endif
+        let num = num / a:base
+    endwh
+    " TLogVAR rv
+    if rtype == 'list'
+        return rv
+    else
+        return join(rv, '')
+    endif
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/paragraph.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/paragraph.vim
new file mode 100755
index 0000000..dd0d112
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/paragraph.vim
@@ -0,0 +1,97 @@
+" paragraph.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-10-26.
+" @Last Change: 2011-04-03.
+" @Revision:    62
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" Return an object describing a |paragraph|.
+function! tlib#paragraph#GetMetric() "{{{3
+    let sp = {'text_start': line("'{") + 1}
+    if line("'}") == line("$")
+        let sp.last = 1
+        let sp.text_end = line("'}")
+        if line("'{") == 1
+            let sp.ws_start = 0
+            let sp.ws_end = 0
+            let sp.top = sp.text_start
+            let sp.bottom = sp.text_end
+        else
+            let sp.ws_start = prevnonblank(line("'{")) + 1
+            let sp.ws_end = line("'{")
+            let sp.top = sp.ws_start
+            let sp.bottom = sp.text_end
+        endif
+    else
+        let sp.last = 0
+        let sp.text_end = line("'}") - 1
+        let sp.ws_start = line("'}")
+        for i in range(line("'}"), line('$'))
+            if getline(i) =~ '\w'
+                let sp.ws_end = i - 1
+                break
+            elseif i == line("$")
+                let sp.ws_end = i
+            endif
+        endfor
+        let sp.top = sp.text_start
+        let sp.bottom = sp.ws_end
+    endif
+    return sp
+endf
+
+
+" This function can be used with the tinymode plugin to move around 
+" paragraphs.
+"
+" Example configuration: >
+" 
+"   call tinymode#EnterMap("para_move", "gp")
+"   call tinymode#ModeMsg("para_move", "Move paragraph: j/k")
+"   call tinymode#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '[N]')")
+"   call tinymode#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '[N]')")
+"   call tinymode#ModeArg("para_move", "owncount", 1)
+function! tlib#paragraph#Move(direction, count)
+    " TLogVAR a:direction, a:count
+    let mycount = empty(a:count) ? 1 : a:count
+    for i in range(1, mycount)
+        let para = tlib#paragraph#GetMetric()
+        " TLogVAR para
+        let text = getline(para.text_start, para.text_end)
+        let ws = getline(para.ws_start, para.ws_end)
+        " TLogVAR text, ws
+        exec para.top .','. para.bottom .'delete'
+        if a:direction == "Down"
+            let other = tlib#paragraph#GetMetric()
+            let target = other.bottom + 1
+            if other.last
+                let lines = ws + text
+                let pos = target + len(ws)
+            else
+                let lines = text + ws
+                let pos = target
+            endif
+        elseif a:direction == "Up"
+            if !para.last
+                norm! {
+            endif
+            let other = tlib#paragraph#GetMetric()
+            let target = other.text_start
+            let lines = text + ws
+            let pos = target
+        endif
+        " TLogVAR other, target
+        " TLogVAR lines
+        call append(target - 1, lines)
+        exec pos
+    endfor
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/persistent.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/persistent.vim
new file mode 100644
index 0000000..de3d487
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/persistent.vim
@@ -0,0 +1,47 @@
+" persistent.vim -- Persistent data
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2012-05-11.
+" @Last Change: 2012-05-11.
+" @Revision:    12
+
+" The directory for persistent data files. If empty, use 
+" |tlib#dir#MyRuntime|.'/share'.
+TLet g:tlib_persistent = ''
+
+
+" :display: tlib#persistent#Dir(?mode = 'bg')
+" Return the full directory name for persistent data files.
+function! tlib#persistent#Dir() "{{{3
+    TVarArg ['mode', 'bg']
+    let dir = tlib#var#Get('tlib_persistent', mode)
+    if empty(dir)
+        let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'share'])
+    endif
+    return dir
+endf
+
+" :def: function! tlib#persistent#Filename(type, ?file=%, ?mkdir=0)
+function! tlib#persistent#Filename(type, ...) "{{{3
+    " TLogDBG 'bufname='. bufname('.')
+    let file = a:0 >= 1 ? a:1 : ''
+    let mkdir = a:0 >= 2 ? a:2 : 0
+    return tlib#cache#Filename(a:type, file, mkdir, tlib#persistent#Dir())
+endf
+
+function! tlib#persistent#Get(...) "{{{3
+    return call('tlib#cache#Get', a:000)
+endf
+
+function! tlib#persistent#MTime(cfile) "{{{3
+    return tlib#cache#MTime(a:cfile)
+endf
+
+function! tlib#persistent#Value(...) "{{{3
+    return call('tlib#cache#Value', a:000)
+endf
+
+function! tlib#persistent#Save(cfile, dictionary) "{{{3
+    call tlib#cache#Save(a:cfile, a:dictionary)
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/progressbar.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/progressbar.vim
new file mode 100755
index 0000000..e739eb3
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/progressbar.vim
@@ -0,0 +1,72 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    72
+
+let s:statusline = []
+let s:laststatus = []
+let s:max = []
+let s:format = []
+let s:width = []
+let s:value = []
+let s:timestamp = -1
+
+" EXAMPLE: >
+"     call tlib#progressbar#Init(20)
+"     try
+"         for i in range(20)
+"             call tlib#progressbar#Display(i)
+"             call DoSomethingThatTakesSomeTime(i)
+"         endfor
+"     finally
+"         call tlib#progressbar#Restore()
+"     endtry
+function! tlib#progressbar#Init(max, ...) "{{{3
+    TVarArg ['format', '%s'], ['width', 10]
+    call insert(s:statusline, &statusline)
+    call insert(s:laststatus, &laststatus)
+    call insert(s:max, a:max)
+    call insert(s:format, format)
+    call insert(s:width, width)
+    call insert(s:value, -1)
+    let &laststatus = 2
+    let s:timestamp = localtime()
+endf
+
+
+function! tlib#progressbar#Display(value, ...) "{{{3
+    TVarArg 'extra', ['always', 0]
+    let ts = localtime()
+    if !always && ts == s:timestamp
+        return
+    else
+        let s:timestamp = ts
+    endif
+    let val = a:value * s:width[0] / s:max[0]
+    if always || val != s:value[0]
+        let s:value[0] = val
+        let pbl = repeat('#', val)
+        let pbr = repeat('.', s:width[0] - val)
+        let txt = printf(s:format[0], '['.pbl.pbr.']') . extra
+        let &l:statusline = txt
+        " TLogDBG txt
+        redrawstatus
+        " redraw
+        " call tlib#notify#Echo(txt)
+    endif
+endf
+
+
+function! tlib#progressbar#Restore() "{{{3
+    let &l:statusline = remove(s:statusline, 0)
+    let &laststatus = remove(s:laststatus, 0)
+    redrawstatus
+    " redraw
+    " echo
+    call remove(s:max, 0)
+    call remove(s:format, 0)
+    call remove(s:width, 0)
+    call remove(s:value, 0)
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/qfl.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/qfl.vim
new file mode 100644
index 0000000..148620a
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/qfl.vim
@@ -0,0 +1,312 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2015-12-06
+" @Revision:    60
+
+" :nodoc:
+TLet g:tlib#qfl#world = {
+            \ 'type': 'mi',
+            \ 'query': 'Select entry',
+            \ 'pick_last_item': 0,
+            \ 'resize_vertical': 0,
+            \ 'resize': 20,
+            \ 'scratch': '__TLibQFL__',
+            \ 'tlib_UseInputListScratch': 'call tlib#qfl#InitListBuffer(world)',
+            \ 'key_handlers': [
+                \ {'key':  5, 'agent': 'tlib#qfl#AgentWithSelected', 'key_name': '<c-e>', 'help': 'Run a command on selected lines'},
+                \ {'key': 16, 'agent': 'tlib#qfl#AgentPreviewQFE',   'key_name': '<c-p>', 'help': 'Preview'},
+                \ {'key': 60, 'agent': 'tlib#qfl#AgentGotoQFE',      'key_name': '<',     'help': 'Jump (don''t close the list)'},
+                \ {'key': 19, 'agent': 'tlib#qfl#AgentSplitBuffer',  'key_name': '<c-s>', 'help': 'Show in split buffer'},
+                \ {'key': 20, 'agent': 'tlib#qfl#AgentTabBuffer',    'key_name': '<c-t>', 'help': 'Show in tab'},
+                \ {'key': 22, 'agent': 'tlib#qfl#AgentVSplitBuffer', 'key_name': '<c-v>', 'help': 'Show in vsplit buffer'},
+                \ {'key': 12, 'agent': 'tlib#qfl#AgentEditLine',     'key_name': '<c-l>', 'help': 'Edit selected line(s)'},
+                \ {'key': "\<c-insert>", 'agent': 'tlib#qfl#SetFollowCursor', 'key_name': '<c-ins>', 'help': 'Toggle trace cursor'},
+            \ ],
+            \ 'return_agent': 'tlib#qfl#AgentEditQFE',
+            \ }
+
+
+function! tlib#qfl#FormatQFLE(qfe) dict abort "{{{3
+    let filename = tlib#qfl#QfeFilename(a:qfe)
+    if get(self, 'qfl_short_filename', '')
+        let filename = pathshorten(filename)
+    endif
+    return printf("%s|%d| %s", filename, a:qfe.lnum, get(a:qfe, "text"))
+endf
+
+
+function! tlib#qfl#QfeFilename(qfe) abort "{{{3
+    let filename = get(a:qfe, 'filename')
+    if empty(filename)
+        let filename = bufname(get(a:qfe, 'bufnr'))
+    endif
+    return filename
+endf
+
+
+function! tlib#qfl#InitListBuffer(world) "{{{3
+    let set_syntax = get(a:world, 'set_syntax', 'tlib#qfl#SetSyntax')
+    call call(set_syntax, [], a:world)
+    if has('balloon_eval')
+        setlocal ballooneval balloonexpr=tlib#qfl#Balloon()
+    endif
+endf
+
+
+function! tlib#qfl#SetSyntax() dict abort "{{{3
+    let syntax = get(self, 'qfl_list_syntax', '')
+    let nextgroup = get(self, 'qfl_list_syntax_nextgroup', '')
+    " TLogVAR syntax, nextgroup
+    if !empty(syntax)
+        exec printf('runtime syntax/%s.vim', syntax)
+    endif
+    syn match TTagedFilesFilename /\%(\f\+\| \)\+\ze|\d\+| / nextgroup=TTagedFilesLNum
+    if !empty(nextgroup)
+        exec 'syn match TTagedFilesLNum /|\d\+|\s\+/ nextgroup='. nextgroup
+    else
+        syn match TTagedFilesLNum /|\d\+|/
+    endif
+    hi def link TTagedFilesFilename Directory
+    hi def link TTagedFilesLNum LineNr
+endf
+
+
+function! tlib#qfl#Balloon() "{{{3
+    let world = getbufvar(v:beval_bufnr, 'tlibDisplayListWorld')
+    let current = max([1, world.offset]) + v:beval_lnum - 1
+    if current > len(world.table)
+        let current = len(world.table)
+    endif
+    let baseidx = world.GetBaseIdx0(current)
+    " TLogVAR world.offset, v:beval_lnum, current, baseidx
+    let item = world.data[baseidx]
+    let bufnr = get(item, 'bufnr', 0)
+    let bufname = get(item, 'filename', '')
+    if bufnr == 0 && !empty(bufname)
+        let bufnr = bufnr(bufname)
+    endif
+    if empty(bufname) && bufnr > 0
+        let bufname = bufname(bufnr)
+    endif
+    " TLogVAR item
+    if bufnr == 0
+        return ''
+    else
+        let lines = [printf("%d#%d: %s", bufnr, item.lnum, bufname)]
+        if has('balloon_multiline')
+            let desc = {'nr': 'Error number', 'type': 'Error type', 'text': ''}
+            for key in ['nr', 'type', 'text']
+                if has_key(item, key) && !empty(item[key])
+                    let keydesc = get(desc, key, key)
+                    if empty(keydesc)
+                        let text = item[key]
+                    else
+                        let text = printf("%s: %s", key, item[key])
+                    endif
+                    call add(lines, text)
+                endif
+            endfor
+        endif
+        return join(lines, "\n")
+    endif
+    " v:beval_bufnr	number of the buffer in which balloon is going to show
+    " v:beval_winnr	number of the window
+    " v:beval_lnum	line number
+    " v:beval_col	column number (byte index)
+    " v:beval_text	word under or after the mouse pointer
+endf
+
+
+function! tlib#qfl#AgentEditQFE(world, selected, ...) "{{{3
+    TVarArg ['cmd_edit', ''], ['cmd_buffer', '']
+    " TVarArg ['cmd_edit', 'edit'], ['cmd_buffer', 'buffer']
+    " TLogVAR a:selected
+    if empty(a:selected)
+        call a:world.RestoreOrigin()
+        " call a:world.ResetSelected()
+    else
+        call a:world.RestoreOrigin()
+        for idx in a:selected
+            let idx -= 1
+            " TLogVAR idx
+            if idx >= 0
+                " TLogVAR a:world.data
+                " call tlog#Debug(string(map(copy(a:world.data), 'v:val.bufnr')))
+                " TLogVAR idx, a:world.data[idx]
+                let qfe = a:world.data[idx]
+                " let back = a:world.SwitchWindow('win')
+                " TLogVAR cmd_edit, cmd_buffer, qfe
+                let fn = tlib#qfl#QfeFilename(qfe)
+                " TLogVAR cmd_edit, cmd_buffer, fn
+                if empty(cmd_edit) && empty(cmd_buffer)
+                    if tlib#file#Edit(fn)
+                        call tlib#buffer#ViewLine(qfe.lnum)
+                    endif
+                else
+                    call tlib#file#With(cmd_edit, cmd_buffer, [fn], a:world)
+                    " TLogDBG bufname('%')
+                    " TLogVAR &filetype
+                    call tlib#buffer#ViewLine(qfe.lnum)
+                    " call a:world.SetOrigin()
+                    " exec back
+                endif
+            endif
+        endfor
+    endif
+    return a:world
+endf 
+
+
+function! tlib#qfl#AgentPreviewQFE(world, selected) "{{{3
+    " TLogVAR a:selected
+    let back = a:world.SwitchWindow('win')
+    call tlib#qfl#AgentEditQFE(a:world, a:selected[0:0])
+    exec back
+    redraw
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#qfl#AgentGotoQFE(world, selected) "{{{3
+    let world = a:world
+    if !empty(a:selected)
+        let world = tlib#agent#Suspend(world, a:selected)
+        call tlib#qfl#AgentEditQFE(world, a:selected[0:0])
+    endif
+    return world
+endf
+
+
+function! tlib#qfl#AgentWithSelected(world, selected, ...) "{{{3
+    let cmd = a:0 >= 1 ? a:1 : input('Ex command: ', '', 'command')
+    let world = a:world
+    if !empty(cmd)
+        let world = tlib#qfl#RunCmdOnSelected(world, a:selected, cmd)
+    else
+        let world.state = 'redisplay'
+    endif
+    return world
+endf
+
+
+function! tlib#qfl#RunCmdOnSelected(world, selected, cmd, ...) "{{{3
+    let close_scratch = a:0 >= 1 ? a:1 : 1
+    if close_scratch
+        call a:world.CloseScratch()
+    endif
+    " TLogVAR a:cmd
+    for entry in a:selected
+        " TLogVAR entry, a:world.GetBaseItem(entry)
+        call tlib#qfl#AgentEditQFE(a:world, [entry])
+        " TLogDBG bufname('%')
+        exec a:cmd
+        " let item = a:world.data[a:world.GetBaseIdx(entry - 1)]
+        " <+TODO+>
+        let item = a:world.data[entry - 1]
+        " TLogVAR entry, item, getline('.')
+        if has_key(a:world, 'GetBufferLines')
+            let lines = a:world.GetBufferLines('.', '.')
+        else
+            let lines = getline('.', '.')
+        endif
+        let item['text'] = tlib#string#Strip(lines[0])
+    endfor
+    if has_key(a:world, 'AfterRunCmd')
+        if bufnr('%') == a:world.bufnr
+            call a:world.AfterRunCmd()
+        else
+            " <+TODO+> Run in other buffer
+        endif
+    endif
+    " call s:FormatBase(a:world)
+    call a:world.RestoreOrigin()
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#qfl#AgentSplitBuffer(world, selected) "{{{3
+    call a:world.CloseScratch()
+    return tlib#qfl#AgentEditQFE(a:world, a:selected, 'split', 'sbuffer')
+endf
+
+
+function! tlib#qfl#AgentTabBuffer(world, selected) "{{{3
+    call a:world.CloseScratch()
+    return tlib#qfl#AgentEditQFE(a:world, a:selected, 'tabedit', 'tab sbuffer')
+endf
+
+
+function! tlib#qfl#AgentVSplitBuffer(world, selected) "{{{3
+    call a:world.CloseScratch()
+    return tlib#qfl#AgentEditQFE(a:world, a:selected, 'vertical split', 'vertical sbuffer')
+endf
+
+
+" function! tlib#qfl#AgentOpenBuffer(world, selected) "{{{3
+" endf
+
+
+function! tlib#qfl#AgentEditLine(world, selected) "{{{3
+    call a:world.CloseScratch()
+    let cmd = 'call tlib#qfl#EditLine(".")'
+    return tlib#qfl#RunCmdOnSelected(a:world, a:selected, cmd)
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#qfl#EditLine(lnum) "{{{3
+    call inputsave()
+    let line = input('', getline(a:lnum))
+    call inputrestore()
+    if !empty(line)
+        call setline(line(a:lnum), line)
+    endif
+endf
+
+
+function! tlib#qfl#SetFollowCursor(world, selected) "{{{3
+    if empty(a:world.follow_cursor)
+        let a:world.follow_cursor = 'tlib#qfl#AgentPreviewQFE'
+    else
+        let a:world.follow_cursor = ''
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#qfl#QflList(list, ...) abort "{{{3
+    TVarArg ['world_dict', {}], ['anyway', 0], ['suspended', 0]
+    Tlibtrace 'tlib', world_dict, anyway, suspended
+    " TLogVAR a:list, world_dict, anyway, suspended
+    if !anyway && empty(a:list)
+        return
+    endif
+    let world = copy(g:tlib#qfl#world)
+    if !empty(world_dict)
+        let world = tlib#eval#Extend(world, world_dict)
+    endif
+    " TLogVAR world
+    let world = tlib#World#New(world)
+    " echom "DBG world" string(sort(keys(world)))
+    let world.data  = copy(a:list)
+    if !has_key(world, 'format_data')
+        let world.format_data = 'tlib#qfl#FormatQFLE'
+    endif
+    " TLogVAR world
+    " TLogVAR world.data
+    " call s:FormatBase(world)
+    " TLogVAR world.base
+    return tlib#input#ListW(world, suspended ? 'hibernate' : '')
+endf
+
+
+function! tlib#qfl#Browse(...) abort "{{{3
+    let list = getqflist()
+    return call(function('tlib#qfl#QflList'), [list] + a:000)
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/rx.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/rx.vim
new file mode 100644
index 0000000..8389983
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/rx.vim
@@ -0,0 +1,60 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    113
+
+
+" :def: function! tlib#rx#Escape(text, ?magic='m')
+" magic can be one of: m, M, v, V
+" See :help 'magic'
+function! tlib#rx#Escape(text, ...) "{{{3
+    TVarArg 'magic'
+    if empty(magic)
+        let magic = 'm'
+    endif
+    if magic =~# '^\\\?m$'
+        return escape(a:text, '^$.*\[]~')
+    elseif magic =~# '^\\\?M$'
+        return escape(a:text, '^$\')
+    elseif magic =~# '^\\\?V$'
+        return escape(a:text, '\')
+    elseif magic =~# '^\\\?v$'
+        return substitute(a:text, '[^0-9a-zA-Z_]', '\\&', 'g')
+    else
+        echoerr 'tlib: Unsupported magic type'
+        return a:text
+    endif
+endf
+
+" :def: function! tlib#rx#EscapeReplace(text, ?magic='m')
+" Escape return |sub-replace-special|.
+function! tlib#rx#EscapeReplace(text, ...) "{{{3
+    TVarArg ['magic', 'm']
+    if magic ==# 'm' || magic ==# 'v'
+        return escape(a:text, '\&~')
+    elseif magic ==# 'M' || magic ==# 'V'
+        return escape(a:text, '\')
+    else
+        echoerr 'magic must be one of: m, v, M, V'
+    endif
+endf
+
+
+function! tlib#rx#Suffixes(...) "{{{3
+    TVarArg ['magic', 'm']
+    let sfx = split(&suffixes, ',')
+    call map(sfx, 'tlib#rx#Escape(v:val, magic)')
+    if magic ==# 'v'
+        return '('. join(sfx, '|') .')$'
+    elseif magic ==# 'V'
+        return '\('. join(sfx, '\|') .'\)\$'
+    else
+        return '\('. join(sfx, '\|') .'\)$'
+    endif
+endf
+
+
+function! tlib#rx#LooksLikeRegexp(text) abort "{{{3
+    return a:text =~ '[.?*+{}\[\]]'
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/scratch.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/scratch.vim
new file mode 100755
index 0000000..c9df64d
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/scratch.vim
@@ -0,0 +1,136 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    255
+
+
+" Scratch window position. By default the list window is opened on the 
+" bottom. Set this variable to 'topleft' or '' to change this behaviour.
+" See |tlib#input#List()|.
+TLet g:tlib_scratch_pos = 'botright'
+
+" If you want the scratch buffer to be fully removed, you might want to 
+" set this variable to 'wipe'.
+" See also https://github.com/tomtom/tlib_vim/pull/16
+TLet g:tlib#scratch#hidden = 'hide'
+
+
+" :def: function! tlib#scratch#UseScratch(?keyargs={})
+" Display a scratch buffer (a buffer with no file). See :TScratch for an 
+" example.
+" Return the scratch buffer's number.
+" Values for keyargs:
+"   scratch_split ... 1: split, 0: window, -1: tab
+function! tlib#scratch#UseScratch(...) "{{{3
+    exec tlib#arg#Let([['keyargs', {}]])
+    " TLogDBG string(keys(keyargs))
+    let id = get(keyargs, 'scratch', '__Scratch__')
+    " TLogVAR id, bufwinnr(id)
+    " TLogVAR bufnr(id), bufname(id)
+    " TLogVAR 1, winnr(), bufnr('%'), bufname("%")
+    if bufwinnr(id) != -1
+        " echom 'DBG noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
+        exec 'noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
+        " TLogVAR "reuse", bufnr("%"), bufname("%")
+    else
+        let winpos = ''
+        let bn = bufnr(id)
+        let wpos = get(keyargs, 'scratch_pos', g:tlib_scratch_pos)
+        " TLogVAR keyargs.scratch_vertical
+        if get(keyargs, 'scratch_vertical')
+            let wpos .= ' vertical'
+            let winpos = tlib#fixes#Winpos()
+        endif
+        " TLogVAR wpos
+        let scratch_split = get(keyargs, 'scratch_split', 1)
+        if bn != -1
+            " TLogVAR bn
+            let wn = bufwinnr(bn)
+            if wn != -1
+                " TLogVAR wn
+                exec 'noautocmd keepalt keepj' (wn .'wincmd w')
+            else
+                if scratch_split == 1
+                    let cmd = wpos.' sbuffer!'
+                elseif scratch_split == -1
+                    let cmd = wpos.' tab sbuffer!'
+                else
+                    let cmd = 'buffer!'
+                endif
+                " TLogVAR cmd, bn
+                silent exec 'noautocmd keepalt keepj' cmd bn
+            endif
+        else
+            " TLogVAR id
+            if scratch_split == 1
+                let cmd = wpos.' split'
+            elseif scratch_split == -1
+                let cmd = wpos.' tab split'
+            else
+                let cmd = 'edit'
+            endif
+            " TLogVAR cmd, id
+            silent exec 'noautocmd keepalt keepj' cmd escape(id, '%#\ ')
+            " silent exec 'split '. id
+        endif
+        let ft = get(keyargs, 'scratch_filetype', '')
+        " TLogVAR ft, winpos
+        if !empty(winpos)
+            exec winpos
+        endif
+        setlocal buftype=nofile
+        let &l:bufhidden = get(keyargs, 'scratch_hidden', g:tlib#scratch#hidden)
+        setlocal noswapfile
+        setlocal nobuflisted
+        setlocal foldmethod=manual
+        setlocal foldcolumn=0
+        setlocal nospell
+        setlocal modifiable
+        setlocal noreadonly
+        " TLogVAR &ft, ft
+        if !empty(ft)
+            let &l:ft = ft
+        endif
+    endif
+    let keyargs.scratch = bufnr('%')
+    let keyargs.scratch_tabpagenr = tabpagenr()
+    let keyargs.scratch_winnr = winnr()
+    " TLogVAR 2, winnr(), bufnr('%'), bufname("%"), keyargs.scratch
+    return keyargs.scratch
+endf
+
+
+" Close a scratch buffer as defined in keyargs (usually a World).
+" Return 1 if the scratch buffer is closed (or if it already was 
+" closed).
+function! tlib#scratch#CloseScratch(keyargs, ...) "{{{3
+    TVarArg ['reset_scratch', 1]
+    let scratch = get(a:keyargs, 'scratch', '')
+    " TLogVAR scratch, reset_scratch
+    " TLogDBG string(tlib#win#List())
+    if !empty(scratch) && winnr('$') > 1
+        let wn = bufwinnr(scratch)
+        " TLogVAR wn
+        try
+            if wn != -1
+                " TLogDBG winnr()
+                let wb = tlib#win#Set(wn)
+                let winpos = tlib#fixes#Winpos()
+                wincmd c
+                if get(a:keyargs, 'scratch_vertical') && !empty(winpos)
+                    exec winpos
+                endif
+                " exec wb 
+                " redraw
+                " TLogVAR winnr()
+            endif
+            return 1
+        finally
+            if reset_scratch
+                let a:keyargs.scratch = ''
+            endif
+        endtry
+    endif
+    return 0
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/selection.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/selection.vim
new file mode 100644
index 0000000..4417157
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/selection.vim
@@ -0,0 +1,40 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2016-01-03
+" @Revision:    3
+
+
+" :display: tlib#selection#GetSelection(mode, ?mbeg="'<", ?mend="'>", ?opmode='selection')
+" mode can be one of: selection, lines, block
+function! tlib#selection#GetSelection(mode, ...) range "{{{3
+    if a:0 >= 2
+        let mbeg = a:1
+        let mend = a:2
+    else
+        let mbeg = "'<"
+        let mend = "'>"
+    endif
+    let opmode = a:0 >= 3 ? a:3 : 'selection'
+    let l0   = line(mbeg)
+    let l1   = line(mend)
+    let text = getline(l0, l1)
+    let c0   = col(mbeg)
+    let c1   = col(mend)
+    " TLogVAR mbeg, mend, opmode, l0, l1, c0, c1
+    " TLogVAR text[-1]
+    " TLogVAR len(text[-1])
+    if opmode == 'block'
+        let clen = c1 - c0
+        call map(text, 'strpart(v:val, c0, clen)')
+    elseif opmode == 'selection'
+        if c1 > 1
+            let text[-1] = strpart(text[-1], 0, c1 - (a:mode == 'o' || c1 > len(text[-1]) ? 0 : 1))
+        endif
+        if c0 > 1
+            let text[0] = strpart(text[0], c0 - 1)
+        endif
+    endif
+    return text
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/signs.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/signs.vim
new file mode 100755
index 0000000..1664680
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/signs.vim
@@ -0,0 +1,103 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-03-12.
+" @Last Change: 2011-03-10.
+" @Revision:    0.0.45
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+let s:base = 2327
+let s:register = {}
+
+
+" Clear all signs with name SIGN.
+function! tlib#signs#ClearAll(sign) "{{{3
+    " TLog a:sign
+    for bn in keys(s:register)
+        let idxs = keys(s:register)
+        call filter(idxs, 's:register[v:val].sign == a:sign')
+        " TLogVAR bns
+        for idx in idxs
+            exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
+            call remove(s:register, idx)
+        endfor
+    endfor
+endf
+
+
+" Clear all signs with name SIGN in buffer BUFNR.
+function! tlib#signs#ClearBuffer(sign, bufnr) "{{{3
+    for bn in keys(s:register)
+        let idxs = keys(s:register)
+        call filter(idxs, 's:register[v:val].sign == a:sign && s:register[v:val].bn == a:bufnr')
+        " TLogVAR bns
+        for idx in idxs
+            exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
+            call remove(s:register, idx)
+        endfor
+    endfor
+endf
+
+
+" function! tlib#signs#Clear(sign, list) "{{{3
+"     " TLogVAR a:sign
+"     let done = []
+"     for item in a:list
+"         let bn = get(item, 'bufnr', -1)
+"         if index(done, bn) == -1
+"             let idxs = keys(s:register)
+"             call filter(idxs, 's:register[v:val].sign == a:sign && s:register[v:val].bn == bn')
+"             for idx in idxs
+"                 exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
+"                 call remove(s:register, idx)
+"             endfor
+"             call add(done, bn)
+"         endif
+"     endfor
+" endf
+
+
+" Add signs for all locations in LIST. LIST must adhere with the 
+" quickfix list format (see |getqflist()|; only the fields lnum and 
+" bufnr are required).
+"
+" list:: a quickfix or location list
+" sign:: a sign defined with |:sign-define|
+function! tlib#signs#Mark(sign, list) "{{{3
+    " TLogVAR a:sign
+    for item in a:list
+        let idx = s:SignId(item)
+        if idx >= 0
+            let lnum = get(item, 'lnum', 0)
+            if lnum > 0
+                let bn = get(item, 'bufnr')
+                exec ':sign place '. idx .' line='. lnum .' name='. a:sign .' buffer='. bn
+                let s:register[idx] = {'sign': a:sign, 'bn': bn}
+            endif
+        endif
+    endfor
+endf
+
+
+function! s:SignId(item) "{{{3
+    " TLogVAR a:item
+    " let bn  = bufnr('%')
+    let bn = get(a:item, 'bufnr', -1)
+    if bn == -1
+        return -1
+    else
+        let idx = s:base + bn * 500
+        while has_key(s:register, idx)
+            let idx += 1
+        endwh
+        return idx
+    endif
+endf
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/string.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/string.vim
new file mode 100755
index 0000000..6ba9d60
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/string.vim
@@ -0,0 +1,194 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    142
+
+
+" :def: function! tlib#string#RemoveBackslashes(text, ?chars=' ')
+" Remove backslashes from text (but only in front of the characters in 
+" chars).
+function! tlib#string#RemoveBackslashes(text, ...) "{{{3
+    exec tlib#arg#Get(1, 'chars', ' ')
+    " TLogVAR chars
+    let rv = substitute(a:text, '\\\(['. chars .']\)', '\1', 'g')
+    return rv
+endf
+
+
+" :display: tlib#string#Chomp(string, ?max=0)
+function! tlib#string#Chomp(string, ...) "{{{3
+    let quant = a:0 >= 1 ? '\{,'. a:1 .'}' : '\+'
+    return substitute(a:string, '[[:cntrl:][:space:]]'. quant .'$', '', '')
+endf
+
+
+" Format a template string. Placeholders have the format "%{NAME}". A 
+" "%" can be inserted as "%%".
+"
+" Examples:
+"   echo tlib#string#Format("foo %{bar} foo", {'bar': 123})
+"   => foo 123 foo
+function! tlib#string#Format(template, dict) "{{{3
+    let parts = split(a:template, '\ze%\({.\{-}}\|.\)')
+    let out = []
+    for part in parts
+        let ml   = matchlist(part, '^%\({\(.\{-}\)}\|\(.\)\)\(.*\)$')
+        if empty(ml)
+            let rest = part
+        else
+            let var  = empty(ml[2]) ? ml[3] : ml[2]
+            let rest = ml[4]
+            if has_key(a:dict, var)
+                call add(out, a:dict[var])
+            elseif var == '%%'
+                call add(out, '%')
+            else
+                call add(out, ml[1])
+            endif
+        endif
+        call add(out, rest)
+    endfor
+    return join(out, '')
+endf
+
+
+" This function deviates from |printf()| in certain ways.
+" Additional items:
+"     %{rx}      ... insert escaped regexp
+"     %{fuzzyrx} ... insert typo-tolerant regexp
+function! tlib#string#Printf1(format, string) "{{{3
+    let s = split(a:format, '%.\zs')
+    " TLogVAR s
+    return join(map(s, 's:PrintFormat(v:val, a:string)'), '')
+endf
+
+function! s:PrintFormat(format, string) "{{{3
+    let cut = match(a:format, '%\({.\{-}}\|.\)$')
+    if cut == -1
+        return a:format
+    else
+        let head = cut > 0 ? a:format[0 : cut - 1] : ''
+        let tail = a:format[cut : -1]
+        " TLogVAR head, tail
+        if tail == '%{fuzzyrx}'
+            let frx = []
+            for i in range(len(a:string))
+                if i > 0
+                    let pb = i - 1
+                else
+                    let pb = 0
+                endif
+                let slice = tlib#rx#Escape(a:string[pb : i + 1])
+                call add(frx, '['. slice .']')
+                call add(frx, '.\?')
+            endfor
+            let tail = join(frx, '')
+        elseif tail == '%{rx}'
+            let tail = tlib#rx#Escape(a:string)
+        elseif tail == '%%'
+            let tail = '%'
+        elseif tail == '%s'
+            let tail = a:string
+        endif
+        " TLogVAR tail
+        return head . tail
+    endif
+endf
+" function! tlib#string#Printf1(format, string) "{{{3
+"     let n = len(split(a:format, '%\@<!%s', 1)) - 1
+"     let f = a:format
+"     if f =~ '%\@<!%{fuzzyrx}'
+"         let frx = []
+"         for i in range(len(a:string))
+"             if i > 0
+"                 let pb = i - 1
+"             else
+"                 let pb = 0
+"             endif
+"             let slice = tlib#rx#Escape(a:string[pb : i + 1])
+"             call add(frx, '['. slice .']')
+"             call add(frx, '.\?')
+"         endfor
+"         let f = s:RewriteFormatString(f, '%{fuzzyrx}', join(frx, ''))
+"     endif
+"     if f =~ '%\@<!%{rx}'
+"         let f = s:RewriteFormatString(f, '%{rx}', tlib#rx#Escape(a:string))
+"     endif
+"     if n == 0
+"         return substitute(f, '%%', '%', 'g')
+"     else
+"         let a = repeat([a:string], n)
+"         return call('printf', insert(a, f))
+"     endif
+" endf
+
+
+function! s:RewriteFormatString(format, pattern, string) "{{{3
+    let string = substitute(a:string, '%', '%%', 'g')
+    return substitute(a:format, tlib#rx#Escape(a:pattern), escape(string, '\'), 'g')
+endf
+
+
+function! tlib#string#TrimLeft(string) "{{{3
+    return substitute(a:string, '^[[:space:][:cntrl:]]\+', '', '')
+endf
+
+
+function! tlib#string#TrimRight(string) "{{{3
+    return substitute(a:string, '[[:space:][:cntrl:]]\+$', '', '')
+endf
+
+
+function! tlib#string#Strip(string) "{{{3
+    return tlib#string#TrimRight(tlib#string#TrimLeft(a:string))
+endf
+
+
+function! tlib#string#Count(string, rx) "{{{3
+    let s:count = 0
+    call substitute(a:string, a:rx, '\=s:CountHelper()', 'g')
+    return s:count
+endf
+
+function! s:CountHelper() "{{{3
+    let s:count += 1
+endf
+
+
+function! tlib#string#SplitCommaList(text, ...) abort "{{{3
+    let sep = a:0 >= 1 ? a:1 : ',\s*'
+    let parts = split(a:text, '\\\@<!\zs'. sep)
+    let parts = map(parts, 'substitute(v:val, ''\\\(.\)'', ''\1'', ''g'')')
+    return parts
+endf
+
+
+function! tlib#string#Input(...) abort "{{{3
+    TVarArg ['text', ''], ['completion', '']
+    call inputsave()
+    let rv = call(function('input'), a:000)
+    call inputrestore()
+    return rv
+endf
+
+
+" :display: tlib#string#MatchAll(string, sep_regexp, ?item_regexp='') abort
+function! tlib#string#MatchAll(string, regexp, ...) abort "{{{3
+    let eregexp = a:0 >= 1 ? a:1 : ''
+    Tlibtrace 'tlib', a:string, a:regexp, eregexp
+    let ms = []
+    if a:regexp =~ '\\ze'
+        let regexp1 = substitute(a:regexp, '\\ze.*$', '', '')
+    else
+        let regexp1 = a:regexp
+    endif
+    for m in split(a:string, '\ze'. regexp1)
+        let m1 = matchstr(m, !empty(eregexp) ? eregexp : a:regexp)
+        Tlibtrace 'tlib', m, m1
+        if !empty(m1)
+            call add(ms, m1)
+        endif
+    endfor
+    return ms
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/syntax.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/syntax.vim
new file mode 100755
index 0000000..aa30b66
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/syntax.vim
@@ -0,0 +1,38 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    13
+
+
+function! tlib#syntax#Collect() "{{{3
+    let acc = {}
+    let syn = ''
+    for line in tlib#cmd#OutputAsList('syntax')
+        if line =~ '^---'
+            continue
+        elseif line =~ '^\w'
+            let ml = matchlist(line, '^\(\w\+\)\s\+\(xxx\s\+\(.*\)\|\(cluster.*\)\)$')
+            if empty(ml)
+                " echoerr 'Internal error: '. string(line)
+            else
+                let [m_0, syn, m_1, m_def1, m_def2; m_rest] = ml
+                let acc[syn] = [empty(m_def1) ? m_def2 : m_def1]
+            endif
+        else
+            call add(acc[syn], matchstr(line, '^\s\+\zs.*$'))
+        endif
+    endfor
+    return acc
+endf
+
+
+" :def: function! tlib#syntax#Names(?rx='')
+function! tlib#syntax#Names(...) "{{{3
+    TVarArg 'rx'
+    let names = keys(tlib#syntax#Collect())
+    if !empty(rx)
+        call filter(names, 'v:val =~ rx')
+    endif
+    return names
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/sys.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/sys.vim
new file mode 100644
index 0000000..0ed24f0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/sys.vim
@@ -0,0 +1,212 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2015-12-12.
+" @Revision:    59
+
+
+if !exists('g:tlib#sys#special_protocols')
+    " A list of |regexp|s matching protocol names that should be handled 
+    " by |g:tlib#sys#system_browser|.
+    " CAVEAT: Must be a |\V| |regexp|.
+    let g:tlib#sys#special_protocols = ['https\?', 'nntp', 'mailto']   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#special_suffixes')
+    " A list of |regexp|s matching suffixes that should be handled by 
+    " |g:tlib#sys#system_browser|.
+    " CAVEAT: Must be a |\V| |regexp|.
+    let g:tlib#sys#special_suffixes = ['xlsx\?', 'docx\?', 'pptx\?', 'accdb', 'mdb', 'sqlite', 'pdf', 'jpg', 'png', 'gif', 'od\[tspg]']    "{{{2
+endif
+
+
+if !exists('g:tlib#sys#system_rx')
+    " Open links matching this |regexp| with |g:tlib#sys#system_browser|.
+    " CAVEAT: Must be a |\V| |regexp|.
+    let g:tlib#sys#system_rx = printf('\V\%(\^\%(%s\):\|.\%(%s\)\$\)', join(g:tlib#sys#special_protocols, '\|'), join(g:tlib#sys#special_suffixes, '\|'))   "{{{2
+endif
+
+
+if !exists("g:tlib#sys#system_browser")
+    if exists('g:netrw_browsex_viewer')
+        " Open files in the system browser.
+        " :read: let g:tlib#sys#system_browser = ... "{{{2
+        let g:tlib#sys#system_browser = "exec 'silent !'. g:netrw_browsex_viewer shellescape('%s')"
+    elseif has("win32") || has("win16") || has("win64")
+        " let g:tlib#sys#system_browser = "exec 'silent ! start \"\"' shellescape('%s')"
+        let g:tlib#sys#system_browser = "exec 'silent ! RunDll32.EXE URL.DLL,FileProtocolHandler' shellescape('%s')"
+    elseif has("mac")
+        let g:tlib#sys#system_browser = "exec 'silent !open' shellescape('%s')"
+    elseif exists('$XDG_CURRENT_DESKTOP') && !empty($XDG_CURRENT_DESKTOP)
+        let g:tlib#sys#system_browser = "exec 'silent !xdg-open' shellescape('%s') '&'"
+    elseif $GNOME_DESKTOP_SESSION_ID != "" || $DESKTOP_SESSION == 'gnome'
+        let g:tlib#sys#system_browser = "exec 'silent !gnome-open' shellescape('%s')"
+    elseif exists("$KDEDIR") && !empty($KDEDIR)
+        let g:tlib#sys#system_browser = "exec 'silent !kfmclient exec' shellescape('%s')"
+    else
+        let g:tlib#sys#system_browser = ''
+    endif
+endif
+
+
+if !exists('g:tlib#sys#windows')
+    let g:tlib#sys#windows = &shell !~ 'sh' && (has('win16') || has('win32') || has('win64'))   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#null')
+    let g:tlib#sys#null = g:tlib#sys#windows ? 'NUL' : (filereadable('/dev/null') ? '/dev/null' : '')    "{{{2
+endif
+
+
+let s:cygwin = {}
+
+function! tlib#sys#IsCygwinBin(cmd) "{{{3
+    " TLogVAR a:cmd
+    if !g:tlib#sys#windows
+        return 0
+    elseif has_key(s:cygwin, a:cmd)
+        let rv = s:cygwin[a:cmd]
+    else
+        if !tlib#sys#IsExecutable('cygpath', 1) || !tlib#sys#IsExecutable('which', 1)
+            let rv = 0
+        else
+            let which = substitute(system('which '. shellescape(a:cmd)), '\n$', '', '')
+            " echom "DBG which:" which
+            if which =~ '^/'
+                let filename = system('cygpath -ma '. shellescape(which))
+                " echom "DBG filename:" filename
+                let rv = filename =~ g:tlib#sys#cygwin_path_rx
+            else
+                let rv = 0
+            endif
+        endif
+        let s:cygwin[a:cmd] = rv
+    endif
+    " TLogVAR rv
+    return rv
+endf
+
+
+let s:executables = {}
+
+function! tlib#sys#IsExecutable(cmd, ...) "{{{3
+    " TLogVAR a:cmd
+    " echom "DBG has_key(s:executables, a:cmd)" has_key(s:executables, a:cmd)
+    if !has_key(s:executables, a:cmd)
+        let executable = executable(a:cmd)
+        " TLogVAR 1, executable
+        let ignore_cyg = a:0 >= 1 ? a:1 : !g:tlib#sys#windows
+        if !executable && !ignore_cyg
+            let executable = tlib#sys#IsCygwinBin(a:cmd)
+            " TLogVAR 2, executable
+        endif
+        let s:executables[a:cmd] = executable
+    endif
+    " echom "DBG s:executables[a:cmd]" s:executables[a:cmd]
+    return s:executables[a:cmd]
+endf
+
+
+if !exists('g:tlib#sys#check_cygpath')
+    " If true, check whether we have to convert a path via cyppath -- 
+    " see |tlib#sys#MaybeUseCygpath|
+    let g:tlib#sys#check_cygpath = g:tlib#sys#windows && tlib#sys#IsExecutable('cygpath', 1)   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#cygwin_path_rx')
+    " If a full windows filename (with slashes instead of backslashes) 
+    " matches this |regexp|, it is assumed to be a cygwin executable.
+    let g:tlib#sys#cygwin_path_rx = '/cygwin/'   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#cygwin_expr')
+    " For cygwin binaries, convert command calls using this vim 
+    " expression.
+    let g:tlib#sys#cygwin_expr = '"bash -c ''". escape(%s, "''\\") ."''"'   "{{{2
+endif
+
+
+function! tlib#sys#GetCmd(cmd) "{{{3
+    if !empty(g:tlib#sys#cygwin_expr) && tlib#sys#IsCygwinBin(matchstr(a:cmd, '^\S\+'))
+        let cmd = eval(printf(g:tlib#sys#cygwin_expr, string(a:cmd)))
+        " TLogVAR cmd
+        return cmd
+    else
+        return a:cmd
+    endif
+endf
+
+
+" If cmd seems to be a cygwin executable, use cygpath to convert 
+" filenames. This assumes that cygwin's which command returns full 
+" filenames for non-cygwin executables.
+function! tlib#sys#MaybeUseCygpath(cmd) "{{{3
+    " echom "DBG" a:cmd
+    if g:tlib#sys#check_cygpath && tlib#sys#IsCygwinBin(a:cmd)
+        return 'cygpath -u "%s"'
+    endif
+    return ''
+endf
+
+
+function! tlib#sys#ConvertPath(converter, filename) "{{{3
+    return tlib#string#Chomp(system(printf(a:converter, shellescape(a:filename))))
+endf
+
+
+let s:native_filenames = {}
+
+function! tlib#sys#FileArgs(cmd, files) "{{{3
+    let cygpath = tlib#sys#MaybeUseCygpath(a:cmd)
+    " TLogVAR cygpath
+    if empty(cygpath)
+        return a:files
+    else
+        let files = map(copy(a:files), 'has_key(s:native_filenames, v:val) ? s:native_filenames[v:val] : tlib#sys#CygPath(v:val)')
+        return files
+    endif
+endf
+
+
+" Check whether filename matches |g:tlib#sys#system_rx|, i.e. whether it 
+" is a special file that should not be opened in vim.
+function! tlib#sys#IsSpecial(filename) abort "{{{3
+    return a:filename =~ g:tlib#sys#system_rx
+endf
+
+
+" Open filename with the default OS application (see 
+" |g:tlib#sys#system_browser|), if |tlib#sys#IsSpecial()| return 1. 
+" Returns 1 if successful or 0 otherwise.
+function! tlib#sys#Open(filename) abort "{{{3
+    Tlibtrace 'tlib', a:filename
+    if !empty(g:tlib#sys#system_browser) && tlib#sys#IsSpecial(a:filename)
+        try
+            let cmd = printf(g:tlib#sys#system_browser, a:filename)
+            " let cmd = printf(g:tlib#sys#system_browser, escape(a:filename, ' %#!'))
+            Tlibtrace 'tlib', cmd
+            exec cmd
+            return 1
+        catch
+            echohl ErrorMsg
+            echom v:exception
+            echohl NONE
+        endtry
+    endif
+    return 0
+endf
+
+
+" :def: function! tlib#sys#SystemInDir(dir, expr, ?input='')
+function! tlib#sys#SystemInDir(dir, ...) abort "{{{3
+    call tlib#dir#CD(a:dir)
+    try
+        return call(function('system'), a:000)
+    finally
+        silent cd! -
+    endtry
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/tab.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/tab.vim
new file mode 100755
index 0000000..fa6bb8d
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/tab.vim
@@ -0,0 +1,49 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    31
+
+
+" Return a dictionary of bufnumbers => [[tabpage, winnr] ...]
+function! tlib#tab#BufMap() "{{{3
+    let acc = {}
+    for t in range(tabpagenr('$'))
+        let bb = tabpagebuflist(t + 1)
+        for b in range(len(bb))
+            let bn = bb[b]
+            let bd = [t + 1, b + 1]
+            if has_key(acc, bn)
+                call add(acc[bn], bd)
+            else
+                let acc[bn] = [bd]
+            endif
+        endfor
+    endfor
+    return acc
+endf
+
+
+" Find a buffer's window at some tab page.
+function! tlib#tab#TabWinNr(buffer) "{{{3
+    let bn = bufnr(a:buffer)
+    let bt = tlib#tab#BufMap()
+    let tn = tabpagenr()
+    let wn = winnr()
+    let bc = get(bt, bn)
+    if !empty(bc)
+        for [t, w] in bc
+            if t == tn
+                return [t, w]
+            endif
+        endfor
+        return bc[0]
+    endif
+endf
+
+
+function! tlib#tab#Set(tabnr) "{{{3
+    if a:tabnr > 0
+        exec a:tabnr .'tabnext'
+    endif
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/tag.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/tag.vim
new file mode 100755
index 0000000..e4239d3
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/tag.vim
@@ -0,0 +1,132 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    59
+
+
+" Extra tags for |tlib#tag#Retrieve()| (see there). Can also be buffer-local.
+TLet g:tlib_tags_extra = ''
+
+" Filter the tag description through |substitute()| for these filetypes. 
+" This applies only if the tag cmd field (see |taglist()|) is used.
+" :nodefault:
+TLet g:tlib_tag_substitute = {
+            \ 'java': [['\s*{\s*$', '', '']],
+            \ 'ruby': [['\<\(def\|class\|module\)\>\s\+', '', '']],
+            \ 'vim':  [
+            \   ['^\s*com\%[mand]!\?\(\s\+-\S\+\)*\s*\u\w*\zs.*$', '', ''],
+            \   ['^\s*\(let\|aug\%[roup]\|fu\%[nction]!\?\|com\%[mand]!\?\(\s\+-\S\+\)*\)\s*', '', ''],
+            \   ['"\?\s*{{{\d.*$', '', ''],
+            \ ],
+            \ }
+
+
+" :def: function! tlib#tag#Retrieve(rx, ?extra_tags=0)
+" Get all tags matching rx. Basically, this function simply calls 
+" |taglist()|, but when extra_tags is true, the list of the tag files 
+" (see 'tags') is temporarily expanded with |g:tlib_tags_extra|.
+"
+" Example use:
+" If you want to include tags for, eg, JDK, normal tags use can become 
+" slow. You could proceed as follows:
+"     1. Create a tags file for the JDK sources. When creating the tags 
+"     file, make sure to include inheritance information and the like 
+"     (command-line options like --fields=+iaSm --extra=+q should be ok).
+"     In this example, we want tags only for public methods (there are 
+"     most likely better ways to do this): >
+"          ctags -R --fields=+iaSm --extra=+q ${JAVA_HOME}/src
+"          head -n 6 tags > tags0
+"          grep access:public tags >> tags0
+" <    2. Make 'tags' include project specific tags files. In 
+"      ~/vimfiles/after/ftplugin/java.vim insert: >
+"          let b:tlib_tags_extra = $JAVA_HOME .'/tags0'
+" <    3. When this function is invoked as >
+"          echo tlib#tag#Retrieve('print')
+" <    it will return only project-local tags. If it is invoked as >
+"          echo tlib#tag#Retrieve('print', 1)
+" <    tags from the JDK will be included.
+function! tlib#tag#Retrieve(rx, ...) "{{{3
+    TVarArg ['extra_tags', 0]
+    " TLogVAR a:rx, extra_tags
+    if extra_tags
+        let tags_orig = &l:tags
+        if empty(tags_orig)
+            setlocal tags<
+        endif
+        try
+            let more_tags = tlib#var#Get('tlib_tags_extra', 'bg')
+            if !empty(more_tags)
+                let &l:tags .= ','. more_tags
+            endif
+            let taglist = taglist(a:rx)
+        finally
+            let &l:tags = tags_orig
+        endtry
+    else
+        let taglist = taglist(a:rx)
+    endif
+    return taglist
+endf
+
+
+" Retrieve tags that meet the constraints (a dictionnary of fields and 
+" regexp, with the exception of the kind field which is a list of chars). 
+" For the use of the optional use_extra argument see 
+" |tlib#tag#Retrieve()|.
+" :def: function! tlib#tag#Collect(constraints, ?use_extra=1, ?match_front=1)
+function! tlib#tag#Collect(constraints, ...) "{{{3
+    TVarArg ['use_extra', 0], ['match_end', 1], ['match_front', 1]
+    " TLogVAR a:constraints, use_extra
+    let rx = get(a:constraints, 'name', '')
+    if empty(rx) || rx == '*'
+        let rx = '.'
+    else
+        let rxl = ['\C']
+        if match_front
+            call add(rxl, '^')
+        endif
+        " call add(rxl, tlib#rx#Escape(rx))
+        call add(rxl, rx)
+        if match_end
+            call add(rxl, '$')
+        endif
+        let rx = join(rxl, '')
+    endif
+    " TLogVAR rx, use_extra
+    let tags = tlib#tag#Retrieve(rx, use_extra)
+    " TLogDBG len(tags)
+    for [field, rx] in items(a:constraints)
+        if !empty(rx) && rx != '*'
+            " TLogVAR field, rx
+            if field == 'kind'
+                call filter(tags, 'v:val.kind =~ "['. rx .']"')
+            elseif field != 'name'
+                call filter(tags, '!empty(get(v:val, field)) && get(v:val, field) =~ rx')
+            endif
+        endif
+    endfor
+    " TLogVAR tags
+    return tags
+endf
+
+
+function! tlib#tag#Format(tag) "{{{3
+    if has_key(a:tag, 'signature')
+        let name = a:tag.name . a:tag.signature
+    elseif a:tag.cmd[0] == '/'
+        let name = a:tag.cmd
+        let name = substitute(name, '^/\^\?\s*', '', '')
+        let name = substitute(name, '\s*\$\?/$', '', '')
+        let name = substitute(name, '\s\{2,}', ' ', 'g')
+        let tsub = tlib#var#Get('tlib_tag_substitute', 'bg')
+        if has_key(tsub, &filetype)
+            for [rx, rplc, sub] in tsub[&filetype]
+                let name = substitute(name, rx, rplc, sub)
+            endfor
+        endif
+    else
+        let name = a:tag.name
+    endif
+    return name
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/textobjects.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/textobjects.vim
new file mode 100755
index 0000000..fb4170e
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/textobjects.vim
@@ -0,0 +1,45 @@
+" textobjects.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-01-09.
+" @Last Change: 2010-01-10.
+" @Revision:    0.0.29
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :tag: standard-paragraph
+" Select a "Standard Paragraph", i.e. a text block followed by blank 
+" lines. Other than |ap|, the last paragraph in a document is handled 
+" just the same.
+"
+" The |text-object| can be accessed as "sp". Example: >
+"
+"   vsp ... select the current standard paragraph
+"
+" Return 1, if the paragraph is the last one in the document.
+function! tlib#textobjects#StandardParagraph() "{{{3
+    if line("'}") == line('$')
+        norm! vip
+        return 1
+    else
+        norm! vap
+        return 0
+    endif
+endf
+
+
+function! tlib#textobjects#Init() "{{{3
+    if !exists('s:tlib_done_textobjects')
+        " sp ... Standard paragraph (for use as |text-objects|).
+        vnoremap <silent> sp <Esc>:call tlib#textobjects#StandardParagraph()<CR>
+        onoremap <silent> sp :<C-u>normal Vsp<CR>
+        let s:tlib_done_textobjects = 1
+    endif
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/time.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/time.vim
new file mode 100755
index 0000000..2273d55
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/time.vim
@@ -0,0 +1,67 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    36
+
+
+function! tlib#time#MSecs() "{{{3
+    let rts = reltimestr(reltime())
+    return substitute(rts, '\.', '', '')
+endf
+
+
+function! tlib#time#Now() "{{{3
+    if has('reltime')
+        let rts = reltimestr(reltime())
+        let rtl = map(split(rts, '\.'), 'str2nr(v:val)')
+    else
+        let rtl = [localtime()]
+    endif
+    return rtl
+endf
+
+
+function! tlib#time#FormatNow() "{{{3
+    let rtl = tlib#time#Now()
+    if len(rtl) == 2
+        let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0]) .'.'. rtl[1]
+    else
+        let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0])
+    endif
+    return rts
+endf
+
+
+function! tlib#time#Diff(a, b, ...) "{{{3
+    TVarArg ['resolution', 2]
+    let [as, am] = a:a
+    let [bs, bm] = a:b
+    let rv = 0 + (as - bs)
+    if resolution > 0
+        let rv .= repeat('0', resolution)
+        let am = am[0 : resolution - 1]
+        let bm = bm[0 : resolution - 1]
+        let rv += (am - bm)
+    endif
+    return rv
+endf
+
+
+function! tlib#time#DiffMSecs(a, b, ...) "{{{3
+    TVarArg ['resolution', 2]
+    if a:a == a:b
+        return 0
+    endif
+    let a = printf('%30s', a:a[0 : -(7 - resolution)])
+    let b = printf('%30s', a:b[0 : -(7 - resolution)])
+    for i in range(0, 29)
+        if a[i] != b[i]
+            let a = a[i : -1]
+            let b = b[i : -1]
+            return a - b
+        endif
+    endfor
+    return 0
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/trace.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/trace.vim
new file mode 100644
index 0000000..0eacfd2
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/trace.vim
@@ -0,0 +1,160 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2016-07-28
+" @Revision:    178
+
+
+if !exists('g:tlib#trace#backtrace')
+    " The length of the backtrace that should be included in 
+    " |tlib#trace#Print()|.
+    let g:tlib#trace#backtrace = 2   "{{{2
+endif
+
+
+if !exists('g:tlib#trace#printer')
+    " Possible values:
+    "   - 'echom'
+    "   - ['file', FILENAME]
+    let g:tlib#trace#printer = 'echom'   "{{{2
+endif
+
+
+if !exists('g:tlib#trace#hl')
+    let g:tlib#trace#hl = {'error': 'ErrorMsg', 'fatal': 'ErrorMsg', 'warn': 'WarningMsg'}   "{{{2
+endif
+
+
+" Print traces from |tlib#trace#Print()|.
+function! tlib#trace#Printer_echom(type, text, args) abort "{{{3
+    let hl = get(g:tlib#trace#hl, a:type, '')
+    try
+        if !empty(hl)
+            exec 'echohl' hl
+        endif
+        echom a:text
+    finally
+        if !empty(hl)
+            echohl NONE
+        endif
+    endtry
+endf
+
+
+function! tlib#trace#Printer_file(type, text, args) abort "{{{3
+    let filename = get(a:args, 0, '')
+    if !filewritable(filename)
+        throw 'tlib#trace#Printer_file: Cannot write to file: '. filename
+    else
+        call writefile([a:text], filename, 'a')
+    endif
+endf
+
+
+" Set the tracing |regexp|. See |:Tlibtrace|.
+" This will also call |tlib#trace#Enable()|.
+"
+" Examples:
+"   call tlib#trace#Set(["+foo", "-bar"])
+"   call tlib#trace#Set("+foo,-bar")
+function! tlib#trace#Set(vars) abort "{{{3
+    call tlib#trace#Enable()
+    if type(a:vars) == 1
+        let vars = tlib#string#SplitCommaList(a:vars, '[,[:space:]]\+')
+    else
+        let vars = a:vars
+    endif
+    " TLogVAR vars
+    for rx in vars
+        let rx1 = substitute(rx, '^[+-]', '', 'g')
+        if rx1 !~# '^\%(error\|warn\|fatal\)$'
+            let erx1 = tlib#rx#Escape(rx1)
+            " TLogVAR rx, rx1
+            " echom "DBG" s:trace_rx
+            if rx =~ '^-'
+                if s:trace_rx =~# '[(|]'. erx1 .'\\'
+                    let s:trace_rx = substitute(s:trace_rx, '\\|'. erx1, '', '')
+                endif
+                " elseif rx =~ '^+'
+            else
+                if s:trace_rx !~# '[(|]'. erx1 .'\\'
+                    let s:trace_rx = substitute(s:trace_rx, '\ze\\)\$', '\\|'. erx1, '')
+                endif
+                " else
+                "     echohl WarningMsg
+                "     echom 'tlib#trace#Print: Unsupported syntax:' rx
+                "     echohl NONE
+            endif
+            " echom "DBG" s:trace_rx
+        endif
+    endfor
+    echom "SetTrace:" s:trace_rx
+endf
+
+
+function! tlib#trace#Backtrace(caller) abort "{{{3
+    let caller = split(a:caller, '\.\.')
+    let start  = max([0, len(caller) - g:tlib#trace#backtrace - 1])
+    let caller = caller[start : -1]
+    return join(caller, '..')
+endf
+
+
+" Print the values of vars. The first value is a "guard" (see 
+" |:Tlibtrace|).
+function! tlib#trace#Print(caller, vars, values) abort "{{{3
+    let msg = ['TRACE']
+    let guard = a:values[0]
+    if type(guard) == 0
+        let cond = guard
+    else
+        let cond = guard =~# s:trace_rx
+    endif
+    " TLogVAR guard, cond, a:vars, a:values
+    if cond
+        call add(msg, guard)
+        call add(msg, tlib#time#FormatNow() .':')
+        if g:tlib#trace#backtrace > 0
+            let bt = tlib#trace#Backtrace(a:caller)
+            if !empty(bt)
+                call add(msg, bt .':')
+            endif
+        endif
+        for i in range(1, len(a:vars) - 1)
+            let v = substitute(a:vars[i], ',$', '', '')
+            let r = a:values[i]
+            if v =~# '^\([''"]\).\{-}\1$'
+                call add(msg, r .';')
+            else
+                call add(msg, v .'='. string(r) .';')
+            endif
+            unlet r
+        endfor
+        if type(g:tlib#trace#printer) == 1
+            let printer = g:tlib#trace#printer
+            let args = []
+        else
+            let [printer; args] = g:tlib#trace#printer
+        endif
+        call tlib#trace#Printer_{printer}(guard, join(msg), args)
+    endif
+endf
+
+
+" Enable tracing via |:Tlibtrace|.
+function! tlib#trace#Enable() abort "{{{3
+    if !exists('s:trace_rx')
+        let s:trace_rx = '^\%(error\|fatal\|warn\|info\)$'
+        " :nodoc:
+        command! -nargs=+ -bang Tlibtrace call tlib#trace#Print(expand('<sfile>'), [<f-args>], [<args>])
+    endif
+endf
+
+
+" Disable tracing via |:Tlibtrace|.
+function! tlib#trace#Disable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ -bang Tlibtrace :
+    unlet! s:trace_rx
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/type.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/type.vim
new file mode 100755
index 0000000..d3e5526
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/type.vim
@@ -0,0 +1,134 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-09-30.
+" @Last Change: 2016-07-13.
+" @Revision:    48
+
+
+let g:tlib#type#nil = []
+
+
+" Enable type assertiona via |:Tlibtype|.
+function! tlib#type#Enable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ Tlibtype call tlib#type#Check(expand('<sfile>'), [<f-args>], [<args>])
+endf
+
+
+" Disable type assertiona via |:Tlibtype|.
+function! tlib#type#Disable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ Tlibtype :
+endf
+
+
+function! tlib#type#IsNil(expr) abort "{{{3
+    return a:expr is g:tlib#type#nil
+endf
+
+
+function! tlib#type#IsNumber(expr)
+    return tlib#type#Is(a:expr, 0)
+endf
+
+
+function! tlib#type#IsString(expr)
+    return tlib#type#Is(a:expr, 1)
+endf
+
+
+function! tlib#type#IsFuncref(expr)
+    return tlib#type#Is(a:expr, 2)
+endf
+
+
+function! tlib#type#IsList(expr)
+    return tlib#type#Is(a:expr, 3)
+endf
+
+
+function! tlib#type#IsDictionary(expr)
+    return tlib#type#Is(a:expr, 4)
+endf
+
+
+function! tlib#type#Is(val, type) abort "{{{3
+    if has_key(s:schemas, a:type)
+        return tlib#type#Has(a:val, a:type)
+    else
+        if type(a:type) == 0
+            let type = a:type
+        elseif a:type =~? '^n\%[umber]$'
+            let type = 0
+        elseif a:type =~? '^s\%[tring]$'
+            let type = 1
+        elseif a:type =~? '^fu\%[ncref]$'
+            let type = 2
+        elseif a:type =~? '^l\%[ist]$'
+            let type = 3
+        elseif a:type =~? '^d\%[ictionary]$'
+            let type = 4
+        elseif a:type =~? '^fl\%[oat]$'
+            let type = 5
+        else
+            throw 'tlib#type#Is: Unknown type: ' a:type
+        endif
+        " TLogVAR a:val, a:type, type, type(a:val), type(a:val) == a:type
+        return type(a:val) == type
+    endif
+endf
+
+
+function! tlib#type#Are(vals, type) abort "{{{3
+    return tlib#assert#Map(a:vals, 'tlib#type#Is(v:val,'. string(a:type) .')')
+endf
+
+
+let s:schemas = {}
+
+
+function! tlib#type#Define(name, schema) abort "{{{3
+    let s:schemas[a:name] = deepcopy(a:schema)
+endf
+
+
+function! tlib#type#Has(val, schema) abort "{{{3
+    " TLogVAR type(a:val), type(a:schema)
+    if !tlib#type#IsDictionary(a:val)
+        " TLogVAR 'not a dictionary', a:val
+        return 0
+    endif
+    if tlib#type#IsString(a:schema)
+        " TLogVAR a:schema
+        let schema = copy(s:schemas[a:schema])
+    else
+        let schema = copy(a:schema)
+    endif
+    if tlib#type#IsDictionary(schema)
+        return tlib#assert#All(map(schema, 'has_key(a:val, v:key) && tlib#type#Is(a:val[v:key], v:val)'))
+    else
+        " TLogVAR keys(a:val), schema
+        return tlib#assert#All(map(schema, 'has_key(a:val, v:val)'))
+    endif
+endf
+
+
+function! tlib#type#Have(vals, schema) abort "{{{3
+    return tlib#assert#Map(a:vals, 'tlib#type#Has(v:val,'. string(a:schema) .')')
+endf
+
+
+function! tlib#type#Check(caller, names, vals) abort "{{{3
+    " TLogVAR a:names, a:vals, len(a:names)
+    for i in range(0, len(a:names) - 1, 2)
+        let val = a:vals[i]
+        let type = a:vals[i + 1]
+        " TLogVAR i, val, type
+        if !tlib#type#Is(val, type)
+            let name = matchstr(a:names[i], '^''\zs.\{-}\ze'',\?$')
+            throw 'tlib#type#Check: Type mismatch: '. name .':'. a:vals[i + 1]
+        endif
+    endfor
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/url.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/url.vim
new file mode 100755
index 0000000..b948d48
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/url.vim
@@ -0,0 +1,52 @@
+" url.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2011-03-10.
+" @Revision:    0.0.28
+
+
+" TODO: These functions could use printf() now.
+
+" Decode an encoded URL.
+function! tlib#url#Decode(url) "{{{3
+    return substitute(a:url, '\(+\|%\(%\|\x\x\)\)', '\=tlib#url#DecodeChar(submatch(1))', 'g')
+endf
+
+
+" Decode a single character.
+function! tlib#url#DecodeChar(char) "{{{3
+    if a:char == '%%'
+        return '%'
+    elseif a:char == '+'
+        return ' '
+    else
+        return nr2char("0x".a:char[1 : -1])
+    endif
+endf
+
+
+" Encode a single character.
+function! tlib#url#EncodeChar(char) "{{{3
+    if a:char == '%'
+        return '%%'
+    elseif a:char == ' '
+        return '+'
+    else
+        return printf("%%%X", char2nr(a:char))
+    endif
+endf
+
+
+" Encode an URL.
+function! tlib#url#Encode(url, ...) "{{{3
+    TVarArg ['extrachars', '']
+    let rx = '\([^a-zA-Z0-9_.'. extrachars .'-]\)'
+    " TLogVAR a:url, rx
+    let rv = substitute(a:url, rx, '\=tlib#url#EncodeChar(submatch(1))', 'g')
+    " TLogVAR rv
+    return rv
+endf
+
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/var.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/var.vim
new file mode 100755
index 0000000..dcd9264
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/var.vim
@@ -0,0 +1,83 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    30
+
+
+" Define a variable called NAME if yet undefined.
+" You can also use the :TLLet command.
+"
+" EXAMPLES: >
+"   exec tlib#var#Let('g:foo', 1)
+"   TLet g:foo = 1
+function! tlib#var#Let(name, val) "{{{3
+    return printf('if !exists(%s) | let %s = %s | endif', string(a:name), a:name, string(a:val))
+    " return printf('if !exists(%s) | let %s = %s | endif', string(a:name), a:name, a:val)
+endf
+
+
+" :def: function! tlib#var#EGet(var, namespace, ?default='')
+" Retrieve a variable by searching several namespaces.
+"
+" EXAMPLES: >
+"   let g:foo = 1
+"   let b:foo = 2
+"   let w:foo = 3
+"   echo eval(tlib#var#EGet('foo', 'vg'))  => 1
+"   echo eval(tlib#var#EGet('foo', 'bg'))  => 2
+"   echo eval(tlib#var#EGet('foo', 'wbg')) => 3
+function! tlib#var#EGet(var, namespace, ...) "{{{3
+    let pre  = []
+    let post = []
+    for namespace in split(a:namespace, '\zs')
+        let var = namespace .':'. a:var
+        call add(pre,  printf('exists("%s") ? %s : (', var, var))
+        call add(post, ')')
+    endfor
+    let default = a:0 >= 1 ? a:1 : ''
+    return join(pre) . string(default) . join(post)
+endf
+
+
+" :def: function! tlib#var#Get(var, namespace, ?default='')
+" Retrieve a variable by searching several namespaces.
+"
+" EXAMPLES: >
+"   let g:foo = 1
+"   let b:foo = 2
+"   let w:foo = 3
+"   echo tlib#var#Get('foo', 'bg')  => 1
+"   echo tlib#var#Get('foo', 'bg')  => 2
+"   echo tlib#var#Get('foo', 'wbg') => 3
+function! tlib#var#Get(var, namespace, ...) "{{{3
+    let var_ = substitute(a:var, '#', '_', 'g')
+    for namespace in split(a:namespace, '\zs')
+        let vname = namespace == 'g' ? a:var : var_
+        let var = namespace .':'. vname
+        if exists(var)
+            return {var}
+        endif
+    endfor
+    return a:0 >= 1 ? a:1 : ''
+endf
+
+
+" :def: function! tlib#var#List(rx, ?prefix='')
+" Get a list of variables matching rx.
+" EXAMPLE:
+"   echo tlib#var#List('tlib_', 'g:')
+function! tlib#var#List(rx, ...) "{{{3
+    TVarArg ['prefix', 'g:']
+    if v:version >= 704
+        exec 'let varlist = keys('. prefix .')'
+    else
+        redir => vars
+        silent! exec 'let '. prefix
+        redir END
+        let varlist = split(vars, '\n')
+        call map(varlist, 'matchstr(v:val, ''^\S\+'')')
+    endif
+    call filter(varlist, 'v:val =~ a:rx')
+    return varlist
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/vcs.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/vcs.vim
new file mode 100644
index 0000000..15d051f
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/vcs.vim
@@ -0,0 +1,189 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2012-03-08.
+" @Last Change: 2015-11-07.
+" @Revision:    190
+
+scriptencoding utf-8
+
+
+" A dictionarie of supported VCS (currently: git, hg, svn, bzr).
+" :display: g:tlib#vcs#def                 {...}
+TLet g:tlib#vcs#def = {
+            \ 'git': {
+            \     'dir': '.git',
+            \     'ls': 'git ls-files --full-name',
+            \     'ls.postprocess': '*tlib#vcs#GitLsPostprocess',
+            \     'diff': 'git diff --no-ext-diff -U0 %s'
+            \ },
+            \ 'hg': {
+            \     'dir': '.hg',
+            \     'diff': 'hg diff -U0 %s',
+            \     'ls': 'hg manifest'
+            \ },
+            \ 'svn': {
+            \     'dir': '.svn',
+            \     'diff': 'svn diff --diff-cmd diff --extensions -U0 %s',
+            \ },
+            \ 'bzr': {
+            \     'dir': '.bzr',
+            \     'diff': 'bzr diff --diff-options=-U0 %s',
+            \ }
+            \ }
+
+
+" A dictionary of custom executables for VCS commands. If the value is 
+" empty, support for that VCS will be removed. If no key is present, it 
+" is assumed that the VCS "type" is the name of the executable.
+" :display: g:tlib#vcs#executables         {...}
+TLet g:tlib#vcs#executables = {} 
+
+
+" If non-empty, use it as a format string to check whether a VCS is 
+" installed on your computer.
+TLet g:tlib#vcs#check = has('win16') || has('win32') || has('win64') ? '%s.exe' : '%s'
+
+
+if !empty(g:tlib#vcs#check)
+    for [s:cmd, s:def] in items(g:tlib#vcs#def)
+        if !has_key(g:tlib#vcs#executables, s:cmd)
+            let s:cmd1 = printf(g:tlib#vcs#check, s:cmd)
+            let g:tlib#vcs#executables[s:cmd] = executable(s:cmd1) ? s:cmd1 : ''
+        endif
+    endfor
+    unlet! s:cmd s:def s:cmd1
+endif
+
+
+function! tlib#vcs#Executable(type) "{{{3
+    return get(g:tlib#vcs#executables, a:type, '')
+endf
+
+
+function! tlib#vcs#FindVCS(filename) "{{{3
+    let type = ''
+    let dir  = ''
+    let dirname = fnamemodify(a:filename, isdirectory(a:filename) ? ':p' : ':p:h')
+    let path = escape(dirname, ';') .';'
+    " TLogVAR a:filename, dirname, path
+    Tlibtrace 'tlib', a:filename, path
+    let depth = -1
+    for vcs in keys(g:tlib#vcs#def)
+        let subdir = g:tlib#vcs#def[vcs].dir
+        let vcsdir = finddir(subdir, path)
+        " TLogVAR vcs, subdir, vcsdir
+        Tlibtrace 'tlib', vcs, subdir, vcsdir
+        if !empty(vcsdir)
+            let vcsdir_depth = len(split(fnamemodify(vcsdir, ':p'), '\/'))
+            if vcsdir_depth > depth
+                let depth = vcsdir_depth
+                let type = vcs
+                let dir = vcsdir
+                " TLogVAR type, depth
+            endif
+        endif
+    endfor
+    Tlibtrace 'tlib', type, dir
+    " TLogVAR type, dir
+    if empty(type)
+        return ['', '']
+    else
+        return [type, dir]
+    endif
+endf
+
+
+function! s:GetCmd(vcstype, cmd)
+    let vcsdef = get(g:tlib#vcs#def, a:vcstype, {})
+    if has_key(vcsdef, a:cmd)
+        let cmd = vcsdef[a:cmd]
+        if cmd =~ '^\*'
+            let cmd = substitute(cmd, '^\*', '', '')
+        else
+            let bin = get(g:tlib#vcs#executables, a:vcstype, '')
+            if empty(bin)
+                let cmd = ''
+            elseif bin != a:vcstype
+                " let bin = escape(shellescape(bin), '\')
+                let bin = escape(bin, '\')
+                let cmd = substitute(cmd, '^.\{-}\zs'. escape(a:vcstype, '\'), bin, '')
+            endif
+        endif
+        return cmd
+    else
+        return ''
+    endif
+endf
+
+
+" :display: tlib#vcs#Ls(?filename=bufname('%'), ?vcs=[type, dir])
+" Return the files under VCS.
+function! tlib#vcs#Ls(...) "{{{3
+    if a:0 >= 2
+        let vcs = a:2
+    else
+        let vcs = tlib#vcs#FindVCS(a:0 >= 1 ? a:1 : bufname('%'))
+    endif
+    Tlibtrace 'tlib', vcs, a:000
+    " TLogVAR vcs
+    if !empty(vcs)
+        let [vcstype, vcsdir] = vcs
+        if has_key(g:tlib#vcs#def, vcstype)
+            let ls = s:GetCmd(vcstype, 'ls')
+            " TLogVAR ls
+            if !empty(ls)
+                let rootdir = fnamemodify(vcsdir, ':p:h:h')
+                " TLogVAR vcsdir, rootdir
+                if ls =~ '%s'
+                    let cmd = printf(ls, shellescape(rootdir))
+                else
+                    let cmd = ls
+                endif
+                " TLogVAR cmd, getcwd()
+                Tlibtrace 'tlib', getcwd(), vcstype, vcsdir, rootdir, cmd
+                let filess = tlib#sys#SystemInDir(rootdir, cmd)
+                " TLogVAR filess
+                let files = split(filess, '\n')
+                let postprocess = s:GetCmd(vcstype, 'ls.postprocess')
+                if !empty(postprocess)
+                    call map(files, 'call(postprocess, [v:val])')
+                endif
+                call map(files, 'join([rootdir, v:val], "/")')
+                " TLogVAR files
+                return files
+            endif
+        endif
+    endif
+    return []
+endf
+
+
+" :display: tlib#vcs#Diff(filename, ?vcs=[type, dir])
+" Return the diff for "filename"
+function! tlib#vcs#Diff(filename, ...) "{{{3
+    let vcs = a:0 >= 1 ? a:1 : tlib#vcs#FindVCS(a:filename)
+    if !empty(vcs)
+        let [vcstype, vcsdir] = vcs
+        let diff = s:GetCmd(vcstype, 'diff')
+        if !empty(diff)
+            let cmd = printf(diff, shellescape(fnamemodify(a:filename, ':p')))
+            let patch = system(cmd)
+            return patch
+        endif
+    endif
+    return []
+endf
+
+
+function! tlib#vcs#GitLsPostprocess(filename) abort "{{{3
+    if a:filename =~ '^".\{-}"$'
+        let filename = matchstr(a:filename, '^"\zs.\{-}\ze"$')
+        let filename = substitute(filename, '\%(\\\@<!\\\(\d\d\d\)\)\+', '\=eval(''"''. submatch(0) .''"'')', 'g')
+        " let filename = eval(a:filename)
+        " TLogVAR a:filename, filename, &enc
+        return filename
+    else
+        return a:filename
+    endif
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/vim.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/vim.vim
new file mode 100644
index 0000000..7154aeb
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/vim.vim
@@ -0,0 +1,152 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/tlib_vim/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-07-19.
+" @Last Change: 2012-06-08.
+" @Revision:    37
+
+
+let s:restoreframecmd = ''
+let s:fullscreen = 0
+
+if has('win16') || has('win32') || has('win64')
+
+    if !exists('g:tlib#vim#simalt_maximize')
+        " The alt-key for maximizing the window.
+        " CAUTION: The value of this paramter depends on your locale and 
+        " maybe the windows version you are running.
+        let g:tlib#vim#simalt_maximize = 'x'   "{{{2
+    endif
+
+    if !exists('g:tlib#vim#simalt_restore')
+        " The alt-key for restoring the window.
+        " CAUTION: The value of this paramter depends on your locale and 
+        " maybe the windows version you are running.
+        let g:tlib#vim#simalt_restore = 'r'   "{{{2
+    endif
+
+    if !exists('g:tlib#vim#use_vimtweak')
+        " If true, use the vimtweak.dll for windows. This will enable 
+        " tlib to remove the caption for fullscreen windows.
+        let g:tlib#vim#use_vimtweak = 0   "{{{2
+    endif
+
+    " Maximize the window.
+    " You might need to redefine |g:tlib#vim#simalt_maximize| if it doesn't 
+    " work for you.
+    fun! tlib#vim#Maximize(fullscreen) "{{{3
+        if !has("gui_running")
+            return
+        endif
+        call s:SaveFrameParams()
+        let s:fullscreen = a:fullscreen
+        if g:tlib#vim#use_vimtweak && a:fullscreen
+            call libcallnr("vimtweak.dll", "EnableCaption", 0)
+        endif
+        exec 'simalt ~'. g:tlib#vim#simalt_maximize
+    endf
+
+    " Restore the original vimsize after having called |tlib#vim#Maximize()|.
+    function! tlib#vim#RestoreWindow() "{{{3
+        if !has("gui_running")
+            return
+        endif
+        if g:tlib#vim#use_vimtweak
+            call libcallnr("vimtweak.dll", "EnableCaption", 1)
+        endif
+        exec 'simalt ~'. g:tlib#vim#simalt_restore
+        call s:RestoreFrameParams()
+    endf
+
+else
+
+    if !exists('g:tlib#vim#use_wmctrl')
+        " If true, use wmctrl for X windows to make a window 
+        " maximized/fullscreen.
+        "
+        " This is the preferred method for maximizing windows under X 
+        " windows. Some window managers have problem coping with the 
+        " default method of setting 'lines' and 'columns' to a large 
+        " value.
+        let g:tlib#vim#use_wmctrl = executable('wmctrl')  "{{{2
+    endif
+
+    " :nodoc:
+    fun! tlib#vim#Maximize(fullscreen) "{{{3
+        if !has("gui_running")
+            return
+        endif
+        call s:SaveFrameParams()
+        let s:fullscreen = a:fullscreen
+        if g:tlib#vim#use_wmctrl
+            if a:fullscreen
+                silent !wmctrl -r :ACTIVE: -b add,fullscreen
+            else
+                silent !wmctrl -r :ACTIVE: -b add,maximized_vert,maximized_horz
+            endif
+        else
+            set lines=1000 columns=1000 
+        endif
+    endf
+
+    " :nodoc:
+    function! tlib#vim#RestoreWindow() "{{{3
+        if !has("gui_running")
+            return
+        endif
+        if g:tlib#vim#use_wmctrl
+            if s:fullscreen
+                silent !wmctrl -r :ACTIVE: -b remove,fullscreen
+            else
+                silent !wmctrl -r :ACTIVE: -b remove,maximized_vert,maximized_horz
+            endif
+        endif
+        call s:RestoreFrameParams()
+    endf
+
+endif
+
+
+function! s:SaveFrameParams() "{{{3
+    let s:restoreframecmd = printf("set lines=%d columns=%d | winpos %d %d", &lines, &columns, getwinposx(), getwinposy())
+endf
+
+
+function! s:RestoreFrameParams() "{{{3
+    if !empty(s:restoreframecmd)
+        exec s:restoreframecmd
+        let s:restoreframecmd = ''
+    endif
+endf
+
+
+" :display: tlib#vim##CopyFunction(old, new, overwrite=0)
+function! tlib#vim#CopyFunction(old, new, ...) "{{{3
+    let overwrite = a:0 >= 1 ? a:1 : 0
+    redir => oldfn
+    exec 'silent function' a:old
+    redir END
+    if exists('*'. a:new)
+        if overwrite > 0
+            exec 'delfunction' a:new
+        elseif overwrite < 0
+            throw 'tlib#vim##CopyFunction: Function already exists: '. a:old .' -> '. a:new
+        else
+            return
+        endif
+    endif
+    let fn = split(oldfn, '\n')
+    let fn = map(fn, 'substitute(v:val, ''^\d\+'', "", "")')
+    let fn[0] = substitute(fn[0], '\V\^\s\*fu\%[nction]!\?\s\+\zs'. a:old, a:new, '')
+    let t = @t
+    try
+        let @t = join(fn, "\n")
+        redir => out
+        @t
+        redir END
+    finally
+        let @t = t
+    endtry
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/autoload/tlib/win.vim b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/win.vim
new file mode 100755
index 0000000..4963af1
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/autoload/tlib/win.vim
@@ -0,0 +1,128 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    55
+
+
+" Return vim code to jump back to the original window.
+function! tlib#win#Set(winnr) "{{{3
+    if a:winnr > 0
+        " TLogVAR a:winnr
+        " TLogDBG winnr()
+        " TLogDBG string(tlib#win#List())
+        if winnr() != a:winnr && winbufnr(a:winnr) != -1
+            let rv = winnr().'wincmd w'
+            exec a:winnr .'wincmd w'
+            " TLogVAR rv
+            " TLogDBG string(tlib#win#List())
+            return rv
+        endif
+    endif
+    return ''
+endf
+ 
+
+" :def: function! tlib#win#GetLayout(?save_view=0)
+function! tlib#win#GetLayout(...) "{{{3
+    TVarArg ['save_view', 0]
+    let views = {}
+    if save_view
+        let winnr = winnr()
+        windo let views[winnr()] = winsaveview()
+        " for w in range(1, winnr('$'))
+        "     call tlib#win#Set(w)
+        "     let views[w] = winsaveview()
+        " endfor
+        call tlib#win#Set(winnr)
+    endif
+    return {'winnr': winnr('$'), 'winrestcmd': winrestcmd(), 'views': views, 'cmdheight': &cmdheight, 'guioptions': &guioptions, 'tabpagenr': tabpagenr()}
+endf
+
+
+function! tlib#win#SetLayout(layout) "{{{3
+    if a:layout.tabpagenr == tabpagenr() && a:layout.winnr == winnr('$')
+        " TLogVAR a:layout.winrestcmd
+        " TLogDBG string(tlib#win#List())
+        exec a:layout.winrestcmd
+        if !empty(a:layout.views)
+            let winnr = winnr()
+            " TLogVAR winnr
+            for [w, v] in items(a:layout.views)
+                " TLogVAR w, v
+                call tlib#win#Set(w)
+                call winrestview(v)
+            endfor
+            call tlib#win#Set(winnr)
+        endif
+        if a:layout.cmdheight != &cmdheight
+            let &cmdheight = a:layout.cmdheight
+        endif
+        " TLogDBG string(tlib#win#List())
+        return 1
+    endif
+    return 0
+endf
+
+
+function! tlib#win#List() "{{{3
+    let wl = {}
+    for wn in range(1, winnr('$'))
+        let wl[wn] = bufname(winbufnr(wn))
+    endfor
+    return wl
+endf
+
+
+" " :def: function! tlib#win#GetLayout1(?save_view=0)
+" " Contrary to |tlib#win#GetLayout|, this version doesn't use 
+" " |winrestcmd()|. It can also save windows views.
+" function! tlib#win#GetLayout1(...) "{{{3
+"     TVarArg ['save_view', 0]
+"     let winnr = winnr()
+"     let acc = {}
+"     for w in range(1, winnr('$'))
+"         let def = {'h': winheight(w), 'w': winwidth(w)}
+"         if save_view
+"             call tlib#win#Set(w)
+"             let def.view = winsaveview()
+"         endif
+"         let acc[w] = def
+"     endfor
+"     call tlib#win#Set(winnr)
+"     return acc
+" endf
+" 
+" 
+" " Reset layout from the value of |tlib#win#GetLayout1|.
+" function! tlib#win#SetLayout1(layout) "{{{3
+"     if len(a:layout) != winnr('$')
+"         return 0
+"     endif
+"     let winnr = winnr()
+"     for [w, def] in items(a:layout)
+"         if tlib#win#Set(w)
+"             exec 'resize '. def.h
+"             exec 'vertical resize '. def.w
+"             if has_key(def, 'view')
+"                 call winrestview(def.view)
+"             endif
+"         else
+"             break
+"         endif
+"     endfor
+"     call tlib#win#Set(winnr)
+"     return 1
+" endf
+
+
+function! tlib#win#Width(wnr) "{{{3
+    return winwidth(a:wnr) - &fdc
+endf
+
+
+function! tlib#win#WinDo(ex) "{{{3
+    let w = winnr()
+    exec 'windo '. a:ex
+    exec w .'wincmd w'
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/doc/tlib.txt b/vim/.vim/bundle/snipmate-tlib/doc/tlib.txt
new file mode 100755
index 0000000..9d2d1a0
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/doc/tlib.txt
@@ -0,0 +1,2559 @@
+*tlib.txt*  tlib -- A library of vim functions
+            Author: Tom Link, micathom at gmail com
+
+This library provides some utility functions. There isn't much need to 
+install it unless another plugin requires you to do so.
+
+Most of the library is included in autoload files. No autocommands are 
+created. With the exception of loading ../plugin/02tlib.vim at startup 
+the library has no impact on startup time or anything else.
+
+The change-log is included at the bottom of ../plugin/02tlib.vim
+(move the cursor over the file name and type gfG)
+
+Demo of |tlib#input#List()|: 
+http://vimsomnia.blogspot.com/2010/11/selecting-items-from-list-with-tlibs.html
+
+
+-----------------------------------------------------------------------
+Install~
+
+Edit the vba file and type: >
+
+    :so %
+
+See :help vimball for details. If you have difficulties, please make 
+sure, you have the current version of vimball (vimscript #1502) 
+installed.
+
+
+========================================================================
+Contents~
+
+        :TLet .................................. |:TLet|
+        :TScratch .............................. |:TScratch|
+        :TVarArg ............................... |:TVarArg|
+        :TBrowseOutput ......................... |:TBrowseOutput|
+        :TBrowseScriptnames .................... |:TBrowseScriptnames|
+        :Tlibtrace ............................. |:Tlibtrace|
+        :Tlibtraceset .......................... |:Tlibtraceset|
+        :Tlibassert ............................ |:Tlibassert|
+        :Tlibtype .............................. |:Tlibtype|
+        Add .................................... |Add()|
+        TestGetArg ............................. |TestGetArg()|
+        TestGetArg1 ............................ |TestGetArg1()|
+        TestArgs ............................... |TestArgs()|
+        TestArgs1 .............................. |TestArgs1()|
+        TestArgs2 .............................. |TestArgs2()|
+        TestArgs3 .............................. |TestArgs3()|
+        g:tlib#debug ........................... |g:tlib#debug|
+        tlib#notify#Echo ....................... |tlib#notify#Echo()|
+        tlib#notify#TrimMessage ................ |tlib#notify#TrimMessage()|
+        tlib#notify#PrintError ................. |tlib#notify#PrintError()|
+        g:tlib#trace#backtrace ................. |g:tlib#trace#backtrace|
+        g:tlib#trace#printer ................... |g:tlib#trace#printer|
+        g:tlib#trace#hl ........................ |g:tlib#trace#hl|
+        tlib#trace#Printer_echom ............... |tlib#trace#Printer_echom()|
+        tlib#trace#Printer_file ................ |tlib#trace#Printer_file()|
+        tlib#trace#Set ......................... |tlib#trace#Set()|
+        tlib#trace#Backtrace ................... |tlib#trace#Backtrace()|
+        tlib#trace#Print ....................... |tlib#trace#Print()|
+        tlib#trace#Enable ...................... |tlib#trace#Enable()|
+        tlib#trace#Disable ..................... |tlib#trace#Disable()|
+        tlib#dictionary#Rev .................... |tlib#dictionary#Rev()|
+        g:tlib_persistent ...................... |g:tlib_persistent|
+        tlib#persistent#Dir .................... |tlib#persistent#Dir()|
+        tlib#persistent#Filename ............... |tlib#persistent#Filename()|
+        tlib#persistent#Get .................... |tlib#persistent#Get()|
+        tlib#persistent#MTime .................. |tlib#persistent#MTime()|
+        tlib#persistent#Value .................. |tlib#persistent#Value()|
+        tlib#persistent#Save ................... |tlib#persistent#Save()|
+        g:tlib#vim#simalt_maximize ............. |g:tlib#vim#simalt_maximize|
+        g:tlib#vim#simalt_restore .............. |g:tlib#vim#simalt_restore|
+        g:tlib#vim#use_vimtweak ................ |g:tlib#vim#use_vimtweak|
+        tlib#vim#Maximize ...................... |tlib#vim#Maximize()|
+        tlib#vim#RestoreWindow ................. |tlib#vim#RestoreWindow()|
+        g:tlib#vim#use_wmctrl .................. |g:tlib#vim#use_wmctrl|
+        tlib#vim#CopyFunction .................. |tlib#vim#CopyFunction()|
+        tlib#progressbar#Init .................. |tlib#progressbar#Init()|
+        tlib#progressbar#Display ............... |tlib#progressbar#Display()|
+        tlib#progressbar#Restore ............... |tlib#progressbar#Restore()|
+        tlib#selection#GetSelection ............ |tlib#selection#GetSelection()|
+        tlib#eval#FormatValue .................. |tlib#eval#FormatValue()|
+        tlib#eval#Extend ....................... |tlib#eval#Extend()|
+        tlib#list#Inject ....................... |tlib#list#Inject()|
+        tlib#list#Compact ...................... |tlib#list#Compact()|
+        tlib#list#Flatten ...................... |tlib#list#Flatten()|
+        tlib#list#FindAll ...................... |tlib#list#FindAll()|
+        tlib#list#Find ......................... |tlib#list#Find()|
+        tlib#list#Any .......................... |tlib#list#Any()|
+        tlib#list#All .......................... |tlib#list#All()|
+        tlib#list#Remove ....................... |tlib#list#Remove()|
+        tlib#list#RemoveAll .................... |tlib#list#RemoveAll()|
+        tlib#list#Zip .......................... |tlib#list#Zip()|
+        tlib#list#Uniq ......................... |tlib#list#Uniq()|
+        tlib#list#ToDictionary ................. |tlib#list#ToDictionary()|
+        tlib#cmd#OutputAsList .................. |tlib#cmd#OutputAsList()|
+        tlib#cmd#BrowseOutput .................. |tlib#cmd#BrowseOutput()|
+        tlib#cmd#BrowseOutputWithCallback ...... |tlib#cmd#BrowseOutputWithCallback()|
+        tlib#cmd#DefaultBrowseOutput ........... |tlib#cmd#DefaultBrowseOutput()|
+        tlib#cmd#ParseScriptname ............... |tlib#cmd#ParseScriptname()|
+        tlib#cmd#TBrowseScriptnames ............ |tlib#cmd#TBrowseScriptnames()|
+        tlib#cmd#UseVertical ................... |tlib#cmd#UseVertical()|
+        tlib#cmd#Time .......................... |tlib#cmd#Time()|
+        tlib#cmd#Capture ....................... |tlib#cmd#Capture()|
+        tlib#syntax#Collect .................... |tlib#syntax#Collect()|
+        tlib#syntax#Names ...................... |tlib#syntax#Names()|
+        tlib#balloon#Register .................. |tlib#balloon#Register()|
+        tlib#balloon#Remove .................... |tlib#balloon#Remove()|
+        tlib#balloon#Expr ...................... |tlib#balloon#Expr()|
+        tlib#balloon#Expand .................... |tlib#balloon#Expand()|
+        g:tlib#vcs#def ......................... |g:tlib#vcs#def|
+        g:tlib#vcs#executables ................. |g:tlib#vcs#executables|
+        g:tlib#vcs#check ....................... |g:tlib#vcs#check|
+        tlib#vcs#Executable .................... |tlib#vcs#Executable()|
+        tlib#vcs#FindVCS ....................... |tlib#vcs#FindVCS()|
+        tlib#vcs#Ls ............................ |tlib#vcs#Ls()|
+        tlib#vcs#Diff .......................... |tlib#vcs#Diff()|
+        tlib#vcs#GitLsPostprocess .............. |tlib#vcs#GitLsPostprocess()|
+        tlib#char#Get .......................... |tlib#char#Get()|
+        tlib#char#IsAvailable .................. |tlib#char#IsAvailable()|
+        tlib#char#GetWithTimeout ............... |tlib#char#GetWithTimeout()|
+        g:tlib#Filter_glob#seq ................. |g:tlib#Filter_glob#seq|
+        g:tlib#Filter_glob#char ................ |g:tlib#Filter_glob#char|
+        tlib#Filter_glob#New ................... |tlib#Filter_glob#New()|
+        g:tlib_scratch_pos ..................... |g:tlib_scratch_pos|
+        g:tlib#scratch#hidden .................. |g:tlib#scratch#hidden|
+        tlib#scratch#UseScratch ................ |tlib#scratch#UseScratch()|
+        tlib#scratch#CloseScratch .............. |tlib#scratch#CloseScratch()|
+        tlib#autocmdgroup#Init ................. |tlib#autocmdgroup#Init()|
+        g:tlib_cache ........................... |g:tlib_cache|
+        g:tlib#cache#purge_days ................ |g:tlib#cache#purge_days|
+        g:tlib#cache#purge_every_days .......... |g:tlib#cache#purge_every_days|
+        g:tlib#cache#script_encoding ........... |g:tlib#cache#script_encoding|
+        g:tlib#cache#run_script ................ |g:tlib#cache#run_script|
+        g:tlib#cache#verbosity ................. |g:tlib#cache#verbosity|
+        g:tlib#cache#dont_purge ................ |g:tlib#cache#dont_purge|
+        g:tlib#cache#max_filename .............. |g:tlib#cache#max_filename|
+        tlib#cache#Dir ......................... |tlib#cache#Dir()|
+        tlib#cache#Filename .................... |tlib#cache#Filename()|
+        tlib#cache#Save ........................ |tlib#cache#Save()|
+        tlib#cache#MTime ....................... |tlib#cache#MTime()|
+        tlib#cache#Get ......................... |tlib#cache#Get()|
+        tlib#cache#Value ....................... |tlib#cache#Value()|
+        tlib#cache#MaybePurge .................. |tlib#cache#MaybePurge()|
+        tlib#cache#Purge ....................... |tlib#cache#Purge()|
+        tlib#cache#ListFilesInCache ............ |tlib#cache#ListFilesInCache()|
+        tlib#normal#WithRegister ............... |tlib#normal#WithRegister()|
+        tlib#time#MSecs ........................ |tlib#time#MSecs()|
+        tlib#time#Now .......................... |tlib#time#Now()|
+        tlib#time#FormatNow .................... |tlib#time#FormatNow()|
+        tlib#time#Diff ......................... |tlib#time#Diff()|
+        tlib#time#DiffMSecs .................... |tlib#time#DiffMSecs()|
+        tlib#var#Let ........................... |tlib#var#Let()|
+        tlib#var#EGet .......................... |tlib#var#EGet()|
+        tlib#var#Get ........................... |tlib#var#Get()|
+        tlib#var#List .......................... |tlib#var#List()|
+        g:tlib_scroll_lines .................... |g:tlib_scroll_lines|
+        tlib#agent#Exit ........................ |tlib#agent#Exit()|
+        tlib#agent#CopyItems ................... |tlib#agent#CopyItems()|
+        tlib#agent#PageUp ...................... |tlib#agent#PageUp()|
+        tlib#agent#PageDown .................... |tlib#agent#PageDown()|
+        tlib#agent#Home ........................ |tlib#agent#Home()|
+        tlib#agent#End ......................... |tlib#agent#End()|
+        tlib#agent#Up .......................... |tlib#agent#Up()|
+        tlib#agent#Down ........................ |tlib#agent#Down()|
+        tlib#agent#UpN ......................... |tlib#agent#UpN()|
+        tlib#agent#DownN ....................... |tlib#agent#DownN()|
+        tlib#agent#ShiftLeft ................... |tlib#agent#ShiftLeft()|
+        tlib#agent#ShiftRight .................. |tlib#agent#ShiftRight()|
+        tlib#agent#Reset ....................... |tlib#agent#Reset()|
+        tlib#agent#ToggleRestrictView .......... |tlib#agent#ToggleRestrictView()|
+        tlib#agent#RestrictView ................ |tlib#agent#RestrictView()|
+        tlib#agent#UnrestrictView .............. |tlib#agent#UnrestrictView()|
+        tlib#agent#Input ....................... |tlib#agent#Input()|
+        tlib#agent#SuspendToParentWindow ....... |tlib#agent#SuspendToParentWindow()|
+        tlib#agent#Suspend ..................... |tlib#agent#Suspend()|
+        tlib#agent#Help ........................ |tlib#agent#Help()|
+        tlib#agent#OR .......................... |tlib#agent#OR()|
+        tlib#agent#AND ......................... |tlib#agent#AND()|
+        tlib#agent#ReduceFilter ................ |tlib#agent#ReduceFilter()|
+        tlib#agent#PopFilter ................... |tlib#agent#PopFilter()|
+        tlib#agent#Debug ....................... |tlib#agent#Debug()|
+        tlib#agent#Select ...................... |tlib#agent#Select()|
+        tlib#agent#SelectUp .................... |tlib#agent#SelectUp()|
+        tlib#agent#SelectDown .................. |tlib#agent#SelectDown()|
+        tlib#agent#SelectAll ................... |tlib#agent#SelectAll()|
+        tlib#agent#ToggleStickyList ............ |tlib#agent#ToggleStickyList()|
+        tlib#agent#EditItem .................... |tlib#agent#EditItem()|
+        tlib#agent#NewItem ..................... |tlib#agent#NewItem()|
+        tlib#agent#DeleteItems ................. |tlib#agent#DeleteItems()|
+        tlib#agent#Cut ......................... |tlib#agent#Cut()|
+        tlib#agent#Copy ........................ |tlib#agent#Copy()|
+        tlib#agent#Paste ....................... |tlib#agent#Paste()|
+        tlib#agent#EditReturnValue ............. |tlib#agent#EditReturnValue()|
+        tlib#agent#ViewFile .................... |tlib#agent#ViewFile()|
+        tlib#agent#EditFile .................... |tlib#agent#EditFile()|
+        tlib#agent#EditFileInSplit ............. |tlib#agent#EditFileInSplit()|
+        tlib#agent#EditFileInVSplit ............ |tlib#agent#EditFileInVSplit()|
+        tlib#agent#EditFileInTab ............... |tlib#agent#EditFileInTab()|
+        tlib#agent#ToggleScrollbind ............ |tlib#agent#ToggleScrollbind()|
+        tlib#agent#ShowInfo .................... |tlib#agent#ShowInfo()|
+        tlib#agent#PreviewLine ................. |tlib#agent#PreviewLine()|
+        tlib#agent#GotoLine .................... |tlib#agent#GotoLine()|
+        tlib#agent#DoAtLine .................... |tlib#agent#DoAtLine()|
+        tlib#agent#Wildcard .................... |tlib#agent#Wildcard()|
+        tlib#agent#Null ........................ |tlib#agent#Null()|
+        tlib#agent#ExecAgentByName ............. |tlib#agent#ExecAgentByName()|
+        tlib#agent#CompleteAgentNames .......... |tlib#agent#CompleteAgentNames()|
+        tlib#agent#Complete .................... |tlib#agent#Complete()|
+        tlib#bitwise#Num2Bits .................. |tlib#bitwise#Num2Bits()|
+        tlib#bitwise#Bits2Num .................. |tlib#bitwise#Bits2Num()|
+        tlib#bitwise#AND ....................... |tlib#bitwise#AND()|
+        tlib#bitwise#OR ........................ |tlib#bitwise#OR()|
+        tlib#bitwise#XOR ....................... |tlib#bitwise#XOR()|
+        tlib#bitwise#ShiftRight ................ |tlib#bitwise#ShiftRight()|
+        tlib#bitwise#ShiftLeft ................. |tlib#bitwise#ShiftLeft()|
+        tlib#bitwise#Add ....................... |tlib#bitwise#Add()|
+        tlib#bitwise#Sub ....................... |tlib#bitwise#Sub()|
+        tlib#url#Decode ........................ |tlib#url#Decode()|
+        tlib#url#DecodeChar .................... |tlib#url#DecodeChar()|
+        tlib#url#EncodeChar .................... |tlib#url#EncodeChar()|
+        tlib#url#Encode ........................ |tlib#url#Encode()|
+        tlib#signs#ClearAll .................... |tlib#signs#ClearAll()|
+        tlib#signs#ClearBuffer ................. |tlib#signs#ClearBuffer()|
+        tlib#signs#Mark ........................ |tlib#signs#Mark()|
+        tlib#rx#Escape ......................... |tlib#rx#Escape()|
+        tlib#rx#EscapeReplace .................. |tlib#rx#EscapeReplace()|
+        tlib#rx#Suffixes ....................... |tlib#rx#Suffixes()|
+        tlib#rx#LooksLikeRegexp ................ |tlib#rx#LooksLikeRegexp()|
+        g:tlib_tags_extra ...................... |g:tlib_tags_extra|
+        g:tlib_tag_substitute .................. |g:tlib_tag_substitute|
+        tlib#tag#Retrieve ...................... |tlib#tag#Retrieve()|
+        tlib#tag#Collect ....................... |tlib#tag#Collect()|
+        tlib#tag#Format ........................ |tlib#tag#Format()|
+        tlib#map#PumAccept ..................... |tlib#map#PumAccept()|
+        tlib#Filter_cnfd#New ................... |tlib#Filter_cnfd#New()|
+        g:tlib#input#sortprefs_threshold ....... |g:tlib#input#sortprefs_threshold|
+        g:tlib#input#livesearch_threshold ...... |g:tlib#input#livesearch_threshold|
+        g:tlib#input#filter_mode ............... |g:tlib#input#filter_mode|
+        g:tlib#input#higroup ................... |g:tlib#input#higroup|
+        g:tlib_pick_last_item .................. |g:tlib_pick_last_item|
+        g:tlib#input#and ....................... |g:tlib#input#and|
+        g:tlib#input#or ........................ |g:tlib#input#or|
+        g:tlib#input#not ....................... |g:tlib#input#not|
+        g:tlib#input#numeric_chars ............. |g:tlib#input#numeric_chars|
+        g:tlib#input#keyagents_InputList_s ..... |g:tlib#input#keyagents_InputList_s|
+        g:tlib#input#keyagents_InputList_m ..... |g:tlib#input#keyagents_InputList_m|
+        g:tlib#input#handlers_EditList ......... |g:tlib#input#handlers_EditList|
+        g:tlib#input#user_shortcuts ............ |g:tlib#input#user_shortcuts|
+        g:tlib#input#use_popup ................. |g:tlib#input#use_popup|
+        g:tlib#input#format_filename ........... |g:tlib#input#format_filename|
+        g:tlib#input#filename_padding_r ........ |g:tlib#input#filename_padding_r|
+        g:tlib#input#filename_max_width ........ |g:tlib#input#filename_max_width|
+        tlib#input#List ........................ |tlib#input#List()|
+        tlib#input#ListD ....................... |tlib#input#ListD()|
+        tlib#input#ListW ....................... |tlib#input#ListW()|
+        tlib#input#EditList .................... |tlib#input#EditList()|
+        tlib#input#Resume ...................... |tlib#input#Resume()|
+        tlib#input#CommandSelect ............... |tlib#input#CommandSelect()|
+        tlib#input#Edit ........................ |tlib#input#Edit()|
+        tlib#input#Dialog ...................... |tlib#input#Dialog()|
+        tlib#number#ConvertBase ................ |tlib#number#ConvertBase()|
+        g:tlib#file#drop ....................... |g:tlib#file#drop|
+        g:tlib#file#use_tabs ................... |g:tlib#file#use_tabs|
+        g:tlib#file#edit_cmds .................. |g:tlib#file#edit_cmds|
+        g:tlib#file#absolute_filename_rx ....... |g:tlib#file#absolute_filename_rx|
+        tlib#file#Split ........................ |tlib#file#Split()|
+        tlib#file#Join ......................... |tlib#file#Join()|
+        tlib#file#Relative ..................... |tlib#file#Relative()|
+        tlib#file#IsAbsolute ................... |tlib#file#IsAbsolute()|
+        tlib#file#Absolute ..................... |tlib#file#Absolute()|
+        tlib#file#Canonic ...................... |tlib#file#Canonic()|
+        tlib#file#With ......................... |tlib#file#With()|
+        tlib#file#Edit ......................... |tlib#file#Edit()|
+        tlib#file#Glob ......................... |tlib#file#Glob()|
+        tlib#file#Globpath ..................... |tlib#file#Globpath()|
+        g:tlib#sys#special_protocols ........... |g:tlib#sys#special_protocols|
+        g:tlib#sys#special_suffixes ............ |g:tlib#sys#special_suffixes|
+        g:tlib#sys#system_rx ................... |g:tlib#sys#system_rx|
+        g:tlib#sys#system_browser .............. |g:tlib#sys#system_browser|
+        g:tlib#sys#windows ..................... |g:tlib#sys#windows|
+        g:tlib#sys#null ........................ |g:tlib#sys#null|
+        tlib#sys#IsCygwinBin ................... |tlib#sys#IsCygwinBin()|
+        tlib#sys#IsExecutable .................. |tlib#sys#IsExecutable()|
+        g:tlib#sys#check_cygpath ............... |g:tlib#sys#check_cygpath|
+        g:tlib#sys#cygwin_path_rx .............. |g:tlib#sys#cygwin_path_rx|
+        g:tlib#sys#cygwin_expr ................. |g:tlib#sys#cygwin_expr|
+        tlib#sys#GetCmd ........................ |tlib#sys#GetCmd()|
+        tlib#sys#MaybeUseCygpath ............... |tlib#sys#MaybeUseCygpath()|
+        tlib#sys#ConvertPath ................... |tlib#sys#ConvertPath()|
+        tlib#sys#FileArgs ...................... |tlib#sys#FileArgs()|
+        tlib#sys#IsSpecial ..................... |tlib#sys#IsSpecial()|
+        tlib#sys#Open .......................... |tlib#sys#Open()|
+        tlib#sys#SystemInDir ................... |tlib#sys#SystemInDir()|
+        tlib#paragraph#GetMetric ............... |tlib#paragraph#GetMetric()|
+        tlib#paragraph#Move .................... |tlib#paragraph#Move()|
+        g:tlib_inputlist_pct ................... |g:tlib_inputlist_pct|
+        g:tlib_inputlist_width_filename ........ |g:tlib_inputlist_width_filename|
+        g:tlib_inputlist_filename_indicators ... |g:tlib_inputlist_filename_indicators|
+        g:tlib_inputlist_shortmessage .......... |g:tlib_inputlist_shortmessage|
+        tlib#World#New ......................... |tlib#World#New()|
+        prototype.PrintLines
+        prototype.Suspend
+        tlib#loclist#Browse .................... |tlib#loclist#Browse()|
+        tlib#tab#BufMap ........................ |tlib#tab#BufMap()|
+        tlib#tab#TabWinNr ...................... |tlib#tab#TabWinNr()|
+        tlib#tab#Set ........................... |tlib#tab#Set()|
+        tlib#date#IsDate ....................... |tlib#date#IsDate()|
+        tlib#date#Format ....................... |tlib#date#Format()|
+        tlib#date#DiffInDays ................... |tlib#date#DiffInDays()|
+        tlib#date#Parse ........................ |tlib#date#Parse()|
+        tlib#date#SecondsSince1970 ............. |tlib#date#SecondsSince1970()|
+        tlib#date#Shift ........................ |tlib#date#Shift()|
+        tlib#date#AddDays ...................... |tlib#date#AddDays()|
+        tlib#type#Enable ....................... |tlib#type#Enable()|
+        tlib#type#Disable ...................... |tlib#type#Disable()|
+        tlib#type#IsNumber ..................... |tlib#type#IsNumber()|
+        tlib#type#IsString ..................... |tlib#type#IsString()|
+        tlib#type#IsFuncref .................... |tlib#type#IsFuncref()|
+        tlib#type#IsList ....................... |tlib#type#IsList()|
+        tlib#type#IsDictionary ................. |tlib#type#IsDictionary()|
+        tlib#type#Is ........................... |tlib#type#Is()|
+        tlib#type#Are .......................... |tlib#type#Are()|
+        tlib#type#Define ....................... |tlib#type#Define()|
+        tlib#type#Has .......................... |tlib#type#Has()|
+        tlib#type#Have ......................... |tlib#type#Have()|
+        tlib#type#Check ........................ |tlib#type#Check()|
+        tlib#Filter_fuzzy#New .................. |tlib#Filter_fuzzy#New()|
+        tlib#assert#Enable ..................... |tlib#assert#Enable()|
+        tlib#assert#Disable .................... |tlib#assert#Disable()|
+        tlib#assert#Assert ..................... |tlib#assert#Assert()|
+        tlib#assert#Map ........................ |tlib#assert#Map()|
+        tlib#assert#All ........................ |tlib#assert#All()|
+        tlib#textobjects#StandardParagraph ..... |standard-paragraph|
+        tlib#textobjects#Init .................. |tlib#textobjects#Init()|
+        v_sp ................................... |v_sp|
+        o_sp ................................... |o_sp|
+        tlib#arg#Get ........................... |tlib#arg#Get()|
+        tlib#arg#Let ........................... |tlib#arg#Let()|
+        tlib#arg#StringAsKeyArgs ............... |tlib#arg#StringAsKeyArgs()|
+        tlib#arg#StringAsKeyArgsEqual .......... |tlib#arg#StringAsKeyArgsEqual()|
+        tlib#arg#GetOpts ....................... |tlib#arg#GetOpts()|
+        tlib#arg#Ex ............................ |tlib#arg#Ex()|
+        tlib#fixes#Winpos ...................... |tlib#fixes#Winpos()|
+        g:tlib#dir#sep ......................... |g:tlib#dir#sep|
+        tlib#dir#CanonicName ................... |tlib#dir#CanonicName()|
+        tlib#dir#NativeName .................... |tlib#dir#NativeName()|
+        tlib#dir#PlainName ..................... |tlib#dir#PlainName()|
+        tlib#dir#Ensure ........................ |tlib#dir#Ensure()|
+        tlib#dir#MyRuntime ..................... |tlib#dir#MyRuntime()|
+        tlib#dir#CD ............................ |tlib#dir#CD()|
+        tlib#dir#Push .......................... |tlib#dir#Push()|
+        tlib#dir#Pop ........................... |tlib#dir#Pop()|
+        g:tlib#hash#use_crc32 .................. |g:tlib#hash#use_crc32|
+        g:tlib#hash#use_adler32 ................ |g:tlib#hash#use_adler32|
+        tlib#hash#CRC32B ....................... |tlib#hash#CRC32B()|
+        tlib#hash#CRC32B_ruby .................. |tlib#hash#CRC32B_ruby()|
+        tlib#hash#CRC32B_vim ................... |tlib#hash#CRC32B_vim()|
+        tlib#hash#Adler32 ...................... |tlib#hash#Adler32()|
+        tlib#hash#Adler32_vim .................. |tlib#hash#Adler32_vim()|
+        tlib#hash#Adler32_tlib ................. |tlib#hash#Adler32_tlib()|
+        tlib#win#Set ........................... |tlib#win#Set()|
+        tlib#win#GetLayout ..................... |tlib#win#GetLayout()|
+        tlib#win#SetLayout ..................... |tlib#win#SetLayout()|
+        tlib#win#List .......................... |tlib#win#List()|
+        tlib#win#Width ......................... |tlib#win#Width()|
+        tlib#win#WinDo ......................... |tlib#win#WinDo()|
+        tlib#comments#Comments ................. |tlib#comments#Comments()|
+        tlib#grep#Do ........................... |tlib#grep#Do()|
+        tlib#grep#LocList ...................... |tlib#grep#LocList()|
+        tlib#grep#QuickFixList ................. |tlib#grep#QuickFixList()|
+        tlib#grep#List ......................... |tlib#grep#List()|
+        tlib#qfl#FormatQFLE .................... |tlib#qfl#FormatQFLE()|
+        tlib#qfl#QfeFilename ................... |tlib#qfl#QfeFilename()|
+        tlib#qfl#InitListBuffer ................ |tlib#qfl#InitListBuffer()|
+        tlib#qfl#SetSyntax ..................... |tlib#qfl#SetSyntax()|
+        tlib#qfl#Balloon ....................... |tlib#qfl#Balloon()|
+        tlib#qfl#AgentEditQFE .................. |tlib#qfl#AgentEditQFE()|
+        tlib#qfl#AgentPreviewQFE ............... |tlib#qfl#AgentPreviewQFE()|
+        tlib#qfl#AgentGotoQFE .................. |tlib#qfl#AgentGotoQFE()|
+        tlib#qfl#AgentWithSelected ............. |tlib#qfl#AgentWithSelected()|
+        tlib#qfl#RunCmdOnSelected .............. |tlib#qfl#RunCmdOnSelected()|
+        tlib#qfl#AgentSplitBuffer .............. |tlib#qfl#AgentSplitBuffer()|
+        tlib#qfl#AgentTabBuffer ................ |tlib#qfl#AgentTabBuffer()|
+        tlib#qfl#AgentVSplitBuffer ............. |tlib#qfl#AgentVSplitBuffer()|
+        tlib#qfl#AgentEditLine ................. |tlib#qfl#AgentEditLine()|
+        tlib#qfl#EditLine ...................... |tlib#qfl#EditLine()|
+        tlib#qfl#SetFollowCursor ............... |tlib#qfl#SetFollowCursor()|
+        tlib#qfl#QflList ....................... |tlib#qfl#QflList()|
+        tlib#qfl#Browse ........................ |tlib#qfl#Browse()|
+        tlib#Filter_cnf#New .................... |tlib#Filter_cnf#New()|
+        prototype.Pretty
+        tlib#Object#New ........................ |tlib#Object#New()|
+        prototype.New
+        prototype.Inherit
+        prototype.Extend
+        prototype.IsA
+        prototype.IsRelated
+        prototype.RespondTo
+        prototype.Super
+        tlib#Object#Methods .................... |tlib#Object#Methods()|
+        g:tlib_viewline_position ............... |g:tlib_viewline_position|
+        tlib#buffer#EnableMRU .................. |tlib#buffer#EnableMRU()|
+        tlib#buffer#DisableMRU ................. |tlib#buffer#DisableMRU()|
+        tlib#buffer#Set ........................ |tlib#buffer#Set()|
+        tlib#buffer#Eval ....................... |tlib#buffer#Eval()|
+        tlib#buffer#GetList .................... |tlib#buffer#GetList()|
+        tlib#buffer#ViewLine ................... |tlib#buffer#ViewLine()|
+        tlib#buffer#HighlightLine .............. |tlib#buffer#HighlightLine()|
+        tlib#buffer#DeleteRange ................ |tlib#buffer#DeleteRange()|
+        tlib#buffer#ReplaceRange ............... |tlib#buffer#ReplaceRange()|
+        tlib#buffer#ScratchStart ............... |tlib#buffer#ScratchStart()|
+        tlib#buffer#ScratchEnd ................. |tlib#buffer#ScratchEnd()|
+        tlib#buffer#BufDo ...................... |tlib#buffer#BufDo()|
+        tlib#buffer#InsertText ................. |tlib#buffer#InsertText()|
+        tlib#buffer#InsertText0 ................ |tlib#buffer#InsertText0()|
+        tlib#buffer#CurrentByte ................ |tlib#buffer#CurrentByte()|
+        tlib#buffer#KeepCursorPosition ......... |tlib#buffer#KeepCursorPosition()|
+        tlib#hook#Run .......................... |tlib#hook#Run()|
+        tlib#string#RemoveBackslashes .......... |tlib#string#RemoveBackslashes()|
+        tlib#string#Chomp ...................... |tlib#string#Chomp()|
+        tlib#string#Format ..................... |tlib#string#Format()|
+        tlib#string#Printf1 .................... |tlib#string#Printf1()|
+        tlib#string#TrimLeft ................... |tlib#string#TrimLeft()|
+        tlib#string#TrimRight .................. |tlib#string#TrimRight()|
+        tlib#string#Strip ...................... |tlib#string#Strip()|
+        tlib#string#Count ...................... |tlib#string#Count()|
+        tlib#string#SplitCommaList ............. |tlib#string#SplitCommaList()|
+        tlib#string#Input ...................... |tlib#string#Input()|
+
+
+========================================================================
+plugin/02tlib.vim~
+
+                                                    *:TLet*
+:TLet VAR = VALUE
+    Set a variable only if it doesn't already exist.
+    EXAMPLES: >
+      TLet foo = 1
+      TLet foo = 2
+      echo foo
+      => 1
+<
+
+                                                    *:TScratch*
+:TScratch
+    Open a scratch buffer (a buffer without a file).
+      TScratch  ... use split window
+      TScratch! ... use the whole frame
+    This command takes an (inner) dictionary as optional argument.
+    EXAMPLES: >
+      TScratch 'scratch': '__FOO__'
+      => Open a scratch buffer named __FOO__
+<
+
+                                                    *:TVarArg*
+:TVarArg VAR1, [VAR2, DEFAULT2] ...
+    A convenience wrapper for |tlib#arg#Let|.
+    EXAMPLES: >
+      function! Foo(...)
+          TVarArg ['a', 1], 'b'
+          echo 'a='. a
+          echo 'b='. b
+      endf
+<
+
+                                                    *:TBrowseOutput*
+:TBrowseOutput COMMAND
+    Ever wondered how to efficiently browse the output of a command 
+    without redirecting it to a file? This command takes a command as 
+    argument and presents the output via |tlib#input#List()| so that you 
+    can easily search for a keyword (e.g. the name of a variable or 
+    function) and the like.
+
+    If you press enter, the selected line will be copied to the command 
+    line. Press ESC to cancel browsing.
+
+    EXAMPLES: >
+      TBrowseOutput 20verb TeaseTheCulprit
+<
+
+                                                    *:TBrowseScriptnames*
+:TBrowseScriptnames
+    List all sourced script names (the output of ':scriptnames').
+
+    When you press enter, the selected script will be opened in the current
+    window. Press ESC to cancel.
+
+    EXAMPLES: >
+      TBrowseScriptnames 
+<
+
+                                                    *:Tlibtrace*
+:Tlibtrace GUARD, VAR1, VAR2...
+    Do nothing unless |tlib#trace#Enable()| was called.
+
+    When |:Tlibtraceset| or |tlib#trace#Enable()| were called:
+
+    If GUARD is a number that evaluates to true or if it is a string that 
+    matches a |regexp|, which was added using Tlibtrace! (with '!'), 
+    display the values of VAR1, VAR2 ...
+
+                                                    *:Tlibtraceset*
+:Tlibtraceset
+    :Tlibtraceset +RX1, -RX2...
+    If |tlib#trace#Enable()| was called: With the optional <bang>, users 
+    can add and remove GUARDs (actually a |regexp|) that should be traced.
+
+                                                    *:Tlibassert*
+:Tlibtrace ASSERTION
+
+                                                    *:Tlibtype*
+:Tlibtype val, 'type', ...
+
+
+========================================================================
+test/tlib.vim~
+
+                                                    *Add()*
+Add(a,b)
+    List
+
+                                                    *TestGetArg()*
+TestGetArg(...)
+    Optional arguments
+
+                                                    *TestGetArg1()*
+TestGetArg1(...)
+
+                                                    *TestArgs()*
+TestArgs(...)
+
+                                                    *TestArgs1()*
+TestArgs1(...)
+
+                                                    *TestArgs2()*
+TestArgs2(...)
+
+                                                    *TestArgs3()*
+TestArgs3(...)
+
+
+========================================================================
+autoload/tlib.vim~
+
+                                                    *g:tlib#debug*
+g:tlib#debug
+
+
+========================================================================
+autoload/tlib/notify.vim~
+
+                                                    *tlib#notify#Echo()*
+tlib#notify#Echo(text, ?style='')
+    Print text in the echo area. Temporarily disable 'ruler' and 'showcmd' 
+    in order to prevent |press-enter| messages.
+
+                                                    *tlib#notify#TrimMessage()*
+tlib#notify#TrimMessage(message)
+    Contributed by Erik Falor:
+    If the line containing the message is too long, echoing it will cause 
+    a 'Hit ENTER' prompt to appear.  This function cleans up the line so 
+    that does not happen.
+    The echoed line is too long if it is wider than the width of the 
+    window, minus cmdline space taken up by the ruler and showcmd 
+    features.
+
+                                                    *tlib#notify#PrintError()*
+tlib#notify#PrintError()
+
+
+========================================================================
+autoload/tlib/trace.vim~
+
+                                                    *g:tlib#trace#backtrace*
+g:tlib#trace#backtrace         (default: 2)
+    The length of the backtrace that should be included in 
+    |tlib#trace#Print()|.
+
+                                                    *g:tlib#trace#printer*
+g:tlib#trace#printer           (default: 'echom')
+    Possible values:
+      - 'echom'
+      - ['file', FILENAME]
+
+                                                    *g:tlib#trace#hl*
+g:tlib#trace#hl                (default: {'error': 'ErrorMsg', 'fatal': 'ErrorMsg', 'warn': 'WarningMsg'})
+
+                                                    *tlib#trace#Printer_echom()*
+tlib#trace#Printer_echom(type, text, args)
+    Print traces from |tlib#trace#Print()|.
+
+                                                    *tlib#trace#Printer_file()*
+tlib#trace#Printer_file(type, text, args)
+
+                                                    *tlib#trace#Set()*
+tlib#trace#Set(vars)
+    Set the tracing |regexp|. See |:Tlibtrace|.
+    This will also call |tlib#trace#Enable()|.
+
+    Examples:
+      call tlib#trace#Set(["+foo", "-bar"])
+      call tlib#trace#Set("+foo,-bar")
+
+                                                    *tlib#trace#Backtrace()*
+tlib#trace#Backtrace(caller)
+
+                                                    *tlib#trace#Print()*
+tlib#trace#Print(caller, vars, values)
+    Print the values of vars. The first value is a "guard" (see 
+    |:Tlibtrace|).
+
+                                                    *tlib#trace#Enable()*
+tlib#trace#Enable()
+    Enable tracing via |:Tlibtrace|.
+
+                                                    *tlib#trace#Disable()*
+tlib#trace#Disable()
+    Disable tracing via |:Tlibtrace|.
+
+
+========================================================================
+autoload/tlib/dictionary.vim~
+
+                                                    *tlib#dictionary#Rev()*
+tlib#dictionary#Rev(dict, ?opts = {}) abort "{{{3
+
+
+========================================================================
+autoload/tlib/persistent.vim~
+
+                                                    *g:tlib_persistent*
+g:tlib_persistent              (default: '')
+    The directory for persistent data files. If empty, use 
+    |tlib#dir#MyRuntime|.'/share'.
+
+                                                    *tlib#persistent#Dir()*
+tlib#persistent#Dir(?mode = 'bg')
+    Return the full directory name for persistent data files.
+
+                                                    *tlib#persistent#Filename()*
+tlib#persistent#Filename(type, ?file=%, ?mkdir=0)
+
+                                                    *tlib#persistent#Get()*
+tlib#persistent#Get(...)
+
+                                                    *tlib#persistent#MTime()*
+tlib#persistent#MTime(cfile)
+
+                                                    *tlib#persistent#Value()*
+tlib#persistent#Value(...)
+
+                                                    *tlib#persistent#Save()*
+tlib#persistent#Save(cfile, dictionary)
+
+
+========================================================================
+autoload/tlib/vim.vim~
+
+                                                    *g:tlib#vim#simalt_maximize*
+g:tlib#vim#simalt_maximize     (default: 'x')
+    The alt-key for maximizing the window.
+    CAUTION: The value of this paramter depends on your locale and 
+    maybe the windows version you are running.
+
+                                                    *g:tlib#vim#simalt_restore*
+g:tlib#vim#simalt_restore      (default: 'r')
+    The alt-key for restoring the window.
+    CAUTION: The value of this paramter depends on your locale and 
+    maybe the windows version you are running.
+
+                                                    *g:tlib#vim#use_vimtweak*
+g:tlib#vim#use_vimtweak        (default: 0)
+    If true, use the vimtweak.dll for windows. This will enable 
+    tlib to remove the caption for fullscreen windows.
+
+                                                    *tlib#vim#Maximize()*
+tlib#vim#Maximize(fullscreen)
+    Maximize the window.
+    You might need to redefine |g:tlib#vim#simalt_maximize| if it doesn't 
+    work for you.
+
+                                                    *tlib#vim#RestoreWindow()*
+tlib#vim#RestoreWindow()
+    Restore the original vimsize after having called |tlib#vim#Maximize()|.
+
+                                                    *g:tlib#vim#use_wmctrl*
+g:tlib#vim#use_wmctrl          (default: executable('wmctrl'))
+    If true, use wmctrl for X windows to make a window 
+    maximized/fullscreen.
+
+    This is the preferred method for maximizing windows under X 
+    windows. Some window managers have problem coping with the 
+    default method of setting 'lines' and 'columns' to a large 
+    value.
+
+                                                    *tlib#vim#CopyFunction()*
+tlib#vim##CopyFunction(old, new, overwrite=0)
+
+
+========================================================================
+autoload/tlib/progressbar.vim~
+
+                                                    *tlib#progressbar#Init()*
+tlib#progressbar#Init(max, ...)
+    EXAMPLE: >
+        call tlib#progressbar#Init(20)
+        try
+            for i in range(20)
+                call tlib#progressbar#Display(i)
+                call DoSomethingThatTakesSomeTime(i)
+            endfor
+        finally
+            call tlib#progressbar#Restore()
+        endtry
+<
+
+                                                    *tlib#progressbar#Display()*
+tlib#progressbar#Display(value, ...)
+
+                                                    *tlib#progressbar#Restore()*
+tlib#progressbar#Restore()
+
+
+========================================================================
+autoload/tlib/selection.vim~
+
+                                                    *tlib#selection#GetSelection()*
+tlib#selection#GetSelection(mode, ?mbeg="'<", ?mend="'>", ?opmode='selection')
+    mode can be one of: selection, lines, block
+
+
+========================================================================
+autoload/tlib/eval.vim~
+
+                                                    *tlib#eval#FormatValue()*
+tlib#eval#FormatValue(value, ...)
+
+                                                    *tlib#eval#Extend()*
+tlib#eval#Extend(a, b, ...)
+
+
+========================================================================
+autoload/tlib/list.vim~
+
+                                                    *tlib#list#Inject()*
+tlib#list#Inject(list, initial_value, funcref)
+    EXAMPLES: >
+      echo tlib#list#Inject([1,2,3], 0, function('Add')
+      => 6
+<
+
+                                                    *tlib#list#Compact()*
+tlib#list#Compact(list)
+    EXAMPLES: >
+      tlib#list#Compact([0,1,2,3,[], {}, ""])
+      => [1,2,3]
+<
+
+                                                    *tlib#list#Flatten()*
+tlib#list#Flatten(list)
+    EXAMPLES: >
+      tlib#list#Flatten([0,[1,2,[3,""]]])
+      => [0,1,2,3,""]
+<
+
+                                                    *tlib#list#FindAll()*
+tlib#list#FindAll(list, filter, ?process_expr="")
+    Basically the same as filter()
+
+    EXAMPLES: >
+      tlib#list#FindAll([1,2,3], 'v:val >= 2')
+      => [2, 3]
+<
+
+                                                    *tlib#list#Find()*
+tlib#list#Find(list, filter, ?default="", ?process_expr="")
+
+    EXAMPLES: >
+      tlib#list#Find([1,2,3], 'v:val >= 2')
+      => 2
+<
+
+                                                    *tlib#list#Any()*
+tlib#list#Any(list, expr)
+    EXAMPLES: >
+      tlib#list#Any([1,2,3], 'v:val >= 2')
+      => 1
+<
+
+                                                    *tlib#list#All()*
+tlib#list#All(list, expr)
+    EXAMPLES: >
+      tlib#list#All([1,2,3], 'v:val >= 2')
+      => 0
+<
+
+                                                    *tlib#list#Remove()*
+tlib#list#Remove(list, element)
+    EXAMPLES: >
+      tlib#list#Remove([1,2,1,2], 2)
+      => [1,1,2]
+<
+
+                                                    *tlib#list#RemoveAll()*
+tlib#list#RemoveAll(list, element)
+    EXAMPLES: >
+      tlib#list#RemoveAll([1,2,1,2], 2)
+      => [1,1]
+<
+
+                                                    *tlib#list#Zip()*
+tlib#list#Zip(lists, ?default='')
+    EXAMPLES: >
+      tlib#list#Zip([[1,2,3], [4,5,6]])
+      => [[1,4], [2,5], [3,6]]
+<
+
+                                                    *tlib#list#Uniq()*
+tlib#list#Uniq(list, ...)
+
+                                                    *tlib#list#ToDictionary()*
+tlib#list#ToDictionary(list, default, ...)
+
+
+========================================================================
+autoload/tlib/cmd.vim~
+
+                                                    *tlib#cmd#OutputAsList()*
+tlib#cmd#OutputAsList(command)
+
+                                                    *tlib#cmd#BrowseOutput()*
+tlib#cmd#BrowseOutput(command)
+    See |:TBrowseOutput|.
+
+                                                    *tlib#cmd#BrowseOutputWithCallback()*
+tlib#cmd#BrowseOutputWithCallback(callback, command)
+    Execute COMMAND and present its output in a |tlib#input#List()|;
+    when a line is selected, execute the function named as the CALLBACK
+    and pass in that line as an argument.
+
+    The CALLBACK function gives you an opportunity to massage the COMMAND output
+    and possibly act on it in a meaningful way. For example, if COMMAND listed
+    all URIs found in the current buffer, CALLBACK could validate and then open
+    the selected URI in the system's default browser.
+
+    This function is meant to be a tool to help compose the implementations of
+    powerful commands that use |tlib#input#List()| as a common interface. See
+    |TBrowseScriptnames| as an example.
+
+    EXAMPLES: >
+      call tlib#cmd#BrowseOutputWithCallback('tlib#cmd#ParseScriptname', 'scriptnames')
+<
+
+                                                    *tlib#cmd#DefaultBrowseOutput()*
+tlib#cmd#DefaultBrowseOutput(cmd)
+
+                                                    *tlib#cmd#ParseScriptname()*
+tlib#cmd#ParseScriptname(line)
+
+                                                    *tlib#cmd#TBrowseScriptnames()*
+tlib#cmd#TBrowseScriptnames()
+
+                                                    *tlib#cmd#UseVertical()*
+tlib#cmd#UseVertical(?rx='')
+    Look at the history whether the command was called with vertical. If 
+    an rx is provided check first if the last entry in the history matches 
+    this rx.
+
+                                                    *tlib#cmd#Time()*
+tlib#cmd#Time(cmd)
+    Print the time in seconds or milliseconds (if your version of VIM 
+    has |+reltime|) a command takes.
+
+                                                    *tlib#cmd#Capture()*
+tlib#cmd#Capture(cmd)
+
+
+========================================================================
+autoload/tlib/syntax.vim~
+
+                                                    *tlib#syntax#Collect()*
+tlib#syntax#Collect()
+
+                                                    *tlib#syntax#Names()*
+tlib#syntax#Names(?rx='')
+
+
+========================================================================
+autoload/tlib/balloon.vim~
+
+                                                    *tlib#balloon#Register()*
+tlib#balloon#Register(expr)
+
+                                                    *tlib#balloon#Remove()*
+tlib#balloon#Remove(expr)
+
+                                                    *tlib#balloon#Expr()*
+tlib#balloon#Expr()
+
+                                                    *tlib#balloon#Expand()*
+tlib#balloon#Expand(expr)
+
+
+========================================================================
+autoload/tlib/vcs.vim~
+
+                                                    *g:tlib#vcs#def*
+g:tlib#vcs#def                 {...}
+    A dictionarie of supported VCS (currently: git, hg, svn, bzr).
+
+                                                    *g:tlib#vcs#executables*
+g:tlib#vcs#executables         {...}
+    A dictionary of custom executables for VCS commands. If the value is 
+    empty, support for that VCS will be removed. If no key is present, it 
+    is assumed that the VCS "type" is the name of the executable.
+
+                                                    *g:tlib#vcs#check*
+g:tlib#vcs#check               (default: has('win16') || has('win32') || has('win64') ? '%s.exe' : '%s')
+    If non-empty, use it as a format string to check whether a VCS is 
+    installed on your computer.
+
+                                                    *tlib#vcs#Executable()*
+tlib#vcs#Executable(type)
+
+                                                    *tlib#vcs#FindVCS()*
+tlib#vcs#FindVCS(filename)
+
+                                                    *tlib#vcs#Ls()*
+tlib#vcs#Ls(?filename=bufname('%'), ?vcs=[type, dir])
+    Return the files under VCS.
+
+                                                    *tlib#vcs#Diff()*
+tlib#vcs#Diff(filename, ?vcs=[type, dir])
+    Return the diff for "filename"
+
+                                                    *tlib#vcs#GitLsPostprocess()*
+tlib#vcs#GitLsPostprocess(filename)
+
+
+========================================================================
+autoload/tlib/char.vim~
+
+                                                    *tlib#char#Get()*
+tlib#char#Get(?timeout=0)
+    Get a character.
+
+    EXAMPLES: >
+      echo tlib#char#Get()
+      echo tlib#char#Get(5)
+<
+
+                                                    *tlib#char#IsAvailable()*
+tlib#char#IsAvailable()
+
+                                                    *tlib#char#GetWithTimeout()*
+tlib#char#GetWithTimeout(timeout, ...)
+
+
+========================================================================
+autoload/tlib/Filter_glob.vim~
+
+                                                    *g:tlib#Filter_glob#seq*
+g:tlib#Filter_glob#seq         (default: '*')
+    A character that should be expanded to '\.\{-}'.
+
+                                                    *g:tlib#Filter_glob#char*
+g:tlib#Filter_glob#char        (default: '?')
+    A character that should be expanded to '\.\?'.
+
+                                                    *tlib#Filter_glob#New()*
+tlib#Filter_glob#New(...)
+    The same as |tlib#Filter_cnf#New()| but a a customizable character 
+    |see tlib#Filter_glob#seq| is expanded to '\.\{-}' and 
+    |g:tlib#Filter_glob#char| is expanded to '\.'.
+    The pattern is a '/\V' very no-'/magic' regexp pattern.
+
+
+========================================================================
+autoload/tlib/scratch.vim~
+
+                                                    *g:tlib_scratch_pos*
+g:tlib_scratch_pos             (default: 'botright')
+    Scratch window position. By default the list window is opened on the 
+    bottom. Set this variable to 'topleft' or '' to change this behaviour.
+    See |tlib#input#List()|.
+
+                                                    *g:tlib#scratch#hidden*
+g:tlib#scratch#hidden          (default: 'hide')
+    If you want the scratch buffer to be fully removed, you might want to 
+    set this variable to 'wipe'.
+    See also https://github.com/tomtom/tlib_vim/pull/16
+
+                                                    *tlib#scratch#UseScratch()*
+tlib#scratch#UseScratch(?keyargs={})
+    Display a scratch buffer (a buffer with no file). See :TScratch for an 
+    example.
+    Return the scratch buffer's number.
+    Values for keyargs:
+      scratch_split ... 1: split, 0: window, -1: tab
+
+                                                    *tlib#scratch#CloseScratch()*
+tlib#scratch#CloseScratch(keyargs, ...)
+    Close a scratch buffer as defined in keyargs (usually a World).
+    Return 1 if the scratch buffer is closed (or if it already was 
+    closed).
+
+
+========================================================================
+autoload/tlib/autocmdgroup.vim~
+
+                                                    *tlib#autocmdgroup#Init()*
+tlib#autocmdgroup#Init()
+
+
+========================================================================
+autoload/tlib/cache.vim~
+
+                                                    *g:tlib_cache*
+g:tlib_cache                   (default: '')
+    The cache directory. If empty, use |tlib#dir#MyRuntime|.'/cache'.
+    You might want to delete old files from this directory from time to 
+    time with a command like: >
+      find ~/vimfiles/cache/ -atime +31 -type f -print -delete
+<
+
+                                                    *g:tlib#cache#purge_days*
+g:tlib#cache#purge_days        (default: 31)
+    |tlib#cache#Purge()|: Remove cache files older than N days.
+
+                                                    *g:tlib#cache#purge_every_days*
+g:tlib#cache#purge_every_days  (default: 31)
+    Purge the cache every N days. Disable automatic purging by setting 
+    this value to a negative value.
+
+                                                    *g:tlib#cache#script_encoding*
+g:tlib#cache#script_encoding   (default: &enc)
+    The encoding used for the purge-cache script.
+    Default: 'enc'
+
+                                                    *g:tlib#cache#run_script*
+g:tlib#cache#run_script        (default: 1)
+    Whether to run the directory removal script:
+       0 ... No
+       1 ... Query user
+       2 ... Yes
+
+                                                    *g:tlib#cache#verbosity*
+g:tlib#cache#verbosity         (default: 1)
+    Verbosity level:
+        0 ... Be quiet
+        1 ... Display informative message
+        2 ... Display detailed messages
+
+                                                    *g:tlib#cache#dont_purge*
+g:tlib#cache#dont_purge        (default: ['[\/]\.last_purge$'])
+    A list of regexps that are matched against partial filenames of the 
+    cached files. If a regexp matches, the file won't be removed by 
+    |tlib#cache#Purge()|.
+
+                                                    *g:tlib#cache#max_filename*
+g:tlib#cache#max_filename      (default: 200)
+    If the cache filename is longer than N characters, use 
+    |pathshorten()|.
+
+                                                    *tlib#cache#Dir()*
+tlib#cache#Dir(?mode = 'bg')
+    The default cache directory.
+
+                                                    *tlib#cache#Filename()*
+tlib#cache#Filename(type, ?file=%, ?mkdir=0, ?dir='')
+
+                                                    *tlib#cache#Save()*
+tlib#cache#Save(cfile, dictionary, ...)
+
+                                                    *tlib#cache#MTime()*
+tlib#cache#MTime(cfile)
+
+                                                    *tlib#cache#Get()*
+tlib#cache#Get(cfile, ...)
+
+                                                    *tlib#cache#Value()*
+tlib#cache#Value(cfile, generator, ftime, ?generator_args=[], ?options={})
+    Get a cached value from cfile. If it is outdated (compared to ftime) 
+    or does not exist, create it calling a generator function.
+
+                                                    *tlib#cache#MaybePurge()*
+tlib#cache#MaybePurge()
+    Call |tlib#cache#Purge()| if the last purge was done before 
+    |g:tlib#cache#purge_every_days|.
+
+                                                    *tlib#cache#Purge()*
+tlib#cache#Purge()
+    Delete old files.
+
+                                                    *tlib#cache#ListFilesInCache()*
+tlib#cache#ListFilesInCache(...)
+
+
+========================================================================
+autoload/tlib/normal.vim~
+
+                                                    *tlib#normal#WithRegister()*
+tlib#normal#WithRegister(cmd, ?register='t', ?norm_cmd='norm!')
+    Execute a normal command while maintaining all registers.
+
+
+========================================================================
+autoload/tlib/time.vim~
+
+                                                    *tlib#time#MSecs()*
+tlib#time#MSecs()
+
+                                                    *tlib#time#Now()*
+tlib#time#Now()
+
+                                                    *tlib#time#FormatNow()*
+tlib#time#FormatNow()
+
+                                                    *tlib#time#Diff()*
+tlib#time#Diff(a, b, ...)
+
+                                                    *tlib#time#DiffMSecs()*
+tlib#time#DiffMSecs(a, b, ...)
+
+
+========================================================================
+autoload/tlib/var.vim~
+
+                                                    *tlib#var#Let()*
+tlib#var#Let(name, val)
+    Define a variable called NAME if yet undefined.
+    You can also use the :TLLet command.
+
+    EXAMPLES: >
+      exec tlib#var#Let('g:foo', 1)
+      TLet g:foo = 1
+<
+
+                                                    *tlib#var#EGet()*
+tlib#var#EGet(var, namespace, ?default='')
+    Retrieve a variable by searching several namespaces.
+
+    EXAMPLES: >
+      let g:foo = 1
+      let b:foo = 2
+      let w:foo = 3
+      echo eval(tlib#var#EGet('foo', 'vg'))  => 1
+      echo eval(tlib#var#EGet('foo', 'bg'))  => 2
+      echo eval(tlib#var#EGet('foo', 'wbg')) => 3
+<
+
+                                                    *tlib#var#Get()*
+tlib#var#Get(var, namespace, ?default='')
+    Retrieve a variable by searching several namespaces.
+
+    EXAMPLES: >
+      let g:foo = 1
+      let b:foo = 2
+      let w:foo = 3
+      echo tlib#var#Get('foo', 'bg')  => 1
+      echo tlib#var#Get('foo', 'bg')  => 2
+      echo tlib#var#Get('foo', 'wbg') => 3
+<
+
+                                                    *tlib#var#List()*
+tlib#var#List(rx, ?prefix='')
+    Get a list of variables matching rx.
+    EXAMPLE:
+      echo tlib#var#List('tlib_', 'g:')
+
+
+========================================================================
+autoload/tlib/agent.vim~
+Various agents for use as key handlers in tlib#input#List()
+
+                                                    *g:tlib_scroll_lines*
+g:tlib_scroll_lines            (default: 10)
+    Number of items to move when pressing <c-up/down> in the input list window.
+
+                                                    *tlib#agent#Exit()*
+tlib#agent#Exit(world, selected)
+
+                                                    *tlib#agent#CopyItems()*
+tlib#agent#CopyItems(world, selected)
+
+                                                    *tlib#agent#PageUp()*
+tlib#agent#PageUp(world, selected)
+
+                                                    *tlib#agent#PageDown()*
+tlib#agent#PageDown(world, selected)
+
+                                                    *tlib#agent#Home()*
+tlib#agent#Home(world, selected)
+
+                                                    *tlib#agent#End()*
+tlib#agent#End(world, selected)
+
+                                                    *tlib#agent#Up()*
+tlib#agent#Up(world, selected, ...)
+
+                                                    *tlib#agent#Down()*
+tlib#agent#Down(world, selected, ...)
+
+                                                    *tlib#agent#UpN()*
+tlib#agent#UpN(world, selected)
+
+                                                    *tlib#agent#DownN()*
+tlib#agent#DownN(world, selected)
+
+                                                    *tlib#agent#ShiftLeft()*
+tlib#agent#ShiftLeft(world, selected)
+
+                                                    *tlib#agent#ShiftRight()*
+tlib#agent#ShiftRight(world, selected)
+
+                                                    *tlib#agent#Reset()*
+tlib#agent#Reset(world, selected)
+
+                                                    *tlib#agent#ToggleRestrictView()*
+tlib#agent#ToggleRestrictView(world, selected)
+
+                                                    *tlib#agent#RestrictView()*
+tlib#agent#RestrictView(world, selected)
+
+                                                    *tlib#agent#UnrestrictView()*
+tlib#agent#UnrestrictView(world, selected)
+
+                                                    *tlib#agent#Input()*
+tlib#agent#Input(world, selected)
+
+                                                    *tlib#agent#SuspendToParentWindow()*
+tlib#agent#SuspendToParentWindow(world, selected)
+    Suspend (see |tlib#agent#Suspend|) the input loop and jump back to the 
+    original position in the parent window.
+
+                                                    *tlib#agent#Suspend()*
+tlib#agent#Suspend(world, selected)
+    Suspend lets you temporarily leave the input loop of 
+    |tlib#input#List|. You can resume editing the list by pressing <c-z>, 
+    <m-z>. <space>, <c-LeftMouse> or <MiddleMouse> in the suspended window.
+    <cr> and <LeftMouse> will immediatly select the item under the cursor.
+    < will select the item but the window will remain opened.
+
+                                                    *tlib#agent#Help()*
+tlib#agent#Help(world, selected)
+
+                                                    *tlib#agent#OR()*
+tlib#agent#OR(world, selected)
+
+                                                    *tlib#agent#AND()*
+tlib#agent#AND(world, selected)
+
+                                                    *tlib#agent#ReduceFilter()*
+tlib#agent#ReduceFilter(world, selected)
+
+                                                    *tlib#agent#PopFilter()*
+tlib#agent#PopFilter(world, selected)
+
+                                                    *tlib#agent#Debug()*
+tlib#agent#Debug(world, selected)
+
+                                                    *tlib#agent#Select()*
+tlib#agent#Select(world, selected)
+
+                                                    *tlib#agent#SelectUp()*
+tlib#agent#SelectUp(world, selected)
+
+                                                    *tlib#agent#SelectDown()*
+tlib#agent#SelectDown(world, selected)
+
+                                                    *tlib#agent#SelectAll()*
+tlib#agent#SelectAll(world, selected)
+
+                                                    *tlib#agent#ToggleStickyList()*
+tlib#agent#ToggleStickyList(world, selected)
+
+                                                    *tlib#agent#EditItem()*
+tlib#agent#EditItem(world, selected)
+
+                                                    *tlib#agent#NewItem()*
+tlib#agent#NewItem(world, selected)
+    Insert a new item below the current one.
+
+                                                    *tlib#agent#DeleteItems()*
+tlib#agent#DeleteItems(world, selected)
+
+                                                    *tlib#agent#Cut()*
+tlib#agent#Cut(world, selected)
+
+                                                    *tlib#agent#Copy()*
+tlib#agent#Copy(world, selected)
+
+                                                    *tlib#agent#Paste()*
+tlib#agent#Paste(world, selected)
+
+                                                    *tlib#agent#EditReturnValue()*
+tlib#agent#EditReturnValue(world, rv)
+
+                                                    *tlib#agent#ViewFile()*
+tlib#agent#ViewFile(world, selected)
+
+                                                    *tlib#agent#EditFile()*
+tlib#agent#EditFile(world, selected)
+
+                                                    *tlib#agent#EditFileInSplit()*
+tlib#agent#EditFileInSplit(world, selected)
+
+                                                    *tlib#agent#EditFileInVSplit()*
+tlib#agent#EditFileInVSplit(world, selected)
+
+                                                    *tlib#agent#EditFileInTab()*
+tlib#agent#EditFileInTab(world, selected)
+
+                                                    *tlib#agent#ToggleScrollbind()*
+tlib#agent#ToggleScrollbind(world, selected)
+
+                                                    *tlib#agent#ShowInfo()*
+tlib#agent#ShowInfo(world, selected)
+
+                                                    *tlib#agent#PreviewLine()*
+tlib#agent#PreviewLine(world, selected)
+
+                                                    *tlib#agent#GotoLine()*
+tlib#agent#GotoLine(world, selected)
+    If not called from the scratch, we assume/guess that we don't have to 
+    suspend the input-evaluation loop.
+
+                                                    *tlib#agent#DoAtLine()*
+tlib#agent#DoAtLine(world, selected)
+
+                                                    *tlib#agent#Wildcard()*
+tlib#agent#Wildcard(world, selected)
+
+                                                    *tlib#agent#Null()*
+tlib#agent#Null(world, selected)
+
+                                                    *tlib#agent#ExecAgentByName()*
+tlib#agent#ExecAgentByName(world, selected)
+
+                                                    *tlib#agent#CompleteAgentNames()*
+tlib#agent#CompleteAgentNames(ArgLead, CmdLine, CursorPos)
+
+                                                    *tlib#agent#Complete()*
+tlib#agent#Complete(world, selected)
+
+
+========================================================================
+autoload/tlib/bitwise.vim~
+
+                                                    *tlib#bitwise#Num2Bits()*
+tlib#bitwise#Num2Bits(num)
+
+                                                    *tlib#bitwise#Bits2Num()*
+tlib#bitwise#Bits2Num(bits, ...)
+
+                                                    *tlib#bitwise#AND()*
+tlib#bitwise#AND(num1, num2, ...)
+
+                                                    *tlib#bitwise#OR()*
+tlib#bitwise#OR(num1, num2, ...)
+
+                                                    *tlib#bitwise#XOR()*
+tlib#bitwise#XOR(num1, num2, ...)
+
+                                                    *tlib#bitwise#ShiftRight()*
+tlib#bitwise#ShiftRight(bits, n)
+
+                                                    *tlib#bitwise#ShiftLeft()*
+tlib#bitwise#ShiftLeft(bits, n)
+
+                                                    *tlib#bitwise#Add()*
+tlib#bitwise#Add(num1, num2, ...)
+
+                                                    *tlib#bitwise#Sub()*
+tlib#bitwise#Sub(num1, num2, ...)
+
+
+========================================================================
+autoload/tlib/url.vim~
+
+                                                    *tlib#url#Decode()*
+tlib#url#Decode(url)
+    Decode an encoded URL.
+
+                                                    *tlib#url#DecodeChar()*
+tlib#url#DecodeChar(char)
+    Decode a single character.
+
+                                                    *tlib#url#EncodeChar()*
+tlib#url#EncodeChar(char)
+    Encode a single character.
+
+                                                    *tlib#url#Encode()*
+tlib#url#Encode(url, ...)
+    Encode an URL.
+
+
+========================================================================
+autoload/tlib/signs.vim~
+
+                                                    *tlib#signs#ClearAll()*
+tlib#signs#ClearAll(sign)
+    Clear all signs with name SIGN.
+
+                                                    *tlib#signs#ClearBuffer()*
+tlib#signs#ClearBuffer(sign, bufnr)
+    Clear all signs with name SIGN in buffer BUFNR.
+
+                                                    *tlib#signs#Mark()*
+tlib#signs#Mark(sign, list)
+    Add signs for all locations in LIST. LIST must adhere with the 
+    quickfix list format (see |getqflist()|; only the fields lnum and 
+    bufnr are required).
+
+    list:: a quickfix or location list
+    sign:: a sign defined with |:sign-define|
+
+
+========================================================================
+autoload/tlib/rx.vim~
+
+                                                    *tlib#rx#Escape()*
+tlib#rx#Escape(text, ?magic='m')
+    magic can be one of: m, M, v, V
+    See :help 'magic'
+
+                                                    *tlib#rx#EscapeReplace()*
+tlib#rx#EscapeReplace(text, ?magic='m')
+    Escape return |sub-replace-special|.
+
+                                                    *tlib#rx#Suffixes()*
+tlib#rx#Suffixes(...)
+
+                                                    *tlib#rx#LooksLikeRegexp()*
+tlib#rx#LooksLikeRegexp(text)
+
+
+========================================================================
+autoload/tlib/tag.vim~
+
+                                                    *g:tlib_tags_extra*
+g:tlib_tags_extra              (default: '')
+    Extra tags for |tlib#tag#Retrieve()| (see there). Can also be buffer-local.
+
+                                                    *g:tlib_tag_substitute*
+g:tlib_tag_substitute
+    Filter the tag description through |substitute()| for these filetypes. 
+    This applies only if the tag cmd field (see |taglist()|) is used.
+
+                                                    *tlib#tag#Retrieve()*
+tlib#tag#Retrieve(rx, ?extra_tags=0)
+    Get all tags matching rx. Basically, this function simply calls 
+    |taglist()|, but when extra_tags is true, the list of the tag files 
+    (see 'tags') is temporarily expanded with |g:tlib_tags_extra|.
+
+    Example use:
+    If you want to include tags for, eg, JDK, normal tags use can become 
+    slow. You could proceed as follows:
+        1. Create a tags file for the JDK sources. When creating the tags 
+        file, make sure to include inheritance information and the like 
+        (command-line options like --fields=+iaSm --extra=+q should be ok).
+        In this example, we want tags only for public methods (there are 
+        most likely better ways to do this): >
+             ctags -R --fields=+iaSm --extra=+q ${JAVA_HOME}/src
+             head -n 6 tags > tags0
+             grep access:public tags >> tags0
+<      2. Make 'tags' include project specific tags files. In 
+         ~/vimfiles/after/ftplugin/java.vim insert: >
+             let b:tlib_tags_extra = $JAVA_HOME .'/tags0'
+<      3. When this function is invoked as >
+             echo tlib#tag#Retrieve('print')
+<      it will return only project-local tags. If it is invoked as >
+             echo tlib#tag#Retrieve('print', 1)
+<      tags from the JDK will be included.
+
+                                                    *tlib#tag#Collect()*
+tlib#tag#Collect(constraints, ?use_extra=1, ?match_front=1)
+    Retrieve tags that meet the constraints (a dictionnary of fields and 
+    regexp, with the exception of the kind field which is a list of chars). 
+    For the use of the optional use_extra argument see 
+    |tlib#tag#Retrieve()|.
+
+                                                    *tlib#tag#Format()*
+tlib#tag#Format(tag)
+
+
+========================================================================
+autoload/tlib/map.vim~
+
+                                                    *tlib#map#PumAccept()*
+tlib#map#PumAccept(key)
+    If |pumvisible()| is true, return "\<c-y>". Otherwise return a:key.
+    For use in maps like: >
+      imap <expr> <cr> tlib#map#PumAccept("\<cr>")
+<
+
+
+========================================================================
+autoload/tlib/Filter_cnfd.vim~
+
+                                                    *tlib#Filter_cnfd#New()*
+tlib#Filter_cnfd#New(...)
+    The same as |tlib#Filter_cnf#New()| but a dot is expanded to '\.\{-}'. 
+    As a consequence, patterns cannot match dots.
+    The pattern is a '/\V' very no-'/magic' regexp pattern.
+
+
+========================================================================
+autoload/tlib/input.vim~
+Input-related, select from a list etc.
+
+                                                    *g:tlib#input#sortprefs_threshold*
+g:tlib#input#sortprefs_threshold (default: 200)
+    If a list is bigger than this value, don't try to be smart when 
+    selecting an item. Be slightly faster instead.
+    See |tlib#input#List()|.
+
+                                                    *g:tlib#input#livesearch_threshold*
+g:tlib#input#livesearch_threshold (default: 1000)
+    If a list contains more items, |tlib#input#List()| does not perform an 
+    incremental "live search" but uses |input()| to query the user for a 
+    filter. This is useful on slower machines or with very long lists.
+
+                                                    *g:tlib#input#filter_mode*
+g:tlib#input#filter_mode       (default: 'glob')
+    Determine how |tlib#input#List()| and related functions work.
+    Can be "glob", "cnf", "cnfd", "seq", or "fuzzy". See:
+      glob ... Like cnf but "*" and "?" (see |g:tlib#Filter_glob#seq|, 
+          |g:tlib#Filter_glob#char|) are interpreted as glob-like 
+          |wildcards| (this is the default method)
+        - Examples:
+            - "f*o" matches "fo", "fxo", and "fxxxoo", but doesn't match 
+              "far".
+        - Otherwise it is a derivate of the cnf method (see below).
+        - See also |tlib#Filter_glob#New()|.
+      cnfd ... Like cnf but "." is interpreted as a wildcard, i.e. it is 
+               expanded to "\.\{-}"
+        - A period character (".") acts as a wildcard as if ".\{-}" (see 
+          |/\{-|) were entered.
+        - Examples:
+            - "f.o" matches "fo", "fxo", and "fxxxoo", but doesn't match 
+              "far".
+        - Otherwise it is a derivate of the cnf method (see below).
+        - See also |tlib#Filter_cnfd#New()|.
+      cnf .... Match substrings
+        - A blank creates an AND conjunction, i.e. the next pattern has to 
+          match too.
+        - A pipe character ("|") creates an OR conjunction, either this or 
+          the next next pattern has to match.
+        - Patterns are very 'nomagic' |regexp| with a |\V| prefix.
+        - A pattern starting with "-" makes the filter exclude items 
+          matching that pattern.
+        - Examples:
+            - "foo bar" matches items that contain the strings "foo" AND 
+              "bar".
+            - "foo|bar boo|far" matches items that contain either ("foo" OR 
+              "bar") AND ("boo" OR "far").
+        - See also |tlib#Filter_cnf#New()|.
+      seq .... Match sequences of characters
+        - |tlib#Filter_seq#New()|
+      fuzzy .. Match fuzzy character sequences
+        - |tlib#Filter_fuzzy#New()|
+
+                                                    *g:tlib#input#higroup*
+g:tlib#input#higroup           (default: 'IncSearch')
+    The highlight group to use for showing matches in the input list 
+    window.
+    See |tlib#input#List()|.
+
+                                                    *g:tlib_pick_last_item*
+g:tlib_pick_last_item          (default: 1)
+    When 1, automatically select the last remaining item only if the list 
+    had only one item to begin with.
+    When 2, automatically select a last remaining item after applying 
+    any filters.
+    See |tlib#input#List()|.
+
+
+Keys for |tlib#input#List|~
+
+                                                    *g:tlib#input#and*
+g:tlib#input#and               (default: ' ')
+
+                                                    *g:tlib#input#or*
+g:tlib#input#or                (default: '|')
+
+                                                    *g:tlib#input#not*
+g:tlib#input#not               (default: '-')
+
+                                                    *g:tlib#input#numeric_chars*
+g:tlib#input#numeric_chars
+    When editing a list with |tlib#input#List|, typing these numeric chars 
+    (as returned by getchar()) will select an item based on its index, not 
+    based on its name. I.e. in the default setting, typing a "4" will 
+    select the fourth item, not the item called "4".
+    In order to make keys 0-9 filter the items in the list and make 
+    <m-[0-9]> select an item by its index, remove the keys 48 to 57 from 
+    this dictionary.
+    Format: [KEY] = BASE ... the number is calculated as KEY - BASE.
+
+                                                    *g:tlib#input#keyagents_InputList_s*
+g:tlib#input#keyagents_InputList_s
+    The default key bindings for single-item-select list views.
+
+    This variable is best customized via the variable 
+    g:tlib_extend_keyagents_InputList_s. If you want to use <c-j>, <c-k> 
+    to move the cursor up and down, add these two lines to your |vimrc| 
+    file:
+
+      let g:tlib_extend_keyagents_InputList_s = {
+          \ 10: 'tlib#agent#Down',
+          \ 11: 'tlib#agent#Up'
+          \ }
+
+                                                    *g:tlib#input#keyagents_InputList_m*
+g:tlib#input#keyagents_InputList_m
+
+                                                    *g:tlib#input#handlers_EditList*
+g:tlib#input#handlers_EditList
+
+                                                    *g:tlib#input#user_shortcuts*
+g:tlib#input#user_shortcuts    (default: {})
+    A dictionary KEY => {'agent': AGENT, 'key_name': KEY_NAME} to 
+    customize keyboard shortcuts in the list view.
+
+                                                    *g:tlib#input#use_popup*
+g:tlib#input#use_popup         (default: has('menu') && (has('gui_gtk') || has('gui_gtk2') || has('gui_win32')))
+    If true, define a popup menu for |tlib#input#List()| and related 
+    functions.
+
+                                                    *g:tlib#input#format_filename*
+g:tlib#input#format_filename   (default: 'l')
+    How to format filenames:
+        l ... Show basenames on the left side, separated from the 
+              directory names
+        r ... Show basenames on the right side
+
+                                                    *g:tlib#input#filename_padding_r*
+g:tlib#input#filename_padding_r (default: '&co / 10')
+    If g:tlib#input#format_filename == 'r', how much space should be kept 
+    free on the right side.
+
+                                                    *g:tlib#input#filename_max_width*
+g:tlib#input#filename_max_width (default: '&co / 2')
+    If g:tlib#input#format_filename == 'l', an expression that 
+    |eval()|uates to the maximum display width of filenames.
+
+                                                    *tlib#input#List()*
+tlib#input#List(type. ?query='', ?list=[], ?handlers=[], ?default="", ?timeout=0)
+    Select a single or multiple items from a list. Return either the list 
+    of selected elements or its indexes.
+
+    By default, typing numbers will select an item by its index. See 
+    |g:tlib#input#numeric_chars| to find out how to change this.
+
+    The item is automatically selected if the numbers typed equals the 
+    number of digits of the list length. I.e. if a list contains 20 items, 
+    typing 1 will first highlight item 1 but it won't select/use it 
+    because 1 is an ambiguous input in this context. If you press enter, 
+    the first item will be selected. If you press another digit (e.g. 0), 
+    item 10 will be selected. Another way to select item 1 would be to 
+    type 01. If the list contains only 9 items, typing 1 would select the 
+    first item right away.
+
+    type can be:
+        s  ... Return one selected element
+        si ... Return the index of the selected element
+        m  ... Return a list of selected elements
+        mi ... Return a list of indexes
+
+    Several pattern matching styles are supported. See 
+    |g:tlib#input#filter_mode|.
+
+    Users can type <Tab> to complete the current filter with the longest 
+    match.
+
+    EXAMPLES: >
+      echo tlib#input#List('s', 'Select one item', [100,200,300])
+      echo tlib#input#List('si', 'Select one item', [100,200,300])
+      echo tlib#input#List('m', 'Select one or more item(s)', [100,200,300])
+      echo tlib#input#List('mi', 'Select one or more item(s)', [100,200,300])
+
+<   See ../samples/tlib/input/tlib_input_list.vim (move the cursor over 
+    the filename and press gf) for a more elaborated example.
+
+                                                    *tlib#input#ListD()*
+tlib#input#ListD(dict)
+    A wrapper for |tlib#input#ListW()| that builds |tlib#World#New| from 
+    dict.
+
+                                                    *tlib#input#ListW()*
+tlib#input#ListW(world, ?command='')
+    The second argument (command) is meant for internal use only.
+    The same as |tlib#input#List| but the arguments are packed into world 
+    (an instance of tlib#World as returned by |tlib#World#New|).
+
+                                                    *tlib#input#EditList()*
+tlib#input#EditList(query, list, ?timeout=0)
+    Edit a list.
+
+    EXAMPLES: >
+      echo tlib#input#EditList('Edit:', [100,200,300])
+<
+
+                                                    *tlib#input#Resume()*
+tlib#input#Resume(name, pick, bufnr)
+
+                                                    *tlib#input#CommandSelect()*
+tlib#input#CommandSelect(command, ?keyargs={})
+    Take a command, view the output, and let the user select an item from 
+    its output.
+
+    EXAMPLE: >
+        command! TMarks exec 'norm! `'. matchstr(tlib#input#CommandSelect('marks'), '^ \+\zs.')
+        command! TAbbrevs exec 'norm i'. matchstr(tlib#input#CommandSelect('abbrev'), '^\S\+\s\+\zs\S\+')
+<
+
+                                                    *tlib#input#Edit()*
+tlib#input#Edit(name, value, callback, ?cb_args=[])
+
+    Edit a value (asynchronously) in a scratch buffer. Use name for 
+    identification. Call callback when done (or on cancel).
+    In the scratch buffer:
+    Press <c-s> or <c-w><cr> to enter the new value, <c-w>c to cancel 
+    editing.
+    EXAMPLES: >
+      fun! FooContinue(success, text)
+          if a:success
+              let b:var = a:text
+          endif
+      endf
+      call tlib#input#Edit('foo', b:var, 'FooContinue')
+<
+
+                                                    *tlib#input#Dialog()*
+tlib#input#Dialog(text, options, default)
+
+
+========================================================================
+autoload/tlib/number.vim~
+
+                                                    *tlib#number#ConvertBase()*
+tlib#number#ConvertBase(num, base, ...)
+
+
+========================================================================
+autoload/tlib/file.vim~
+
+                                                    *g:tlib#file#drop*
+g:tlib#file#drop               (default: has('gui'))
+    If true, use |:drop| to edit loaded buffers (only available with GUI).
+
+                                                    *g:tlib#file#use_tabs*
+g:tlib#file#use_tabs           (default: 0)
+
+                                                    *g:tlib#file#edit_cmds*
+g:tlib#file#edit_cmds          (default: g:tlib#file#use_tabs ? {'buffer': 'tab split | buffer', 'edit': 'tabedit'} : {})
+
+                                                    *g:tlib#file#absolute_filename_rx*
+g:tlib#file#absolute_filename_rx (default: '^\~\?[\/]')
+
+                                                    *tlib#file#Split()*
+tlib#file#Split(filename)
+    EXAMPLES: >
+      tlib#file#Split('foo/bar/filename.txt')
+      => ['foo', 'bar', 'filename.txt']
+<
+
+                                                    *tlib#file#Join()*
+tlib#file#Join(filename_parts, ?strip_slashes=1, ?maybe_absolute=0)
+    EXAMPLES: >
+      tlib#file#Join(['foo', 'bar', 'filename.txt'])
+      => 'foo/bar/filename.txt'
+<
+
+                                                    *tlib#file#Relative()*
+tlib#file#Relative(filename, basedir)
+    EXAMPLES: >
+      tlib#file#Relative('foo/bar/filename.txt', 'foo')
+      => 'bar/filename.txt'
+<
+
+                                                    *tlib#file#IsAbsolute()*
+tlib#file#IsAbsolute(filename)
+
+                                                    *tlib#file#Absolute()*
+tlib#file#Absolute(filename, ...)
+
+                                                    *tlib#file#Canonic()*
+tlib#file#Canonic(filename, ...)
+
+                                                    *tlib#file#With()*
+tlib#file#With(fcmd, bcmd, files, ?world={})
+
+                                                    *tlib#file#Edit()*
+tlib#file#Edit(fileid)
+    Return 0 if the file isn't readable/doesn't exist.
+    Otherwise return 1.
+
+                                                    *tlib#file#Glob()*
+tlib#file#Glob(pattern)
+
+                                                    *tlib#file#Globpath()*
+tlib#file#Globpath(path, pattern)
+
+
+========================================================================
+autoload/tlib/sys.vim~
+
+                                                    *g:tlib#sys#special_protocols*
+g:tlib#sys#special_protocols   (default: ['https\?', 'nntp', 'mailto'])
+    A list of |regexp|s matching protocol names that should be handled 
+    by |g:tlib#sys#system_browser|.
+    CAVEAT: Must be a |\V| |regexp|.
+
+                                                    *g:tlib#sys#special_suffixes*
+g:tlib#sys#special_suffixes    (default: ['xlsx\?', 'docx\?', 'pptx\?', 'accdb', 'mdb', 'sqlite', 'pdf', 'jpg', 'png', 'gif', 'od\[tspg]'])
+    A list of |regexp|s matching suffixes that should be handled by 
+    |g:tlib#sys#system_browser|.
+    CAVEAT: Must be a |\V| |regexp|.
+
+                                                    *g:tlib#sys#system_rx*
+g:tlib#sys#system_rx           (default: printf('\V\%(\^\%(%s\):\|.\%(%s\)\$\)', join(g:tlib#sys#special_protocols, '\|'), join(g:tlib#sys#special_suffixes, '\|')))
+    Open links matching this |regexp| with |g:tlib#sys#system_browser|.
+    CAVEAT: Must be a |\V| |regexp|.
+
+                                                    *g:tlib#sys#system_browser*
+g:tlib#sys#system_browser      (default: ...)
+    Open files in the system browser.
+
+                                                    *g:tlib#sys#windows*
+g:tlib#sys#windows             (default: &shell !~ 'sh' && (has('win16') || has('win32') || has('win64')))
+
+                                                    *g:tlib#sys#null*
+g:tlib#sys#null                (default: g:tlib#sys#windows ? 'NUL' : (filereadable('/dev/null') ? '/dev/null' : ''))
+
+                                                    *tlib#sys#IsCygwinBin()*
+tlib#sys#IsCygwinBin(cmd)
+
+                                                    *tlib#sys#IsExecutable()*
+tlib#sys#IsExecutable(cmd, ...)
+
+                                                    *g:tlib#sys#check_cygpath*
+g:tlib#sys#check_cygpath       (default: g:tlib#sys#windows && tlib#sys#IsExecutable('cygpath', 1))
+    If true, check whether we have to convert a path via cyppath -- 
+    see |tlib#sys#MaybeUseCygpath|
+
+                                                    *g:tlib#sys#cygwin_path_rx*
+g:tlib#sys#cygwin_path_rx      (default: '/cygwin/')
+    If a full windows filename (with slashes instead of backslashes) 
+    matches this |regexp|, it is assumed to be a cygwin executable.
+
+                                                    *g:tlib#sys#cygwin_expr*
+g:tlib#sys#cygwin_expr         (default: '"bash -c ''". escape(%s, "''\\") ."''"')
+    For cygwin binaries, convert command calls using this vim 
+    expression.
+
+                                                    *tlib#sys#GetCmd()*
+tlib#sys#GetCmd(cmd)
+
+                                                    *tlib#sys#MaybeUseCygpath()*
+tlib#sys#MaybeUseCygpath(cmd)
+    If cmd seems to be a cygwin executable, use cygpath to convert 
+    filenames. This assumes that cygwin's which command returns full 
+    filenames for non-cygwin executables.
+
+                                                    *tlib#sys#ConvertPath()*
+tlib#sys#ConvertPath(converter, filename)
+
+                                                    *tlib#sys#FileArgs()*
+tlib#sys#FileArgs(cmd, files)
+
+                                                    *tlib#sys#IsSpecial()*
+tlib#sys#IsSpecial(filename)
+    Check whether filename matches |g:tlib#sys#system_rx|, i.e. whether it 
+    is a special file that should not be opened in vim.
+
+                                                    *tlib#sys#Open()*
+tlib#sys#Open(filename)
+    Open filename with the default OS application (see 
+    |g:tlib#sys#system_browser|), if |tlib#sys#IsSpecial()| return 1. 
+    Returns 1 if successful or 0 otherwise.
+
+                                                    *tlib#sys#SystemInDir()*
+tlib#sys#SystemInDir(dir, expr, ?input='')
+
+
+========================================================================
+autoload/tlib/paragraph.vim~
+
+                                                    *tlib#paragraph#GetMetric()*
+tlib#paragraph#GetMetric()
+    Return an object describing a |paragraph|.
+
+                                                    *tlib#paragraph#Move()*
+tlib#paragraph#Move(direction, count)
+    This function can be used with the tinymode plugin to move around 
+    paragraphs.
+
+    Example configuration: >
+
+      call tinymode#EnterMap("para_move", "gp")
+      call tinymode#ModeMsg("para_move", "Move paragraph: j/k")
+      call tinymode#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '[N]')")
+      call tinymode#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '[N]')")
+      call tinymode#ModeArg("para_move", "owncount", 1)
+<
+
+
+========================================================================
+autoload/tlib/World.vim~
+A prototype used by |tlib#input#List|.
+Inherits from |tlib#Object#New|.
+
+                                                    *g:tlib_inputlist_pct*
+g:tlib_inputlist_pct           (default: 50)
+    Size of the input list window (in percent) from the main size (of &lines).
+    See |tlib#input#List()|.
+
+                                                    *g:tlib_inputlist_width_filename*
+g:tlib_inputlist_width_filename (default: '&co / 3')
+    Size of filename columns when listing filenames.
+    See |tlib#input#List()|.
+
+                                                    *g:tlib_inputlist_filename_indicators*
+g:tlib_inputlist_filename_indicators (default: 0)
+    If true, |tlib#input#List()| will show some indicators about the 
+    status of a filename (e.g. buflisted(), bufloaded() etc.).
+    This is disabled by default because vim checks also for the file on 
+    disk when doing this.
+
+                                                    *g:tlib_inputlist_shortmessage*
+g:tlib_inputlist_shortmessage  (default: 0)
+    If not null, display only a short info about the filter.
+
+                                                    *tlib#World#New()*
+tlib#World#New(...)
+
+prototype.PrintLines
+
+prototype.Suspend
+
+
+========================================================================
+autoload/tlib/loclist.vim~
+
+                                                    *tlib#loclist#Browse()*
+tlib#loclist#Browse(...)
+
+
+========================================================================
+autoload/tlib/tab.vim~
+
+                                                    *tlib#tab#BufMap()*
+tlib#tab#BufMap()
+    Return a dictionary of bufnumbers => [[tabpage, winnr] ...]
+
+                                                    *tlib#tab#TabWinNr()*
+tlib#tab#TabWinNr(buffer)
+    Find a buffer's window at some tab page.
+
+                                                    *tlib#tab#Set()*
+tlib#tab#Set(tabnr)
+
+
+========================================================================
+autoload/tlib/date.vim~
+
+                                                    *tlib#date#IsDate()*
+tlib#date#IsDate(text)
+
+                                                    *tlib#date#Format()*
+tlib#date#Format(...)
+
+                                                    *tlib#date#DiffInDays()*
+tlib#date#DiffInDays(date1, ?date2=localtime(), ?allow_zero=0)
+
+                                                    *tlib#date#Parse()*
+tlib#date#Parse(date, ?allow_zero=0, ?silent=0) "{{{3
+
+                                                    *tlib#date#SecondsSince1970()*
+tlib#date#SecondsSince1970(date, ...)
+    tlib#date#SecondsSince1970(date, ?daysshift=0, ?allow_zero=0)
+
+                                                    *tlib#date#Shift()*
+tlib#date#Shift(date, shift)
+
+                                                    *tlib#date#AddDays()*
+tlib#date#AddDays(date, n)
+
+
+========================================================================
+autoload/tlib/type.vim~
+
+                                                    *tlib#type#Enable()*
+tlib#type#Enable()
+    Enable type assertiona via |:Tlibtype|.
+
+                                                    *tlib#type#Disable()*
+tlib#type#Disable()
+    Disable type assertiona via |:Tlibtype|.
+
+                                                    *tlib#type#IsNumber()*
+tlib#type#IsNumber(expr)
+
+                                                    *tlib#type#IsString()*
+tlib#type#IsString(expr)
+
+                                                    *tlib#type#IsFuncref()*
+tlib#type#IsFuncref(expr)
+
+                                                    *tlib#type#IsList()*
+tlib#type#IsList(expr)
+
+                                                    *tlib#type#IsDictionary()*
+tlib#type#IsDictionary(expr)
+
+                                                    *tlib#type#Is()*
+tlib#type#Is(val, type)
+
+                                                    *tlib#type#Are()*
+tlib#type#Are(vals, type)
+
+                                                    *tlib#type#Define()*
+tlib#type#Define(name, schema)
+
+                                                    *tlib#type#Has()*
+tlib#type#Has(val, schema)
+
+                                                    *tlib#type#Have()*
+tlib#type#Have(vals, schema)
+
+                                                    *tlib#type#Check()*
+tlib#type#Check(caller, names, vals)
+
+
+========================================================================
+autoload/tlib/Filter_fuzzy.vim~
+
+                                                    *tlib#Filter_fuzzy#New()*
+tlib#Filter_fuzzy#New(...)
+    Support for "fuzzy" pattern matching in |tlib#input#List()|. 
+    Patterns are interpreted as if characters were connected with '.\{-}'.
+
+    In "fuzzy" mode, the pretty printing of filenames is disabled.
+
+
+========================================================================
+autoload/tlib/assert.vim~
+
+                                                    *tlib#assert#Enable()*
+tlib#assert#Enable()
+    Enable tracing via |:Tlibassert|.
+
+                                                    *tlib#assert#Disable()*
+tlib#assert#Disable()
+    Disable tracing via |:Tlibassert|.
+
+                                                    *tlib#assert#Assert()*
+tlib#assert#Assert(caller, check, vals)
+
+                                                    *tlib#assert#Map()*
+tlib#assert#Map(vals, expr)
+
+                                                    *tlib#assert#All()*
+tlib#assert#All(vals)
+
+
+========================================================================
+autoload/tlib/textobjects.vim~
+
+                                                    *standard-paragraph*
+tlib#textobjects#StandardParagraph()
+    Select a "Standard Paragraph", i.e. a text block followed by blank 
+    lines. Other than |ap|, the last paragraph in a document is handled 
+    just the same.
+
+    The |text-object| can be accessed as "sp". Example: >
+
+      vsp ... select the current standard paragraph
+
+<   Return 1, if the paragraph is the last one in the document.
+
+                                                    *tlib#textobjects#Init()*
+tlib#textobjects#Init()
+
+                                                    *v_sp*
+v_sp ... <Esc>:call tlib#textobjects#StandardParagraph()<CR>
+    sp ... Standard paragraph (for use as |text-objects|).
+
+                                                    *o_sp*
+o_sp ... :<C-u>normal Vsp<CR>
+
+
+========================================================================
+autoload/tlib/arg.vim~
+
+                                                    *tlib#arg#Get()*
+tlib#arg#Get(n, var, ?default="", ?test='')
+    Set a positional argument from a variable argument list.
+    See tlib#string#RemoveBackslashes() for an example.
+
+                                                    *tlib#arg#Let()*
+tlib#arg#Let(list, ?default='')
+    Set a positional arguments from a variable argument list.
+    See tlib#input#List() for an example.
+
+                                                    *tlib#arg#StringAsKeyArgs()*
+tlib#arg#StringAsKeyArgs(string, ?keys=[], ?evaluate=0, ?sep=':', ?booleans=0)
+
+                                                    *tlib#arg#StringAsKeyArgsEqual()*
+tlib#arg#StringAsKeyArgsEqual(string)
+
+                                                    *tlib#arg#GetOpts()*
+tlib#arg#GetOpts(args, ?def={})
+    Convert a list of strings of command-line arguments into a dictonary.
+
+    The main use case is to pass [<f-args>], i.e. the command-line 
+    arguments of a command as list, from a command definition to this 
+    function.
+
+    Example:
+    ['-h']
+    => If def contains a 'help' key, invoke |:help| on its value.
+
+    ['-ab', '--foo', '--bar=BAR', 'bla', bla']
+    => {'a': 1, 'b': 1, 'foo': 1, 'bar': 'BAR', '__rest__': ['bla', 'bla']}
+
+    ['-ab', '--', '--foo', '--bar=BAR']
+    => {'a': 1, 'b': 1, '__rest__': ['--foo', '--bar=BAR']}
+
+                                                    *tlib#arg#Ex()*
+tlib#arg#Ex(arg, ?chars='%#! ')
+    Escape some characters in a string.
+
+    Use |fnamescape()| if available.
+
+    EXAMPLES: >
+      exec 'edit '. tlib#arg#Ex('foo%#bar.txt')
+<
+
+
+========================================================================
+autoload/tlib/fixes.vim~
+
+                                                    *tlib#fixes#Winpos()*
+tlib#fixes#Winpos()
+
+
+========================================================================
+autoload/tlib/dir.vim~
+
+                                                    *g:tlib#dir#sep*
+g:tlib#dir#sep                 (default: exists('+shellslash') && !&shellslash ? '\' : '/')
+    TLet g:tlib#dir#sep = '/'
+
+                                                    *tlib#dir#CanonicName()*
+tlib#dir#CanonicName(dirname)
+    EXAMPLES: >
+      tlib#dir#CanonicName('foo/bar')
+      => 'foo/bar/'
+<
+
+                                                    *tlib#dir#NativeName()*
+tlib#dir#NativeName(dirname)
+    EXAMPLES: >
+      tlib#dir#NativeName('foo/bar/')
+      On Windows:
+      => 'foo\bar\'
+      On Linux:
+      => 'foo/bar/'
+<
+
+                                                    *tlib#dir#PlainName()*
+tlib#dir#PlainName(dirname)
+    EXAMPLES: >
+      tlib#dir#PlainName('foo/bar/')
+      => 'foo/bar'
+<
+
+                                                    *tlib#dir#Ensure()*
+tlib#dir#Ensure(dir)
+    Create a directory if it doesn't already exist.
+
+                                                    *tlib#dir#MyRuntime()*
+tlib#dir#MyRuntime()
+    Return the first directory in &rtp.
+
+                                                    *tlib#dir#CD()*
+tlib#dir#CD(dir, ?locally=0)
+
+                                                    *tlib#dir#Push()*
+tlib#dir#Push(dir, ?locally=0)
+
+                                                    *tlib#dir#Pop()*
+tlib#dir#Pop()
+
+
+========================================================================
+autoload/tlib/hash.vim~
+
+                                                    *g:tlib#hash#use_crc32*
+g:tlib#hash#use_crc32          (default: '')
+
+                                                    *g:tlib#hash#use_adler32*
+g:tlib#hash#use_adler32        (default: '')
+
+                                                    *tlib#hash#CRC32B()*
+tlib#hash#CRC32B(chars)
+
+                                                    *tlib#hash#CRC32B_ruby()*
+tlib#hash#CRC32B_ruby(chars)
+
+                                                    *tlib#hash#CRC32B_vim()*
+tlib#hash#CRC32B_vim(chars)
+
+                                                    *tlib#hash#Adler32()*
+tlib#hash#Adler32(chars)
+
+                                                    *tlib#hash#Adler32_vim()*
+tlib#hash#Adler32_vim(chars)
+
+                                                    *tlib#hash#Adler32_tlib()*
+tlib#hash#Adler32_tlib(chars)
+
+
+========================================================================
+autoload/tlib/win.vim~
+
+                                                    *tlib#win#Set()*
+tlib#win#Set(winnr)
+    Return vim code to jump back to the original window.
+
+                                                    *tlib#win#GetLayout()*
+tlib#win#GetLayout(?save_view=0)
+
+                                                    *tlib#win#SetLayout()*
+tlib#win#SetLayout(layout)
+
+                                                    *tlib#win#List()*
+tlib#win#List()
+
+                                                    *tlib#win#Width()*
+tlib#win#Width(wnr)
+
+                                                    *tlib#win#WinDo()*
+tlib#win#WinDo(ex)
+
+
+========================================================================
+autoload/tlib/comments.vim~
+
+                                                    *tlib#comments#Comments()*
+tlib#comments#Comments(...)
+    function! tlib#comments#Comments(?rx='')
+
+
+========================================================================
+autoload/tlib/grep.vim~
+
+                                                    *tlib#grep#Do()*
+tlib#grep#Do(cmd, rx, files)
+
+                                                    *tlib#grep#LocList()*
+tlib#grep#LocList(rx, files)
+
+                                                    *tlib#grep#QuickFixList()*
+tlib#grep#QuickFixList(rx, files)
+
+                                                    *tlib#grep#List()*
+tlib#grep#List(rx, files)
+
+
+========================================================================
+autoload/tlib/qfl.vim~
+
+                                                    *tlib#qfl#FormatQFLE()*
+tlib#qfl#FormatQFLE(qfe)
+
+                                                    *tlib#qfl#QfeFilename()*
+tlib#qfl#QfeFilename(qfe)
+
+                                                    *tlib#qfl#InitListBuffer()*
+tlib#qfl#InitListBuffer(world)
+
+                                                    *tlib#qfl#SetSyntax()*
+tlib#qfl#SetSyntax()
+
+                                                    *tlib#qfl#Balloon()*
+tlib#qfl#Balloon()
+
+                                                    *tlib#qfl#AgentEditQFE()*
+tlib#qfl#AgentEditQFE(world, selected, ...)
+
+                                                    *tlib#qfl#AgentPreviewQFE()*
+tlib#qfl#AgentPreviewQFE(world, selected)
+
+                                                    *tlib#qfl#AgentGotoQFE()*
+tlib#qfl#AgentGotoQFE(world, selected)
+
+                                                    *tlib#qfl#AgentWithSelected()*
+tlib#qfl#AgentWithSelected(world, selected, ...)
+
+                                                    *tlib#qfl#RunCmdOnSelected()*
+tlib#qfl#RunCmdOnSelected(world, selected, cmd, ...)
+
+                                                    *tlib#qfl#AgentSplitBuffer()*
+tlib#qfl#AgentSplitBuffer(world, selected)
+
+                                                    *tlib#qfl#AgentTabBuffer()*
+tlib#qfl#AgentTabBuffer(world, selected)
+
+                                                    *tlib#qfl#AgentVSplitBuffer()*
+tlib#qfl#AgentVSplitBuffer(world, selected)
+
+                                                    *tlib#qfl#AgentEditLine()*
+tlib#qfl#AgentEditLine(world, selected)
+
+                                                    *tlib#qfl#EditLine()*
+tlib#qfl#EditLine(lnum)
+
+                                                    *tlib#qfl#SetFollowCursor()*
+tlib#qfl#SetFollowCursor(world, selected)
+
+                                                    *tlib#qfl#QflList()*
+tlib#qfl#QflList(list, ...)
+
+                                                    *tlib#qfl#Browse()*
+tlib#qfl#Browse(...)
+
+
+========================================================================
+autoload/tlib/Filter_cnf.vim~
+
+                                                    *tlib#Filter_cnf#New()*
+tlib#Filter_cnf#New(...)
+    The search pattern for |tlib#input#List()| is in conjunctive normal 
+    form: (P1 OR P2 ...) AND (P3 OR P4 ...) ...
+    The pattern is a '/\V' very no-'/magic' regexp pattern.
+
+    Pressing <space> joins two patterns with AND.
+    Pressing | joins two patterns with OR.
+    I.e. In order to get "lala AND (foo OR bar)", you type 
+    "lala foo|bar".
+
+    This is also the base class for other filters.
+
+prototype.Pretty
+
+
+========================================================================
+autoload/tlib/Object.vim~
+Provides a prototype plus some OO-like methods.
+
+                                                    *tlib#Object#New()*
+tlib#Object#New(?fields={})
+    This function creates a prototype that provides some kind of 
+    inheritance mechanism and a way to call parent/super methods.
+
+    The usage demonstrated in the following example works best when every 
+    class/prototype is defined in a file of its own.
+
+    The reason for why there is a dedicated constructor function is that 
+    this layout facilitates the use of templates and that methods are 
+    hidden from the user. Other solutions are possible.
+
+    EXAMPLES: >
+        let s:prototype = tlib#Object#New({
+                    \ '_class': ['FooBar'],
+                    \ 'foo': 1, 
+                    \ 'bar': 2, 
+                    \ })
+        " Constructor
+        function! FooBar(...)
+            let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+            return object
+        endf
+        function! s:prototype.babble() {
+          echo "I think, therefore I am ". (self.foo * self.bar) ." months old."
+        }
+
+<   This could now be used like this: >
+        let myfoo = FooBar({'foo': 3})
+        call myfoo.babble()
+        => I think, therefore I am 6 months old.
+        echo myfoo.IsA('FooBar')
+        => 1
+        echo myfoo.IsA('object')
+        => 1
+        echo myfoo.IsA('Foo')
+        => 0
+        echo myfoo.RespondTo('babble')
+        => 1
+        echo myfoo.RespondTo('speak')
+        => 0
+<
+
+prototype.New
+
+prototype.Inherit
+
+prototype.Extend
+
+prototype.IsA
+
+prototype.IsRelated
+
+prototype.RespondTo
+
+prototype.Super
+
+                                                    *tlib#Object#Methods()*
+tlib#Object#Methods(object, ...)
+
+
+========================================================================
+autoload/tlib/buffer.vim~
+
+                                                    *g:tlib_viewline_position*
+g:tlib_viewline_position       (default: 'zz')
+    Where to display the line when using |tlib#buffer#ViewLine|.
+    For possible values for position see |scroll-cursor|.
+
+                                                    *tlib#buffer#EnableMRU()*
+tlib#buffer#EnableMRU()
+
+                                                    *tlib#buffer#DisableMRU()*
+tlib#buffer#DisableMRU()
+
+                                                    *tlib#buffer#Set()*
+tlib#buffer#Set(buffer)
+    Set the buffer to buffer and return a command as string that can be 
+    evaluated by |:execute| in order to restore the original view.
+
+                                                    *tlib#buffer#Eval()*
+tlib#buffer#Eval(buffer, code)
+    Evaluate CODE in BUFFER.
+
+    EXAMPLES: >
+      call tlib#buffer#Eval('foo.txt', 'echo b:bar')
+<
+
+                                                    *tlib#buffer#GetList()*
+tlib#buffer#GetList(?show_hidden=0, ?show_number=0, " ?order='bufnr')
+    Possible values for the "order" argument:
+      bufnr    :: Default behaviour
+      mru      :: Sort buffers according to most recent use
+      basename :: Sort by the file's basename (last component)
+
+    NOTE: MRU order works on second invocation only. If you want to always 
+    use MRU order, call tlib#buffer#EnableMRU() in your ~/.vimrc file.
+
+                                                    *tlib#buffer#ViewLine()*
+tlib#buffer#ViewLine(line, ?position='z')
+    line is either a number or a string that begins with a number.
+    For possible values for position see |scroll-cursor|.
+    See also |g:tlib_viewline_position|.
+
+                                                    *tlib#buffer#HighlightLine()*
+tlib#buffer#HighlightLine(...)
+
+                                                    *tlib#buffer#DeleteRange()*
+tlib#buffer#DeleteRange(line1, line2)
+    Delete the lines in the current buffer. Wrapper for |:delete|.
+
+                                                    *tlib#buffer#ReplaceRange()*
+tlib#buffer#ReplaceRange(line1, line2, lines)
+    Replace a range of lines.
+
+                                                    *tlib#buffer#ScratchStart()*
+tlib#buffer#ScratchStart()
+    Initialize some scratch area at the bottom of the current buffer.
+
+                                                    *tlib#buffer#ScratchEnd()*
+tlib#buffer#ScratchEnd()
+    Remove the in-buffer scratch area.
+
+                                                    *tlib#buffer#BufDo()*
+tlib#buffer#BufDo(exec)
+    Run exec on all buffers via bufdo and return to the original buffer.
+
+                                                    *tlib#buffer#InsertText()*
+tlib#buffer#InsertText(text, keyargs)
+    Keyargs:
+      'shift': 0|N
+      'col': col('.')|N
+      'lineno': line('.')|N
+      'indent': 0|1
+      'pos': 'e'|'s' ... Where to locate the cursor (somewhat like s and e in {offset})
+    Insert text (a string) in the buffer.
+
+                                                    *tlib#buffer#InsertText0()*
+tlib#buffer#InsertText0(text, ...)
+
+                                                    *tlib#buffer#CurrentByte()*
+tlib#buffer#CurrentByte()
+
+                                                    *tlib#buffer#KeepCursorPosition()*
+tlib#buffer#KeepCursorPosition(cmd)
+    Evaluate cmd while maintaining the cursor position and jump registers.
+
+
+========================================================================
+autoload/tlib/hook.vim~
+
+                                                    *tlib#hook#Run()*
+tlib#hook#Run(hook, ?dict={})
+    Execute dict[hook], w:{hook}, b:{hook}, or g:{hook} if existent.
+
+
+========================================================================
+autoload/tlib/string.vim~
+
+                                                    *tlib#string#RemoveBackslashes()*
+tlib#string#RemoveBackslashes(text, ?chars=' ')
+    Remove backslashes from text (but only in front of the characters in 
+    chars).
+
+                                                    *tlib#string#Chomp()*
+tlib#string#Chomp(string, ?max=0)
+
+                                                    *tlib#string#Format()*
+tlib#string#Format(template, dict)
+    Format a template string. Placeholders have the format "%{NAME}". A 
+    "%" can be inserted as "%%".
+
+    Examples:
+      echo tlib#string#Format("foo %{bar} foo", {'bar': 123})
+      => foo 123 foo
+
+                                                    *tlib#string#Printf1()*
+tlib#string#Printf1(format, string)
+    This function deviates from |printf()| in certain ways.
+    Additional items:
+        %{rx}      ... insert escaped regexp
+        %{fuzzyrx} ... insert typo-tolerant regexp
+
+                                                    *tlib#string#TrimLeft()*
+tlib#string#TrimLeft(string)
+
+                                                    *tlib#string#TrimRight()*
+tlib#string#TrimRight(string)
+
+                                                    *tlib#string#Strip()*
+tlib#string#Strip(string)
+
+                                                    *tlib#string#Count()*
+tlib#string#Count(string, rx)
+
+                                                    *tlib#string#SplitCommaList()*
+tlib#string#SplitCommaList(text, ...)
+
+                                                    *tlib#string#Input()*
+tlib#string#Input(...)
+
+
+
+vim:tw=78:fo=w2croql:isk=!-~,^*,^|,^":ts=8:ft=help:norl:
diff --git a/vim/.vim/bundle/snipmate-tlib/etc/tpl_tlib.txt b/vim/.vim/bundle/snipmate-tlib/etc/tpl_tlib.txt
new file mode 100644
index 0000000..f805970
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/etc/tpl_tlib.txt
@@ -0,0 +1,30 @@
+*tlib.txt*  tlib -- A library of vim functions
+            Author: Tom Link, micathom at gmail com
+
+This library provides some utility functions. There isn't much need to 
+install it unless another plugin requires you to do so.
+
+Most of the library is included in autoload files. No autocommands are 
+created. With the exception of loading ../plugin/02tlib.vim at startup 
+the library has no impact on startup time or anything else.
+
+The change-log is included at the bottom of ../plugin/02tlib.vim
+(move the cursor over the file name and type gfG)
+
+Demo of |tlib#input#List()|: 
+http://vimsomnia.blogspot.com/2010/11/selecting-items-from-list-with-tlibs.html
+
+
+-----------------------------------------------------------------------
+Install~
+
+Edit the vba file and type: >
+
+    :so %
+
+See :help vimball for details. If you have difficulties, please make 
+sure, you have the current version of vimball (vimscript #1502) 
+installed.
+
+
+%s
diff --git a/vim/.vim/bundle/snipmate-tlib/macros/tlib.vim b/vim/.vim/bundle/snipmate-tlib/macros/tlib.vim
new file mode 100644
index 0000000..3e5a791
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/macros/tlib.vim
@@ -0,0 +1,38 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @GIT:         http://github.com/tomtom/tlib_vim/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2015-11-09.
+" @Revision:    10
+
+if &cp || exists("loaded_tlib_macros")
+    finish
+endif
+let loaded_tlib_macros = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :display: :TRequire NAME [VERSION [FILE]]
+" Make a certain vim file is loaded.
+"
+" Conventions: If FILE isn't defined, plugin/NAME.vim is loaded. The 
+" file must provide a variable loaded_{NAME} that represents the version 
+" number.
+command! -nargs=+ TRequire let s:require = [<f-args>]
+            \ | if !exists('loaded_'. get(s:require, 0))
+                \ | exec 'runtime '. get(s:require, 2, 'plugin/'. get(s:require, 0) .'.vim')
+                \ | if !exists('loaded_'. get(s:require, 0)) || loaded_{get(s:require, 0)} < get(s:require, 1, loaded_{get(s:require, 0)})
+                    \ | echoerr 'Require '.  get(s:require, 0) .' >= '. get(s:require, 1, 'any version will do')
+                    \ | finish
+                    \ | endif
+                \ | endif | unlet s:require
+
+
+" :display: :Ttimecommand CMD
+" Time the execution time of CMD.
+command! -nargs=1 -complete=command Ttimecommand call tlib#cmd#Time(<q-args>)
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/plugin/02tlib.vim b/vim/.vim/bundle/snipmate-tlib/plugin/02tlib.vim
new file mode 100755
index 0000000..9913706
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/plugin/02tlib.vim
@@ -0,0 +1,108 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Created:     2007-04-10.
+" @Last Change: 2016-07-28.
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    817
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" GetLatestVimScripts: 1863 1 tlib.vim
+" tlib.vim -- Some utility functions
+
+if &cp || exists("g:loaded_tlib")
+    finish
+endif
+if v:version < 700 "{{{2
+    echoerr "tlib requires Vim >= 7"
+    finish
+endif
+let g:loaded_tlib = 122
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :display: :TLet VAR = VALUE
+" Set a variable only if it doesn't already exist.
+" EXAMPLES: >
+"   TLet foo = 1
+"   TLet foo = 2
+"   echo foo
+"   => 1
+command! -nargs=+ TLet if !exists(matchstr(<q-args>, '^[^=[:space:]]\+')) | exec 'let '. <q-args> | endif
+
+
+" Open a scratch buffer (a buffer without a file).
+"   TScratch  ... use split window
+"   TScratch! ... use the whole frame
+" This command takes an (inner) dictionary as optional argument.
+" EXAMPLES: >
+"   TScratch 'scratch': '__FOO__'
+"   => Open a scratch buffer named __FOO__
+command! -bar -nargs=* -bang TScratch call tlib#scratch#UseScratch({'scratch_split': empty('<bang>'), <args>})
+
+
+" :display: :TVarArg VAR1, [VAR2, DEFAULT2] ...
+" A convenience wrapper for |tlib#arg#Let|.
+" EXAMPLES: >
+"   function! Foo(...)
+"       TVarArg ['a', 1], 'b'
+"       echo 'a='. a
+"       echo 'b='. b
+"   endf
+command! -nargs=+ TVarArg exec tlib#arg#Let([<args>])
+
+
+" :display: :TBrowseOutput COMMAND
+" Ever wondered how to efficiently browse the output of a command 
+" without redirecting it to a file? This command takes a command as 
+" argument and presents the output via |tlib#input#List()| so that you 
+" can easily search for a keyword (e.g. the name of a variable or 
+" function) and the like.
+"
+" If you press enter, the selected line will be copied to the command 
+" line. Press ESC to cancel browsing.
+"
+" EXAMPLES: >
+"   TBrowseOutput 20verb TeaseTheCulprit
+command! -nargs=1 -complete=command TBrowseOutput call tlib#cmd#BrowseOutput(<q-args>)
+
+
+" :display: :TBrowseScriptnames
+" List all sourced script names (the output of ':scriptnames').
+"
+" When you press enter, the selected script will be opened in the current
+" window. Press ESC to cancel.
+"
+" EXAMPLES: >
+"   TBrowseScriptnames 
+command! -nargs=0 -complete=command TBrowseScriptnames call tlib#cmd#TBrowseScriptnames()
+
+
+" :display: :Tlibtrace GUARD, VAR1, VAR2...
+" Do nothing unless |tlib#trace#Enable()| was called.
+" 
+" When |:Tlibtraceset| or |tlib#trace#Enable()| were called:
+"
+" If GUARD is a number that evaluates to true or if it is a string that 
+" matches a |regexp|, which was added using Tlibtrace! (with '!'), 
+" display the values of VAR1, VAR2 ...
+command! -nargs=+ -bang Tlibtrace :
+
+
+" :Tlibtraceset +RX1, -RX2...
+" If |tlib#trace#Enable()| was called: With the optional <bang>, users 
+" can add and remove GUARDs (actually a |regexp|) that should be traced.
+"
+" If no `+` or `-` is prepended, assume `+`.
+command! -nargs=+ -bang Tlibtraceset call tlib#trace#Set(<q-args>)
+
+
+" :display: :Tlibtrace ASSERTION
+command! -nargs=+ -bang Tlibassert :
+
+" :display: :Tlibtype val, 'type', ...
+command! -nargs=+ Tlibtype :
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/samples/tlib/input/tlib_input_list.vim b/vim/.vim/bundle/snipmate-tlib/samples/tlib/input/tlib_input_list.vim
new file mode 100644
index 0000000..4d668ff
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/samples/tlib/input/tlib_input_list.vim
@@ -0,0 +1,50 @@
+" The following variable configures the way |tlib#input#ListD()| works. 
+" In this example, we allow selection of multiple items (we could also 
+" allow only a single choice and make |tlib#input#ListD()| work on the 
+" indices, not the items).
+"
+" We also set a prompt that will be displayed in the command area.
+"
+" By default, |tlib#input#ListD()| will automatically select an item if 
+" there is only one item left matching the filter. In this example, we 
+" disable this feature.
+"
+" For demonstration purposes, we also define a key handler that prints 
+" the selected items.
+let s:state = {
+            \ 'type': 'm',
+            \ 'query': 'Select lines for command output',
+            \ 'pick_last_item': 0,
+            \ 'key_handlers': [
+                \ {'key': 16, 'agent': 'PrintMe', 'key_name': '<c-p>', 'help': 'Print line'},
+            \ ],
+            \ }
+
+" A key handler takes two arguments: the current state of the list 
+" display and a list of selected items/indices (depending on the type 
+" parameter).
+function! PrintMe(state, items) "{{{3
+    echom "You selected:"
+    for i in a:items
+        echom i
+    endfor
+    call input("Press ENTER to continue")
+    let a:state.state = 'redisplay'
+    return a:state
+endf
+
+" In this example, we evaluate an ex-command with |:execute| and display 
+" the command's output as list. The user can select certain lines by 
+" typing some pattern or by pressing <a-NUMBER> to select an item by 
+" number. The user can then press <c-p> to print the lines (see above) 
+" or <cr> to pick the selected lines.
+function! SelectOutput(ex) "{{{3
+    redir => lines
+    silent exec a:ex
+    redir END
+    let state = copy(s:state)
+    let state.base = split(lines, '\n')
+    let picked = tlib#input#ListD(state)
+    echom "You picked: ". join(picked, ', ')
+endf
+
diff --git a/vim/.vim/bundle/snipmate-tlib/scripts/create_crc_table.rb b/vim/.vim/bundle/snipmate-tlib/scripts/create_crc_table.rb
new file mode 100644
index 0000000..149fe11
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/scripts/create_crc_table.rb
@@ -0,0 +1,67 @@
+# @Author:      Tom Link (micathom AT gmail com)
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Revision:    14
+
+
+def crc_vim_table
+  tbl = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 
+      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 
+      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 
+      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 
+      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 
+      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 
+      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 
+      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 
+      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 
+      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 
+      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 
+      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 
+      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 
+      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 
+      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 
+      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 
+      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 
+      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 
+      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 
+      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 
+      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 
+      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 
+      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 
+      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 
+      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 
+      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 
+      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 
+      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 
+      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 
+      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 
+      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 
+      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 
+      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 
+      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 
+      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 
+      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 
+      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 
+      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 
+      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 
+      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 
+      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 
+      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 
+      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 
+      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 
+      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 
+      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 
+      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 
+      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 
+      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 
+      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 
+      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 
+      0x2d02ef8d]
+  tbl.map! do |num|
+      b = "%b" % num
+      bits = b.split(//)
+      bits.map! {|b| b.to_i}
+      bits.reverse
+  end
+  VIM::command("let @t = '#{tbl.inspect}'")
+end
+
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/arg.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/arg.vim
new file mode 100755
index 0000000..cf060a2
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/arg.vim
@@ -0,0 +1,66 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-04-03.
+" @Last Change: 2010-04-03.
+" @Revision:    1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib#arg'
+
+function! TestGetArg(...) "{{{3
+    exec tlib#arg#Get(1, 'foo', 1)
+    return foo
+endf
+
+function! TestGetArg1(...) "{{{3
+    exec tlib#arg#Get(1, 'foo', 1, '!= ""')
+    return foo
+endf
+
+Should be equal TestGetArg(), 1
+Should be equal TestGetArg(''), ''
+Should be equal TestGetArg(2), 2
+Should be equal TestGetArg1(), 1
+Should be equal TestGetArg1(''), 1
+Should be equal TestGetArg1(2), 2
+
+function! TestArgs(...) "{{{3
+    exec tlib#arg#Let([['foo', "o"], ['bar', 2]])
+    return repeat(foo, bar)
+endf
+Should be equal TestArgs(), 'oo'
+Should be equal TestArgs('a'), 'aa'
+Should be equal TestArgs('a', 3), 'aaa'
+
+function! TestArgs1(...) "{{{3
+    exec tlib#arg#Let(['foo', ['bar', 2]])
+    return repeat(foo, bar)
+endf
+Should be equal TestArgs1(), ''
+Should be equal TestArgs1('a'), 'aa'
+Should be equal TestArgs1('a', 3), 'aaa'
+
+function! TestArgs2(...) "{{{3
+    exec tlib#arg#Let(['foo', 'bar'], 1)
+    return repeat(foo, bar)
+endf
+Should be equal TestArgs2(), '1'
+Should be equal TestArgs2('a'), 'a'
+Should be equal TestArgs2('a', 3), 'aaa'
+
+function! TestArgs3(...)
+    TVarArg ['a', 1], 'b'
+    return a . b
+endf
+Should be equal TestArgs3(), '1'
+Should be equal TestArgs3('a'), 'a'
+Should be equal TestArgs3('a', 3), 'a3'
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/date.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/date.vim
new file mode 100644
index 0000000..42c336b
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/date.vim
@@ -0,0 +1,61 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/vimtlib/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-09-17.
+" @Last Change: 2016-03-16.
+" @Revision:    21
+
+SpecBegin 'title': 'tlib#date'
+
+Should be equal tlib#date#Parse('2000-1-0', 1), [2000, 1, 0]
+Should be equal tlib#date#Parse('2000-1-2'), [2000, 1, 2]
+Should be equal tlib#date#Parse('2000-01-02'), [2000, 1, 2]
+Should be equal tlib#date#Parse('2000-10-20'), [2000, 10, 20]
+
+Should be equal tlib#date#Parse('00-1-0', 1), [2000, 1, 0]
+Should be equal tlib#date#Parse('00-1-2'), [2000, 1, 2]
+Should be equal tlib#date#Parse('00-01-02'), [2000, 1, 2]
+Should be equal tlib#date#Parse('00-10-20'), [2000, 10, 20]
+
+Should be equal tlib#date#Parse('2000/2/1'), [2000, 1, 2]
+Should be equal tlib#date#Parse('2000/02/01'), [2000, 1, 2]
+Should be equal tlib#date#Parse('2000/20/10'), [2000, 10, 20]
+
+Should be equal tlib#date#Parse('00/2/1'), [2000, 1, 2]
+Should be equal tlib#date#Parse('00/02/01'), [2000, 1, 2]
+Should be equal tlib#date#Parse('00/20/10'), [2000, 10, 20]
+
+Should be equal tlib#date#Parse('2.1.2000'), [2000, 1, 2]
+Should be equal tlib#date#Parse('2. 1. 2000'), [2000, 1, 2]
+Should be equal tlib#date#Parse('02.01.2000'), [2000, 1, 2]
+Should be equal tlib#date#Parse('02. 01. 2000'), [2000, 1, 2]
+Should be equal tlib#date#Parse('20.10.2000'), [2000, 10, 20]
+Should be equal tlib#date#Parse('20. 10. 2000'), [2000, 10, 20]
+
+Should throw exception "tlib#date#Parse('2000-14-2')", 'TLib: Invalid date'
+Should throw exception "tlib#date#Parse('2000-011-02')", 'TLib: Invalid date'
+Should throw exception "tlib#date#Parse('2000-10-40')", 'TLib: Invalid date'
+Should throw exception "tlib#date#Parse('2000-10-0')", 'TLib: Invalid date'
+
+Should be equal tlib#date#Shift('2015-10-29', '1m'), '2015-11-29'
+Should be equal tlib#date#Shift('2015-11-29', '1m'), '2015-12-29'
+Should be equal tlib#date#Shift('2015-12-29', '1m'), '2016-01-29'
+Should be equal tlib#date#Shift('2016-01-29', '1m'), '2016-02-29'
+Should be equal tlib#date#Shift('2015-10-29', '2m'), '2015-12-29'
+Should be equal tlib#date#Shift('2015-10-29', '3m'), '2016-01-29'
+Should be equal tlib#date#Shift('2015-10-29', '4m'), '2016-02-29'
+Should be equal tlib#date#Shift('2015-12-30', '1d'), '2015-12-31'
+Should be equal tlib#date#Shift('2015-12-31', '1d'), '2016-01-01'
+Should be equal tlib#date#Shift('2015-12-30', '2d'), '2016-01-01'
+Should be equal tlib#date#Shift('2015-12-30', '3d'), '2016-01-02'
+
+Should be equal tlib#date#Shift('2016-03-16', '1b'), '2016-03-17'
+Should be equal tlib#date#Shift('2016-03-16', '2b'), '2016-03-18'
+Should be equal tlib#date#Shift('2016-03-16', '3b'), '2016-03-21'
+Should be equal tlib#date#Shift('2016-03-16', '4b'), '2016-03-22'
+Should be equal tlib#date#Shift('2016-03-16', '5b'), '2016-03-23'
+Should be equal tlib#date#Shift('2016-03-16', '6b'), '2016-03-24'
+Should be equal tlib#date#Shift('2016-03-16', '7b'), '2016-03-25'
+Should be equal tlib#date#Shift('2016-03-16', '8b'), '2016-03-28'
+
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/dictionary.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/dictionary.vim
new file mode 100644
index 0000000..52439e6
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/dictionary.vim
@@ -0,0 +1,28 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2016-04-03.
+" @Last Change: 2016-04-03.
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib#dictionary'
+
+
+It should handle basic test cases for tlib#dictionary#Rev properly.
+
+Should be equal tlib#dictionary#Rev({}), {}
+Should be equal tlib#dictionary#Rev({1: 2, 3: 4}), {'2': '1', '4': '3'}
+Should be equal tlib#dictionary#Rev({1: '', 3: 4}, {'empty': '*'}), {'*': '1', '4': '3'}
+Should be equal tlib#dictionary#Rev({1: '', 3: 4}, {'use_string': 1}), {'''''': '1', '4': '3'}
+Should be equal tlib#dictionary#Rev({1: '', 3: 4}, {'use_string': 1, 'use_eval': 1}), {'''''': 1, '4': 3}
+Should be equal tlib#dictionary#Rev(tlib#dictionary#Rev({1: '', 3: 4}, {'use_string': 1}), {'use_eval': 1}), {1: '', 3: 4}
+Should be equal tlib#dictionary#Rev({1: 4, 2: 4}, {'values_as_list': 1}), {'4': ['1', '2']}
+Should be equal tlib#dictionary#Rev({1: 4, 2: 4}, {'values_as_list': 1, 'use_eval': 1}), {'4': [1, 2]}
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/eval.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/eval.vim
new file mode 100644
index 0000000..40c5138
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/eval.vim
@@ -0,0 +1,27 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2015-10-26.
+" @Last Change: 2015-10-26.
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+SpecBegin 'title': 'tlib#eval'
+
+
+let g:eval_a = {'foo': range(0, 5), 'd': {'a': range(0, 5)}}
+let g:eval_b = {'foo': range(6, 10), 'd': {'a': range(6, 10), 'b': 2}, 'bar': range(5)}
+let g:eval_a0 = deepcopy(g:eval_a)
+let g:eval_b0 = deepcopy(g:eval_b)
+let g:eval_c = {'foo': range(0, 10), 'd': {'a': range(0, 10), 'b': 2}, 'bar': range(5)}
+
+
+Should be equal tlib#eval#Extend(copy(g:eval_a), g:eval_b), g:eval_c
+Should be equal g:eval_a, g:eval_a0
+Should be equal g:eval_b, g:eval_b0
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/file.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/file.vim
new file mode 100755
index 0000000..f692abf
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/file.vim
@@ -0,0 +1,59 @@
+" @Author:      Thomas Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/vimtlib/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-02-25.
+" @Last Change: 2010-04-03.
+" @Revision:    13
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+SpecBegin 'title': 'tlib/file',
+            \ 'sfile': 'autoload/tlib/file.vim'
+
+
+
+It should split filenames.
+Should be equal tlib#file#Split('foo/bar/filename.txt'), ['foo', 'bar', 'filename.txt']
+Should be equal tlib#file#Split('/foo/bar/filename.txt'), ['', 'foo', 'bar', 'filename.txt']
+Should be equal tlib#file#Split('ftp://foo/bar/filename.txt'), ['ftp:/', 'foo', 'bar', 'filename.txt']
+
+
+It should join filenames.
+Should be#Equal tlib#file#Join(['foo', 'bar']), 'foo/bar'
+Should be#Equal tlib#file#Join(['foo/', 'bar'], 1), 'foo/bar'
+Should be#Equal tlib#file#Join(['', 'bar']), '/bar'
+Should be#Equal tlib#file#Join(['/', 'bar'], 1), '/bar'
+Should be#Equal tlib#file#Join(['foo', 'bar', 'filename.txt']), 'foo/bar/filename.txt'
+Should be#Equal tlib#file#Join(['', 'foo', 'bar', 'filename.txt']), '/foo/bar/filename.txt'
+Should be#Equal tlib#file#Join(['ftp:/', 'foo', 'bar', 'filename.txt']), 'ftp://foo/bar/filename.txt'
+Should be#Equal tlib#file#Join(['ftp://', 'foo', 'bar', 'filename.txt'], 1), 'ftp://foo/bar/filename.txt'
+
+Should be equal tlib#file#Join(['foo', 'bar', 'filename.txt']), 'foo/bar/filename.txt'
+Should be equal tlib#file#Join(['', 'foo', 'bar', 'filename.txt']), '/foo/bar/filename.txt'
+Should be equal tlib#file#Join(['ftp:/', 'foo', 'bar', 'filename.txt']), 'ftp://foo/bar/filename.txt'
+
+
+It should construct relative path names.
+Should be#Equal tlib#file#Relative('foo/bar/filename.txt', 'foo'), 'bar/filename.txt'
+Should be#Equal tlib#file#Relative('foo/bar/filename.txt', 'foo/base'), '../bar/filename.txt'
+Should be#Equal tlib#file#Relative('filename.txt', 'foo/base'), '../../filename.txt'
+Should be#Equal tlib#file#Relative('/foo/bar/filename.txt', '/boo/base'), '../../foo/bar/filename.txt'
+Should be#Equal tlib#file#Relative('/bar/filename.txt', '/boo/base'), '../../bar/filename.txt'
+Should be#Equal tlib#file#Relative('/foo/bar/filename.txt', '/base'), '../foo/bar/filename.txt'
+Should be#Equal tlib#file#Relative('c:/bar/filename.txt', 'x:/boo/base'), 'c:/bar/filename.txt'
+
+
+Should be equal tlib#file#Relative('foo/bar/filename.txt', 'foo'), 'bar/filename.txt'
+Should be equal tlib#file#Relative('foo/bar/filename.txt', 'foo/base'), '../bar/filename.txt'
+Should be equal tlib#file#Relative('filename.txt', 'foo/base'), '../../filename.txt'
+Should be equal tlib#file#Relative('/foo/bar/filename.txt', '/boo/base'), '../../foo/bar/filename.txt'
+Should be equal tlib#file#Relative('/bar/filename.txt', '/boo/base'), '../../bar/filename.txt'
+Should be equal tlib#file#Relative('/foo/bar/filename.txt', '/base'), '../foo/bar/filename.txt'
+Should be equal tlib#file#Relative('c:/bar/filename.txt', 'x:/boo/base'), 'c:/bar/filename.txt'
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/hash.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/hash.vim
new file mode 100644
index 0000000..a2403a3
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/hash.vim
@@ -0,0 +1,58 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    31
+
+
+SpecBegin 'title': 'tlib#hash'
+
+
+It should calculate CRC32B checksums.
+
+let g:tlib_hash_use_crc32 = g:tlib#hash#use_crc32
+
+let g:tlib#hash#use_crc32 = 'ruby'
+Should be equal tlib#hash#CRC32B('The quick brown fox jumps over the lazy dog'), '414FA339'
+Should be equal tlib#hash#CRC32B('foo'), '8C736521'
+Should be equal tlib#hash#CRC32B('f'), '76D32BE0'
+
+let g:tlib#hash#use_crc32 = 'vim'
+Should be equal tlib#hash#CRC32B('The quick brown fox jumps over the lazy dog'), '414FA339'
+Should be equal tlib#hash#CRC32B('foo'), '8C736521'
+Should be equal tlib#hash#CRC32B('f'), '76D32BE0'
+
+
+function! s:CompareHash(text) "{{{3
+    if !empty(a:text)
+        exec 'It should calculate the crc32b checksum for:' a:text
+        let crc32ruby = tlib#hash#CRC32B_ruby(a:text)
+        let crc32vim = tlib#hash#CRC32B_vim(a:text)
+        exec 'Should be equal' string(crc32ruby) ',' string(crc32vim)
+        exec 'It should calculate the adler32 checksum for:' a:text
+        let adler32tlib = tlib#hash#Adler32_tlib(a:text)
+        let adler32vim = tlib#hash#Adler32_vim(a:text)
+        exec 'Should be equal' string(adler32tlib) ',' string(adler32vim)
+    endif
+endf
+
+redir => s:scriptnames
+silent scriptnames
+redir END
+for s:script in split(s:scriptnames, '\n')
+    let s:scriptfile = matchstr(s:script, '^\s*\d\+:\s\+\zs.*$')
+    call s:CompareHash(s:scriptfile)
+    try
+        let s:scriptlines = readfile(s:scriptfile)
+        call s:CompareHash(join(s:scriptlines, "\n"))
+        for s:scriptline in s:scriptlines
+            call s:CompareHash(s:scriptline)
+        endfor
+    catch /^Vim\%((\a\+)\)\=:E484/
+    endtry
+endfor
+unlet s:scriptnames, :script, s:scriptfile, s:scriptlines, s:scriptline
+delf s:CompareHash
+
+
+let g:tlib#hash#use_crc32 = g:tlib_hash_use_crc32
+
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/input.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/input.vim
new file mode 100755
index 0000000..f82aea6
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/input.vim
@@ -0,0 +1,127 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/vimtlib/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-02-28.
+" @Last Change: 2009-03-14.
+" @Revision:    73
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+SpecBegin 'title': 'tlib: Input', 'scratch': '%',
+            \ 'after': ':unlet! g:spec_lib_rv',
+            \ 'options': [
+			\ 'vim',
+			\ ]
+
+
+let g:spec_tlib_list = [10, 20, 30, 40, 'a50', 'aa60', 'b70', 'ba80', 90]
+
+
+
+It should return empty values when the user presses <escape>.
+Replay :let g:spec_lib_rv = tlib#input#List('s', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<esc>
+Should be#Equal g:spec_lib_rv, ''
+
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<esc>
+Should be#Equal g:spec_lib_rv, []
+
+Replay :let g:spec_lib_rv = tlib#input#List('si', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<esc>
+Should be#Equal g:spec_lib_rv, 0
+
+
+
+It should pick an item from s-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('s', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<cr>
+Should be#Equal g:spec_lib_rv, 30
+
+
+
+It should return an index from si-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('si', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<cr>
+Should be#Equal g:spec_lib_rv, 3
+
+
+
+It should return a list from a m-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+            \ \<Down>#\<Down>\<Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [20, 40]
+
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+           \ \<Down>\<S-Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [20, 30]
+
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<S-up>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [20, 30]
+
+
+
+It should return a list of indices from a mi-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('mi', '', g:spec_tlib_list)\<cr>
+            \ \<Down>#\<Down>\<Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [2, 4]
+
+Replay :let g:spec_lib_rv = tlib#input#List('mi', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<S-Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [2, 3]
+
+Replay :let g:spec_lib_rv = tlib#input#List('mi', '', g:spec_tlib_list)\<cr>
+            \ \<Down>\<Down>\<S-up>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [2, 3]
+
+
+
+It should filter items from a s-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('s', '', g:spec_tlib_list)\<cr>
+            \ \<Down>a\<Down>\<cr>
+Should be#Equal g:spec_lib_rv, 'aa60'
+
+
+
+It should filter items from a si-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('si', '', g:spec_tlib_list)\<cr>
+            \ \<Down>a\<Down>\<cr>
+Should be#Equal g:spec_lib_rv, 6
+
+
+
+It should filter items from a m-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+            \ a\<Down>#\<Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), ['aa60', 'ba80']
+
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+            \ a\<Down>\<S-Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), ['aa60', 'ba80']
+
+Replay :let g:spec_lib_rv = tlib#input#List('m', '', g:spec_tlib_list)\<cr>
+            \ a\<Down>\<Down>\<S-up>\<cr>
+Should be#Equal sort(g:spec_lib_rv), ['aa60', 'ba80']
+
+
+
+It should filter items from a mi-type list.
+Replay :let g:spec_lib_rv = tlib#input#List('mi', '', g:spec_tlib_list)\<cr>
+            \ a\<Down>#\<Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [6, 8]
+
+Replay :let g:spec_lib_rv = tlib#input#List('mi', '', g:spec_tlib_list)\<cr>
+            \ a\<Down>\<S-Down>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [6, 8]
+
+Replay :let g:spec_lib_rv = tlib#input#List('mi', '', g:spec_tlib_list)\<cr>
+            \ a\<Down>\<Down>\<S-up>\<cr>
+Should be#Equal sort(g:spec_lib_rv), [6, 8]
+
+
+
+let &cpo = s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/list.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/list.vim
new file mode 100755
index 0000000..d4aae54
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/list.vim
@@ -0,0 +1,67 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-04-03.
+" @Last Change: 2010-04-03.
+" @Revision:    4
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib: List'
+            " \, 'options': [vim, <+SET+>]
+            " \, 'sfile': '<+SCRIPT CONTEXT+>'
+            " \, 'scratch': '<+SCRATCH FILE+>'
+            " \, 'before': '<+BEFORE EX COMMANDS+>'
+            " \, 'after': '<+AFTER EX COMMANDS+>'
+            " \, 'cleanup': ['<+FUNCTION+>()']
+
+
+" List {{{2
+fun! Add(a,b)
+    return a:a + a:b
+endf
+
+Should be equal tlib#list#Inject([], 0, function('Add')), 0
+Should be equal tlib#list#Inject([1,2,3], 0, function('Add')), 6
+
+Should be equal tlib#list#Compact([]), []
+Should be equal tlib#list#Compact([0,1,2,3,[], {}, ""]), [1,2,3]
+
+Should be equal tlib#list#Flatten([]), []
+Should be equal tlib#list#Flatten([1,2,3]), [1,2,3]
+Should be equal tlib#list#Flatten([1,2, [1,2,3], 3]), [1,2,1,2,3,3]
+Should be equal tlib#list#Flatten([0,[1,2,[3,""]]]), [0,1,2,3,""]
+
+Should be equal tlib#list#FindAll([1,2,3], 'v:val >= 2'), [2,3]
+Should be equal tlib#list#FindAll([1,2,3], 'v:val >= 2', 'v:val * 10'), [20,30]
+
+Should be equal tlib#list#Find([1,2,3], 'v:val >= 2'), 2
+Should be equal tlib#list#Find([1,2,3], 'v:val >= 2', 0, 'v:val * 10'), 20
+Should be equal tlib#list#Find([1,2,3], 'v:val >= 5', 10), 10
+
+Should be equal tlib#list#Any([1,2,3], 'v:val >= 2'), 1
+Should be equal tlib#list#Any([1,2,3], 'v:val >= 5'), 0
+
+Should be equal tlib#list#All([1,2,3], 'v:val < 5'), 1
+Should be equal tlib#list#All([1,2,3], 'v:val >= 2'), 0
+
+Should be equal tlib#list#Remove([1,2,1,2], 2), [1,1,2]
+Should be equal tlib#list#RemoveAll([1,2,1,2], 2), [1,1]
+
+Should be equal tlib#list#Zip([[1,2,3], [4,5,6]]), [[1,4], [2,5], [3,6]]
+Should be equal tlib#list#Zip([[1,2,3], [4,5,6,7]]), [[1,4], [2,5], [3,6], ['', 7]]
+Should be equal tlib#list#Zip([[1,2,3], [4,5,6,7]], -1), [[1,4], [2,5], [3,6], [-1,7]]
+Should be equal tlib#list#Zip([[1,2,3,7], [4,5,6]], -1), [[1,4], [2,5], [3,6], [7,-1]]
+
+
+Should be equal tlib#list#Uniq([]), []
+Should be equal tlib#list#Uniq([1,1]), [1]
+Should be equal tlib#list#Uniq([1,2,2,3,2,3,4,2,1,7,2,3,2,3,7]), [1,2,3,4,7]
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/rx.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/rx.vim
new file mode 100755
index 0000000..fc28103
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/rx.vim
@@ -0,0 +1,27 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-04-03.
+" @Last Change: 2010-04-03.
+" @Revision:    2
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib#rx'
+
+
+for c in split('^$.*+\()|{}[]~', '\zs')
+    let s = printf('%sfoo%sbar%s', c, c, c)
+    Should be like s, '\m^'. tlib#rx#Escape(s, 'm') .'$'
+    Should be like s, '\M^'. tlib#rx#Escape(s, 'M') .'$'
+    Should be like s, '\v^'. tlib#rx#Escape(s, 'v') .'$'
+    Should be like s, '\V\^'. tlib#rx#Escape(s, 'V') .'\$'
+endfor
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/string.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/string.vim
new file mode 100755
index 0000000..4329d94
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/string.vim
@@ -0,0 +1,29 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-04-03.
+" @Last Change: 2010-04-03.
+" @Revision:    4
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib#string'
+
+Should be equal tlib#string#RemoveBackslashes('foo bar'), 'foo bar'
+Should be equal tlib#string#RemoveBackslashes('foo\ bar'), 'foo bar'
+Should be equal tlib#string#RemoveBackslashes('foo\ \\bar'), 'foo \\bar'
+Should be equal tlib#string#RemoveBackslashes('foo\ \\bar', '\ '), 'foo \bar'
+
+
+Should be equal tlib#string#Count("fooo", "o"), 3
+Should be equal tlib#string#Count("***", "\\*"), 3
+Should be equal tlib#string#Count("***foo", "\\*"), 3
+Should be equal tlib#string#Count("foo***", "\\*"), 3
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/url.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/url.vim
new file mode 100755
index 0000000..80783e9
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/url.vim
@@ -0,0 +1,23 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-04-03.
+" @Last Change: 2010-04-03.
+" @Revision:    2
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib#url'
+
+Should be equal tlib#url#Decode('http://example.com/foo+bar%25bar'), 'http://example.com/foo bar%bar'
+Should be equal tlib#url#Decode('Hello%20World.%20%20Good%2c%20bye.'), 'Hello World.  Good, bye.'
+
+Should be equal tlib#url#Encode('foo bar%bar'), 'foo+bar%%bar'
+Should be equal tlib#url#Encode('Hello World. Good, bye.'), 'Hello+World.+Good%2c+bye.'
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate-tlib/spec/tlib/var.vim b/vim/.vim/bundle/snipmate-tlib/spec/tlib/var.vim
new file mode 100755
index 0000000..28e3fac
--- /dev/null
+++ b/vim/.vim/bundle/snipmate-tlib/spec/tlib/var.vim
@@ -0,0 +1,37 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-04-03.
+" @Last Change: 2010-04-03.
+" @Revision:    2
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+
+SpecBegin 'title': 'tlib#var'
+
+
+let g:foo = 1
+let g:bar = 2
+let b:bar = 3
+let s:bar = 4
+
+Should be equal tlib#var#Get('bar', 'bg'), 3
+Should be equal tlib#var#Get('bar', 'g'), 2
+Should be equal tlib#var#Get('foo', 'bg'), 1
+Should be equal tlib#var#Get('foo', 'g'), 1
+Should be equal tlib#var#Get('none', 'l'), ''
+
+Should be equal eval(tlib#var#EGet('bar', 'bg')), 3
+Should be equal eval(tlib#var#EGet('bar', 'g')), 2
+" Should be equal eval(tlib#var#EGet('bar', 'sg')), 4
+Should be equal eval(tlib#var#EGet('foo', 'bg')), 1
+Should be equal eval(tlib#var#EGet('foo', 'g')), 1
+Should be equal eval(tlib#var#EGet('none', 'l')), ''
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
diff --git a/vim/.vim/bundle/snipmate/Contributors.md b/vim/.vim/bundle/snipmate/Contributors.md
new file mode 100644
index 0000000..4206472
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/Contributors.md
@@ -0,0 +1,52 @@
+# Contributors #
+
+SnipMate was originally authored by Michael Sanders
+([Vim](http://www.vim.org/account/profile.php?user_id=16544),
+[GitHub](https://github.com/msanders)).
+
+It is currently maintained by [Rok Garbas](rok@garbas.si), [Marc
+Weber](marco-oweber@gmx.de), and [Adnan Zafar](https://github.com/ajzafar) with
+additional contributions from:
+
+* [907th](https://github.com/907th)
+* [adkron](https://github.com/adkron)
+* [alderz](https://github.com/alderz)
+* [asymmetric](https://github.com/asymmetric)
+* [bpugh](https://github.com/bpugh)
+* [bruno-](https://github.com/bruno-)
+* [CharlesGueunet](https://github.com/CharlesGueunet)
+* [darkwise](https://github.com/darkwise)
+* [dreviejo](https://github.com/dreviejo)
+* [fish-face](https://github.com/fish-face)
+* [henrik](https://github.com/henrik)
+* [holizz](https://github.com/holizz)
+* [honza](https://github.com/honza)
+* [hpesoj](https://github.com/hpesoj)
+* [ironcamel](https://github.com/ironcamel)
+* [jb55](https://github.com/jb55)
+* [jbernard](https://github.com/jbernard)
+* [jherdman](https://github.com/jherdman)
+* [kozo2](https://github.com/kozo2)
+* [lilydjwg](https://github.com/lilydjwg)
+* [lpil](https://github.com/lpil)
+* [marutanm](https://github.com/marutanm)
+* [MicahElliott](https://github.com/MicahElliott)
+* [mikeastock](https://github.com/mikeastock)
+* [muffinresearch](https://github.com/muffinresearch)
+* [munyari](https://github.com/munyari)
+* [pielgrzym](https://github.com/pielgrzym)
+* [pose](https://github.com/pose)
+* [r00k](https://github.com/r00k)
+* [radicalbit](https://github.com/radicalbit)
+* [redpill](https://github.com/redpill)
+* [rglassett](http://github.com/rglassett)
+* [robhudson](https://github.com/robhudson)
+* [shinymayhem](https://github.com/shinymayhem)
+* [Shraymonks](https://github.com/shraymonks)
+* [sickill](https://github.com/sickill)
+* [statik](https://github.com/statik)
+* [steveno](https://github.com/steveno)
+* [taq](https://github.com/taq)
+* [thisgeek](https://github.com/thisgeek)
+* [trusktr](https://github.com/trusktr)
+* [Xandaros](https://github.com/Xandaros)
diff --git a/vim/.vim/bundle/snipmate/README.md b/vim/.vim/bundle/snipmate/README.md
new file mode 100644
index 0000000..b47b56d
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/README.md
@@ -0,0 +1,169 @@
+# SnipMate #
+
+SnipMate aims to provide support for textual snippets, similar to TextMate or
+other Vim plugins like [UltiSnips][ultisnips]. For
+example, in C, typing `for<tab>` could be expanded to
+
+    for (i = 0; i < count; i++) {
+        /* code */
+    }
+
+with successive presses of tab jumping around the snippet.
+
+Originally authored by [Michael Sanders][msanders], SnipMate was forked in 2011
+after a stagnation in development. This fork is currently maintained by [Rok
+Garbas][garbas], [Marc Weber][marcweber], and [Adnan Zafar][ajzafar].
+
+
+## Installing SnipMate ##
+
+We recommend one of the following methods for installing SnipMate and its
+dependencies. SnipMate depends on [vim-addon-mw-utils][mw-utils] and
+[tlib][tlib].
+
+> **NOTE:** SnipMate does not ship with any snippets out of the box. We suggest
+looking at the [vim-snippets][vim-snippets] repository.
+
+* Using [VAM][vam], add `vim-snippets` to the list of packages to be installed.
+
+* Using [Pathogen][pathogen], run the following commands:
+
+        % cd ~/.vim/bundle
+        % git clone https://github.com/tomtom/tlib_vim.git
+        % git clone https://github.com/MarcWeber/vim-addon-mw-utils.git
+        % git clone https://github.com/garbas/vim-snipmate.git
+
+        # Optional:
+        % git clone https://github.com/honza/vim-snippets.git
+
+* Using [Vundle][vundle], add the following to your `vimrc` then run
+  `:PluginInstall`
+
+        Plugin 'MarcWeber/vim-addon-mw-utils'
+        Plugin 'tomtom/tlib_vim'
+        Plugin 'garbas/vim-snipmate'
+
+        " Optional:
+        Plugin 'honza/vim-snippets'
+
+## FAQ ##
+
+> SnipMate doesn't work / My snippets aren't triggering
+
+Try all of the following:
+
+* Check that SnipMate is loaded. This can be done by looking for
+  `<Plug>snipMateTrigger` and similar maps in the output of `:imap`.
+  Additionally make sure either `<Plug>snipMateTrigger` or
+  `<Plug>snipMateNextOrTrigger` is mapped to the key you expect.
+
+* Check that the snippets file you mean to use exists, and that it contains the
+  snippet you're trying to expand.
+
+* Check that your snippets file is located inside a `foo/snippets` directory,
+  where `foo` is a path listed in your `runtimepath`.
+
+* Check that your snippets file is in scope by either the filetype matching the
+  path of the snippet file or the scope explicitly loaded.
+
+* Check if any snippets from your snippets file are available. This can be done
+  with the "show available snips" map, by default bound to `<C-R><Tab>` in
+  insert mode.
+
+If all of the above check out, please open an issue stating your Vim version,
+a sample snippet, and a description of exactly what happens when you try to
+trigger a snippet.
+
+> How does SnipMate determine which snippets to load? How can I separate, for
+> example, my Rails snippets from my Ruby snippets?
+
+Primarily SnipMate looks at the `'filetype'` and `'syntax'` settings. Taking
+"scopes" from these options, it looks in each `snippets/` directory in
+`'runtimepath'` for files named `scope.snippets`, `scope/*.snippets`, or
+`scope_*.snippets`.
+
+However we understand this may not allow for the flexibility desired by some
+languages. For this we provide two options: scope aliases and the
+`:SnipMateLoadScope` command. Scope aliases simply say "whenever this scope is
+loaded, also load this other scope:
+
+    let g:snipMate = get(g:, 'snipMate', {}) " Allow for vimrc re-sourcing
+    let g:snipMate.scope_aliases = {}
+    let g:snipMate.scope_aliases['ruby'] = 'ruby,rails'
+
+will load the `ruby-rails` scope whenever the `ruby` scope is active. The
+`:SnipMateLoadScope foo` command will always load the foo scope in the current
+buffer. The [vim-rails](https://github.com/tpope/vim-rails) plugin automatically
+does `:SnipMateLoadScope rails` when editing a Rails project for example.
+
+## Release Notes ##
+
+### 0.89 - 2016-05-29 ###
+
+* Various regex updates to legacy parser
+* Addition of double bang syntax to completely remove a snippet from lookup
+* Group various SnipMate autocommands
+* Support setting 'shiftwidth' to 0
+* Parser now operates linewise, adding some flexibility
+* Mirror substitutions are more literal
+* Mirror length is calculated correctly when substitutions occur
+
+### 0.88 - 2015-04-04 ###
+
+* Implement simple caching
+* Remove expansion guards
+* Add `:SnipMateLoadScope` command and buffer-local scope aliases
+* Load `<scope>_*.snippets` files
+* Use CursorMoved autocmd events entirely
+
+* The nested branch has been merged
+    * A new snippet parser has been added. The g:snipmate.version as well as
+      version lines in snippet files determines which is used
+    * The new parser supports tab stops placed within placeholders,
+      substitutions, non-consecutive stop numbers, and fewer ambiguities
+    * The stop jumping code has been updated
+    * Tests have been added for the jumping code and the new parser
+
+* The override branch has been merged
+    * The g:snipMate.override option is added. When enabled, if two snippets
+      share the same name, the later-loaded one is kept and the other discarded
+    * Override behavior can be enabled on a per-snippet basis with a bang (!) in
+      the snippet file
+    * Otherwise, SnipMate tries to preserve all snippets loaded
+
+* Fix bug with mirrors in the first column
+* Fix bug with tabs in indents ([#143][143])
+* Fix bug with mirrors in placeholders
+* Fix reading single snippet files
+* Fix the use of the visual map at the end of a line
+* Fix expansion of stops containing only the zero tab stop
+* Remove select mode mappings
+* Indent visual placeholder expansions and remove extraneous lines ([#177][177]
+  and [#178][178])
+
+### 0.87 - 2014-01-04 ###
+
+* Stop indenting empty lines when expanding snippets
+* Support extends keyword in .snippets files
+* Fix visual placeholder support
+* Add zero tabstop support
+* Support negative 'softtabstop'
+* Add g:snipMate_no_default_aliases option
+* Add <Plug>snipMateTrigger for triggering an expansion inside a snippet
+* Add snipMate#CanBeTriggered() function
+
+[ultisnips]: https://github.com/sirver/ultisnips
+[msanders]: https://github.com/msanders
+[garbas]: https://github.com/garbas
+[marcweber]: https://github.com/marcweber
+[ajzafar]: https://github.com/ajzafar
+[mw-utils]: https://github.com/marcweber/vim-addon-mw-utils
+[tlib]: https://github.com/tomtom/tlib_vim
+[vim-snippets]: https://github.com/honza/vim-snippets
+[vam]: https://github.com/marcweber/vim-addon-manager
+[pathogen]: https://github.com/tpope/vim-pathogen
+[vundle]: https://github.com/gmarik/vundle
+
+[143]: https://github.com/garbas/vim-snipmate/issues/143
+[177]: https://github.com/garbas/vim-snipmate/issues/177
+[178]: https://github.com/garbas/vim-snipmate/issues/178
diff --git a/vim/.vim/bundle/snipmate/addon-info.json b/vim/.vim/bundle/snipmate/addon-info.json
new file mode 100644
index 0000000..8d9930f
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/addon-info.json
@@ -0,0 +1,12 @@
+{
+  "name" : "snipMate",
+  "version" : "dev",
+  "author" : "Michael Sanders -> original project http://github.com/msanders/snipmate.vim",
+  "maintainer" : "Rok Garbas / Marc Weber",
+  "repository" : {"type": "git", "url": "git://github.com/garbas/vim-snipmate.git"},
+  "dependencies" : {
+    "vim-addon-mw-utils": {},
+    "tlib": {}
+  },
+  "description" : "snipMate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim. See README.md to learn about the features this fork adds"
+}
diff --git a/vim/.vim/bundle/snipmate/after/plugin/snipMate.vim b/vim/.vim/bundle/snipmate/after/plugin/snipMate.vim
new file mode 100644
index 0000000..3d6bac7
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/after/plugin/snipMate.vim
@@ -0,0 +1,46 @@
+" snipMate maps
+" These maps are created here in order to make sure we can reliably create maps
+" after SuperTab.
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! s:map_if_not_mapped(lhs, rhs, mode) abort
+    let l:unique = s:overwrite ? '' : ' <unique>'
+    if !hasmapto(a:rhs, a:mode)
+	silent! exe a:mode . 'map' . l:unique a:lhs a:rhs
+    endif
+endfunction
+
+if !exists('g:snips_no_mappings') || !g:snips_no_mappings
+	if exists('g:snips_trigger_key')
+		echom 'g:snips_trigger_key is deprecated. See :h snipMate-mappings'
+		exec 'imap <unique>' g:snips_trigger_key '<Plug>snipMateTrigger'
+		exec 'smap <unique>' g:snips_trigger_key '<Plug>snipMateSNext'
+		exec 'xmap <unique>' g:snips_trigger_key '<Plug>snipMateVisual'
+	else
+		" Remove SuperTab map if it exists
+		let s:overwrite = maparg('<Tab>', 'i') ==? '<Plug>SuperTabForward'
+		call s:map_if_not_mapped('<Tab>', '<Plug>snipMateNextOrTrigger', 'i')
+		call s:map_if_not_mapped('<Tab>', '<Plug>snipMateNextOrTrigger', 's')
+		let s:overwrite = 0
+		call s:map_if_not_mapped('<Tab>', '<Plug>snipMateVisual', 'x')
+	endif
+
+	if exists('g:snips_trigger_key_backwards')
+		echom 'g:snips_trigger_key_backwards is deprecated. See :h snipMate-mappings'
+		exec 'imap <unique>' g:snips_trigger_key_backwards '<Plug>snipMateIBack'
+		exec 'smap <unique>' g:snips_trigger_key_backwards '<Plug>snipMateSBack'
+	else
+		let s:overwrite = maparg('<S-Tab>', 'i') ==? '<Plug>SuperTabBackward'
+		call s:map_if_not_mapped('<S-Tab>', '<Plug>snipMateBack', 'i')
+		call s:map_if_not_mapped('<S-Tab>', '<Plug>snipMateBack', 's')
+		let s:overwrite = 0
+	endif
+
+	call s:map_if_not_mapped('<C-R><Tab>', '<Plug>snipMateShow', 'i')
+endif
+
+let &cpo = s:save_cpo
+
+" vim:noet:
diff --git a/vim/.vim/bundle/snipmate/autoload/snipMate.vim b/vim/.vim/bundle/snipmate/autoload/snipMate.vim
new file mode 100644
index 0000000..76cc648
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/autoload/snipMate.vim
@@ -0,0 +1,613 @@
+" config which can be overridden (shared lines)
+if !exists('g:snipMate')
+  let g:snipMate = {}
+endif
+
+try
+	call tlib#input#List('mi', '', [])
+catch /.*/
+	echoe "you're missing tlib. See install instructions at ".expand('<sfile>:h:h').'/README.md'
+endtry
+
+fun! Filename(...) abort
+	let filename = expand('%:t:r')
+	if filename == '' | return a:0 == 2 ? a:2 : '' | endif
+	return !a:0 || a:1 == '' ? filename : substitute(a:1, '$1', filename, 'g')
+endf
+
+let s:cache = {}
+
+function! snipMate#expandSnip(snip, version, col) abort
+	let lnum = line('.')
+	let col = a:col
+	let line = getline(lnum)
+	let indent = match(line, '\S\|$') + 1
+	let b:snip_state = snipmate#jumping#state()
+
+	if a:version == 1
+		let [snippet, b:snip_state.stops] = snipmate#parse#snippet(a:snip)
+		" Build stop/mirror info
+		let b:snip_state.stop_count = s:build_stops(snippet, b:snip_state.stops, lnum, col, indent)
+		let snipLines = map(copy(snippet),
+					\ 'snipMate#sniplist_str(v:val, b:snip_state.stops)')
+	else
+		let snippet = snipmate#legacy#process_snippet(a:snip)
+		let [b:snip_state.stops, b:snip_state.stop_count] = snipmate#legacy#build_stops(snippet, lnum, col - indent, indent)
+		let snipLines = split(substitute(snippet, printf('%s\d\+\|%s{\d\+.\{-}}',
+					\ g:snipmate#legacy#sigil, g:snipmate#legacy#sigil), '', 'g'), "\n", 1)
+	endif
+
+	" Abort if the snippet is empty
+	if empty(snippet)
+		return ''
+	endif
+
+	" Expand snippet onto current position
+	let afterCursor = strpart(line, col - 1)
+	" Keep text after the cursor
+	if afterCursor != "\t" && afterCursor != ' '
+		let line = strpart(line, 0, col - 1)
+		let snipLines[-1] .= afterCursor
+	else
+		let afterCursor = ''
+		" For some reason the cursor needs to move one right after this
+		if line != '' && col == 1 && &ve != 'all' && &ve != 'onemore'
+			let col += 1
+		endif
+	endif
+
+	" Insert snippet with proper indentation
+	call setline(lnum, line . snipLines[0])
+	call append(lnum, map(snipLines[1:], "empty(v:val) ? v:val : '" . strpart(line, 0, indent - 1) . "' . v:val"))
+
+	" Open any folds snippet expands into
+	if &foldenable
+		silent! exec lnum . ',' . (lnum + len(snipLines) - 1) . 'foldopen'
+	endif
+
+	aug snipmate_changes
+		au CursorMoved,CursorMovedI <buffer> if exists('b:snip_state') |
+					\     call b:snip_state.update_changes() |
+					\ else |
+					\     silent! au! snipmate_changes * <buffer> |
+					\ endif
+	aug END
+
+	let b:snip_state.stop_no = 0
+	return b:snip_state.set_stop(0)
+endfunction
+
+function! snipMate#placeholder_str(num, stops) abort
+	return snipMate#sniplist_str(a:stops[a:num].placeholder, a:stops)
+endfunction
+
+function! snipMate#sniplist_str(snippet, stops) abort
+	let str = ''
+	let pos = 0
+	let add_to = 1
+	let seen_stops = []
+
+	while pos < len(a:snippet)
+		let item = a:snippet[pos]
+
+		if type(item) == type('')
+			let str .= item
+		elseif type(item) == type([])
+			let str .= snipMate#placeholder_str(item[0], a:stops)
+		endif
+
+		let pos += 1
+		unlet item " avoid E706
+	endwhile
+
+	return str
+endfunction
+
+function! s:build_stops(snippet, stops, lnum, col, indent) abort
+	let stops = a:stops
+	let lnum  = a:lnum
+	let col   = a:col
+
+	for line in a:snippet
+		let col = s:build_loc_info(line, stops, lnum, col, [])
+		if line isnot a:snippet[-1]
+			let lnum += 1
+			let col = a:indent
+		endif
+	endfor
+
+	" add zero tabstop if it doesn't exist and then link it to the highest stop
+	" number
+	let stops[0] = get(stops, 0,
+				\ { 'placeholder' : [], 'line' : lnum, 'col' : col })
+	let stop_count = max(keys(stops)) + 2
+	let stops[stop_count - 1] = stops[0]
+
+	return stop_count
+endfunction
+
+function! s:build_loc_info(snippet, stops, lnum, col, seen_items) abort
+	let stops   = a:stops
+	let lnum    = a:lnum
+	let col     = a:col
+	let pos     = 0
+	let in_text = 0
+	let seen_items = a:seen_items
+
+	for item in a:snippet
+		if type(item) == type('')
+			let col += len(item)
+		elseif type(item) == type([])
+			let id = item[0]
+			let stub = item[-1]
+			let stub.line = lnum
+			let stub.col = col
+			call s:add_update_objects(stub, seen_items)
+
+			if len(item) > 2 && type(item[1]) != type({})
+				let col = s:build_loc_info(item[1:-2], stops, lnum, col, seen_items)
+			else
+				let col += len(snipMate#placeholder_str(id, stops))
+			endif
+
+			let in_text = 0
+		endif
+		unlet item " avoid E706
+	endfor
+
+	return col
+endfunction
+
+function! s:add_update_objects(object, targets) abort
+	let targets = a:targets
+
+	for item in targets
+		let item.update_objects = get(item, 'update_objects', [])
+		call add(item.update_objects, a:object)
+	endfor
+
+	call add(targets, a:object)
+endfunction
+
+" reads a .snippets file
+" returns list of
+" ['triggername', 'name', 'contents']
+" if triggername is not set 'default' is assumed
+" TODO: better error checking
+fun! snipMate#ReadSnippetsFile(file) abort
+	let result = []
+	let new_scopes = []
+	if !filereadable(a:file) | return [result, new_scopes] | endif
+	let inSnip = 0
+	let line_no = 0
+	let snipversion = get(g:snipMate, 'snippet_version', 0)
+	for line in readfile(a:file) + ["\n"]
+		let line_no += 1
+
+		if inSnip && (line[0] == "\t" || line == '')
+			let content .= strpart(line, 1)."\n"
+			continue
+		elseif inSnip
+			call add(result, [trigger, name,
+						\     content[:-2], bang, snipversion])
+			let inSnip = 0
+		endif
+
+		if line[:6] == 'snippet'
+			let inSnip = 1
+			let bang = (line[7] == '!')
+			if bang
+				let bang += line[8] == '!'
+			endif
+			let trigger = strpart(line, 8 + bang)
+			let name = ''
+			let space = stridx(trigger, ' ') + 1
+			if space " Process multi snip
+				let name = strpart(trigger, space)
+				let trigger = strpart(trigger, 0, space - 1)
+			endif
+			let content = ''
+			if trigger =~ '^\s*$' " discard snippets with empty triggers
+				echom 'Invalid snippet in' a:file 'near line' line_no
+				let inSnip = 0
+			endif
+		elseif line[:6] == 'extends'
+			call extend(new_scopes, map(split(strpart(line, 8)),
+						\ "substitute(v:val, ',*$', '', '')"))
+		elseif line[:6] == 'version'
+			let snipversion = +strpart(line, 8)
+		endif
+	endfor
+	return [result, new_scopes]
+endf
+
+function! s:GetScopes() abort
+	let ret = exists('b:snipMate.scope_aliases') ? copy(b:snipMate.scope_aliases) : {}
+	let global = get(g:snipMate, 'scope_aliases', {})
+	for alias in keys(global)
+		if has_key(ret, alias)
+			let ret[alias] = join(split(ret[alias], ',')
+						\ + split(global[alias], ','), ',')
+		else
+			let ret[alias] = global[alias]
+		endif
+	endfor
+	return ret
+endfunction
+
+" adds scope aliases to list.
+" returns new list
+" the aliases of aliases are added recursively
+fun! s:AddScopeAliases(list) abort
+  let did = {}
+  let scope_aliases = s:GetScopes()
+  let new = a:list
+  let new2 =  []
+  while !empty(new)
+	for i in new
+	  if !has_key(did, i)
+		let did[i] = 1
+		call extend(new2, split(get(scope_aliases,i,''),','))
+	  endif
+	endfor
+	let new = new2
+	let new2 = []
+  endwhile
+  return keys(did)
+endf
+
+augroup SnipMateSource
+	au SourceCmd *.snippet,*.snippets call s:source_snippet()
+augroup END
+
+function! s:info_from_filename(file) abort
+	let parts = split(fnamemodify(a:file, ':r'), '/')
+	let snipidx = len(parts) - index(reverse(copy(parts)), 'snippets') - 1
+	let rtp_prefix = join(parts[(snipidx -
+				\ (parts[snipidx - 1] == 'after' ? 3 : 2)):snipidx - 1], '/')
+	let trigger = get(parts, snipidx + 2, '')
+	let desc = get(parts, snipidx + 3, get(g:snipMate, 'override', 0) ?
+				\ '' : fnamemodify(a:file, ':t'))
+	return [rtp_prefix, trigger, desc]
+endfunction
+
+function! s:source_snippet() abort
+	let file = expand('<afile>:p')
+	let [rtp_prefix, trigger, desc] = s:info_from_filename(file)
+	let new_snips = []
+	if fnamemodify(file, ':e') == 'snippet'
+		call add(new_snips, [trigger, desc, join(readfile(file), "\n"), 0,
+					\ get(g:snipMate, 'snippet_version', 0)])
+	else
+		let [snippets, extends] = s:CachedSnips(file)
+		let new_snips = deepcopy(snippets)
+		call extend(s:lookup_state.extends, extends)
+	endif
+	for snip in new_snips
+		if get(g:snipMate, 'override', 0)
+			let snip[1] = join([s:lookup_state.scope, snip[1]])
+		else
+			let snip[1] = join([s:lookup_state.scope, rtp_prefix,
+						\ empty(snip[1]) ? desc : snip[1]])
+		endif
+	endfor
+	call extend(s:lookup_state.snips, new_snips)
+endfunction
+
+function! s:CachedSnips(file) abort
+	let mtime = getftime(a:file)
+	if has_key(s:cache, a:file) && s:cache[a:file].mtime >= mtime
+		return s:cache[a:file].contents
+	endif
+	let s:cache[a:file] = {}
+	let s:cache[a:file].mtime = mtime
+	let s:cache[a:file].contents = snipMate#ReadSnippetsFile(a:file)
+	return s:cache[a:file].contents
+endfunction
+
+function! s:snippet_filenames(scope, trigger) abort
+	let mid = ['', '_*', '/*']
+	let mid += map(copy(mid), "'/' . a:trigger . '*' . v:val")
+	call map(mid, "'snippets/' . a:scope . v:val . '.snippet'")
+	return map(mid[:2], 'v:val . "s"') + mid[3:]
+endfunction
+
+function! snipMate#SetByPath(dict, trigger, path, snippet, bang, snipversion) abort
+	let d = a:dict
+	if a:bang == 2
+		unlet! d[a:trigger]
+		return
+	elseif !has_key(d, a:trigger) || a:bang == 1
+		let d[a:trigger] = {}
+	endif
+	let d[a:trigger][a:path] = [a:snippet, a:snipversion]
+endfunction
+
+if v:version < 704 || has('win32')
+	function! s:Glob(path, expr)
+		let res = []
+		for p in split(a:path, ',')
+			let h = split(fnamemodify(a:expr, ':h'), '/')[0]
+			if isdirectory(p . '/' . h)
+				call extend(res, split(glob(p . '/' . a:expr), "\n"))
+			endif
+		endfor
+		return filter(res, 'filereadable(v:val)')
+	endfunction
+else
+	function! s:Glob(path, expr)
+		return split(globpath(a:path, a:expr), "\n")
+	endfunction
+endif
+
+" default triggers based on paths
+function! snipMate#DefaultPool(scopes, trigger, result) abort
+	let scopes = s:AddScopeAliases(a:scopes)
+	let scopes_done = []
+	let s:lookup_state = {}
+	let s:lookup_state.snips = []
+
+	while !empty(scopes)
+		let scope = remove(scopes, 0)
+		let s:lookup_state.scope = scope
+		let s:lookup_state.extends = []
+
+		for expr in s:snippet_filenames(scope, escape(a:trigger, "*[]?{}`'$|#%"))
+			for path in g:snipMate.snippet_dirs
+				for file in s:Glob(path, expr)
+					source `=file`
+				endfor
+			endfor
+		endfor
+
+		call add(scopes_done, scope)
+		call extend(scopes, s:lookup_state.extends)
+		call filter(scopes, 'index(scopes_done, v:val) == -1')
+	endwhile
+
+	for [trigger, desc, contents, bang, snipversion] in s:lookup_state.snips
+		if trigger =~ '\V\^' . escape(a:trigger, '\')
+			call snipMate#SetByPath(a:result, trigger, desc, contents, bang, snipversion)
+		endif
+	endfor
+endfunction
+
+" return a dict of snippets found in runtimepath matching trigger
+" scopes: list of scopes. usually this is the filetype. eg ['c','cpp']
+" trigger may contain glob patterns. Thus use '*' to get all triggers
+"
+fun! snipMate#GetSnippets(scopes, trigger) abort
+	let result = {}
+
+	for F in values(g:snipMateSources)
+	  call funcref#Call(F, [a:scopes, a:trigger, result])
+	endfor
+	return result
+endf
+
+function! snipMate#OpenSnippetFiles() abort
+	let files = []
+	let scopes_done = []
+	let exists = []
+	let notexists = []
+	for scope in s:AddScopeAliases(snipMate#ScopesByFile())
+		let files += s:snippet_filenames(scope, '')
+	endfor
+	call filter(files, "v:val !~# '\\*'")
+	for path in g:snipMate.snippet_dirs
+		let fullpaths = map(copy(files), 'printf("%s/%s", path, v:val)')
+		let exists += filter(copy(fullpaths), 'filereadable(v:val)')
+		let notexists += map(filter(copy(fullpaths),
+					\ 'v:val =~# "\.snippets" && !filereadable(v:val)'),
+					\       '"does not exist: " . v:val')
+	endfor
+	let all = exists + notexists
+	let select = tlib#input#List('mi', 'select files to be opened in splits', all)
+	for idx in select
+		exec 'sp' all[idx - 1]
+	endfor
+endfunction
+
+fun! snipMate#ScopesByFile() abort
+	" duplicates are removed in AddScopeAliases
+	return filter(funcref#Call(g:snipMate.get_scopes), "v:val != ''")
+endf
+
+" used by both: completion and insert snippet
+fun! snipMate#GetSnippetsForWordBelowCursor(word, exact) abort
+	" Split non-word characters into their own piece
+	" so 'foo.bar..baz' becomes ['foo', '.', 'bar', '.', '.', 'baz']
+	" First split just after a \W and then split each resultant string just
+	" before a \W
+	let parts = filter(tlib#list#Flatten(
+				\ map(split(a:word, '\W\zs'), 'split(v:val, "\\ze\\W")')),
+				\ '!empty(v:val)')
+	" Only look at the last few possibilities. Too many can be slow.
+	if len(parts) > 5
+		let parts = parts[-5:]
+	endif
+	let lookups = [a:word]
+	let lookup = ''
+	for w in reverse(parts)
+		let lookup = w . lookup
+		if index(lookups, lookup) == -1
+			call add(lookups, lookup)
+		endif
+	endfor
+
+	" Remove empty lookup entries, but only if there are other nonempty lookups
+	if len(lookups) > 1
+		call filter(lookups, 'v:val != ""')
+	endif
+
+	let matching_snippets = []
+	let snippet = ''
+	" prefer longest word
+	for word in lookups
+		let g:snipMate.word = word
+		for [k,snippetD] in items(funcref#Call(g:snipMate['get_snippets'], [snipMate#ScopesByFile(), word]))
+			" hack: require exact match
+			if a:exact && k !=# word
+				continue
+			endif
+			call add(matching_snippets, [k, snippetD])
+			if a:exact
+				break
+			endif
+		endfor
+	endfor
+	return matching_snippets
+endf
+
+" snippets: dict containing snippets by name
+" usually this is just {'default' : snippet_contents }
+fun! s:ChooseSnippet(snippets) abort
+	let snippet = []
+	let keys = keys(a:snippets)
+	let i = 1
+	for snip in keys
+		let snippet += [i.'. '.snip]
+		let i += 1
+	endfor
+	if len(snippet) == 1
+		" there's only a single snippet, choose it
+		let idx = 0
+	else
+		let idx = tlib#input#List('si','select snippet by name',snippet) -1
+		if idx == -1
+			return ''
+		endif
+	endif
+	" if a:snippets[..] is a String Call returns it
+	" If it's a function or a function string the result is returned
+	return funcref#Call(a:snippets[keys(a:snippets)[idx]])
+endf
+
+fun! snipMate#WordBelowCursor() abort
+	return matchstr(getline('.'), '\S\+\%' . col('.') . 'c')
+endf
+
+fun! snipMate#GetSnippetsForWordBelowCursorForComplete(word) abort
+	let matches = snipMate#GetSnippetsForWordBelowCursor(a:word, 0)
+	let snippets = []
+	for [trigger, dict] in matches
+		if get(g:snipMate, 'description_in_completion', 0)
+			call extend(snippets, map(keys(dict),
+						\ '{ "word" : trigger, "menu" : v:val, "dup" : 1 }'))
+		else
+			call add(snippets, { "word" : trigger })
+		endif
+	endfor
+	return filter(snippets,
+				\ 'v:val.word =~# "\\V\\^' . escape(a:word, '"\') . '"')
+endf
+
+fun! snipMate#CanBeTriggered() abort
+	let word    = snipMate#WordBelowCursor()
+	let matches = snipMate#GetSnippetsForWordBelowCursorForComplete(word)
+	return len(matches) > 0
+endf
+
+fun! snipMate#ShowAvailableSnips() abort
+	let col     = col('.')
+	let word    = snipMate#WordBelowCursor()
+	let matches = snipMate#GetSnippetsForWordBelowCursorForComplete(word)
+
+	" Pretty hacky, but really can't have the tab swallowed!
+	if len(matches) == 0
+		call feedkeys(g:snipMate['no_match_completion_feedkeys_chars'], 'n')
+		return ""
+	endif
+
+	call complete(col - len(word), sort(matches))
+	return ''
+endf
+
+" Pass an argument to force snippet expansion instead of triggering or jumping
+function! snipMate#TriggerSnippet(...) abort
+	if exists('g:SuperTabMappingForward')
+		if g:SuperTabMappingForward == "<tab>"
+			let SuperTabPlug = maparg('<Plug>SuperTabForward', 'i')
+			if SuperTabPlug == ""
+				let SuperTabKey = "\<c-n>"
+			else
+				exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
+			endif
+		elseif g:SuperTabMappingBackward == "<tab>"
+			let SuperTabPlug = maparg('<Plug>SuperTabBackward', 'i')
+			if SuperTabPlug == ""
+				let SuperTabKey = "\<c-p>"
+			else
+				exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
+			endif
+		endif
+	endif
+
+	if pumvisible() " Update snippet if completion is used, or deal with supertab
+		if exists('SuperTabKey')
+			call feedkeys(SuperTabKey) | return ''
+		endif
+		call feedkeys("\<esc>a", 'n') " Close completion menu
+		call feedkeys("\<tab>") | return ''
+	endif
+
+	if exists('b:snip_state') && a:0 == 0 " Jump only if no arguments
+		let jump = b:snip_state.jump_stop(0)
+		if type(jump) == 1 " returned a string
+			return jump
+		endif
+	endif
+
+	let word = matchstr(getline('.'), '\S\+\%'.col('.').'c')
+	let list = snipMate#GetSnippetsForWordBelowCursor(word, 1)
+	if empty(list)
+		let snippet = ''
+	else
+		let [trigger, snippetD] = list[0]
+		let snippet = s:ChooseSnippet(snippetD)
+		" Before expanding snippet, create new undo point |i_CTRL-G|
+		let &undolevels = &undolevels
+		let col = col('.') - len(trigger)
+		sil exe 's/\V'.escape(trigger, '/\.').'\%#//'
+		return snipMate#expandSnip(snippet[0], snippet[1], col)
+	endif
+
+	" should allow other plugins to register hooks instead (duplicate code)
+	if exists('SuperTabKey')
+		call feedkeys(SuperTabKey)
+		return ''
+	endif
+	return word == ''
+	  \ ? "\<tab>"
+	  \ : "\<c-r>=snipMate#ShowAvailableSnips()\<cr>"
+endfunction
+
+fun! snipMate#BackwardsSnippet() abort
+	if exists('b:snip_state') | return b:snip_state.jump_stop(1) | endif
+
+	if exists('g:SuperTabMappingForward')
+		if g:SuperTabMappingForward == "<s-tab>"
+			let SuperTabPlug = maparg('<Plug>SuperTabForward', 'i')
+			if SuperTabPlug == ""
+				let SuperTabKey = "\<c-n>"
+			else
+				exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
+			endif
+		elseif g:SuperTabMappingBackward == "<s-tab>"
+			let SuperTabPlug = maparg('<Plug>SuperTabBackward', 'i')
+			if SuperTabPlug == ""
+				let SuperTabKey = "\<c-p>"
+			else
+				exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
+			endif
+		endif
+	endif
+	" should allow other plugins to register hooks instead (duplicate code)
+	if exists('SuperTabKey')
+		call feedkeys(SuperTabKey)
+		return ''
+	endif
+	return "\<s-tab>"
+endf
+
+" vim:noet:sw=4:ts=4:ft=vim
diff --git a/vim/.vim/bundle/snipmate/autoload/snipMate_python_demo.vim b/vim/.vim/bundle/snipmate/autoload/snipMate_python_demo.vim
new file mode 100644
index 0000000..de495d2
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/autoload/snipMate_python_demo.vim
@@ -0,0 +1,47 @@
+" This file demonstrates
+" - how to register your own snippet sources (call snipMate_python_demo#Activate() in ftplugin/python.vim)
+" - implents a source which creates snippets based on python function
+"   definitions found in the current file
+"
+" Example:
+"
+" def abc(a,b,c=None)
+" will create a snippet on the fly which looks like this:
+" abc(${1:a}, ${2:b}, ${3:c=None})
+
+fun! snipMate_python_demo#Activate() abort
+  if !exists('g:snipMateSources')
+    let g:snipMateSources = {}
+  endif
+
+  let g:snipMateSources['python'] = funcref#Function('snipMate_python_demo#FunctionsFromCurrentFileAndTags')
+endf
+
+fun! s:Add(dict, line, source, trigger) abort
+  let matched = matchlist(a:line,'def\s\+\([^( \t]\+\)[ \t]*(\([^)]*\)')
+  if len(matched) > 2
+    let name = matched[1]
+    " TODO: is this a glob?
+    if name !~ a:trigger | return  | endif
+    let a:dict[name] = get(a:dict, name, {})
+    let sd = a:dict[name]
+    let args = []
+    let nr=1
+    for arg in split(matched[2], '\s*,\s*')
+      call add(args, '${'.nr.':'.arg.'}')
+      let nr+=1
+    endfor
+    let sd[a:source] = name.'('.join(args,', ').')'
+  endif
+endf
+fun! snipMate_python_demo#FunctionsFromCurrentFileAndTags(scopes, trigger, result) abort
+  " getting all might be too much
+  if a:trigger == '*' | return | endif
+  if index(a:scopes, 'python') < 0 | return | endif
+  for t in taglist('^'.a:trigger)
+    call s:Add(a:result, t.cmd, 'tags-' . t.filename, a:trigger)
+  endfor
+  for l in getline(0, line('$'))
+    call s:Add(a:result, l, 'current-file', a:trigger)
+  endfor
+endf
diff --git a/vim/.vim/bundle/snipmate/autoload/snipmate/jumping.vim b/vim/.vim/bundle/snipmate/autoload/snipmate/jumping.vim
new file mode 100644
index 0000000..aaf65ab
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/autoload/snipmate/jumping.vim
@@ -0,0 +1,228 @@
+function! s:sfile() abort
+	return expand('<sfile>')
+endfunction
+
+let s:state_proto = {}
+
+function! snipmate#jumping#state() abort
+	return copy(s:state_proto)
+endfunction
+
+function! s:listize_mirror(mirrors) abort
+	return map(copy(a:mirrors), '[v:val.line, v:val.col]')
+endfunction
+
+" Removes snippet state info
+function! s:state_remove() dict abort
+	" Remove all autocmds in group snipmate_changes in the current buffer
+	unlet! b:snip_state
+	silent! au! snipmate_changes * <buffer>
+endfunction
+
+function! s:state_find_next_stop(backwards) dict abort
+	let self.stop_no += a:backwards? -1 : 1
+	while !has_key(self.stops, self.stop_no)
+		if self.stop_no == self.stop_count
+			let self.stop_no = 0
+		endif
+		if self.stop_no <= 0 && a:backwards
+			let self.stop_no = self.stop_count - 1
+		endif
+		let self.stop_no += a:backwards? -1 : 1
+	endwhile
+endfunction
+
+" Update state information to correspond to the given tab stop
+function! s:state_set_stop(backwards) dict abort
+	call self.find_next_stop(a:backwards)
+	let self.cur_stop    = self.stops[self.stop_no]
+	let self.stop_len = (type(self.cur_stop.placeholder) == type(0))
+				\ ? self.cur_stop.placeholder
+				\ : len(snipMate#placeholder_str(self.stop_no, self.stops))
+	let self.start_col   = self.cur_stop.col
+	let self.end_col     = self.start_col + self.stop_len
+	let self.mirrors     = get(self.cur_stop, 'mirrors', [])
+	let self.old_mirrors = deepcopy(self.mirrors)
+	call cursor(self.cur_stop.line, self.cur_stop.col)
+	let self.prev_len    = col('$')
+	let self.changed = 0
+	let ret = self.select_word()
+	if (self.stop_no == 0 || self.stop_no == self.stop_count - 1) && !a:backwards
+		call self.remove()
+	endif
+	return ret
+endfunction
+
+" Jump to the next/previous tab stop
+function! s:state_jump_stop(backwards) dict abort
+	" Update changes just in case
+	" This seems to be only needed because insert completion does not trigger
+	" the CursorMovedI event
+	call self.update_changes()
+
+	" Store placeholder/location changes
+	let self.cur_stop.col = self.start_col
+	if self.changed
+		call self.remove_nested()
+		unlet! self.cur_stop.placeholder " avoid type error for old parsing version
+		let self.cur_stop.placeholder = [strpart(getline('.'),
+					\ self.start_col - 1, self.end_col - self.start_col)]
+	endif
+
+	return self.set_stop(a:backwards)
+endfunction
+
+function! s:state_remove_nested(...) dict abort
+	let id = a:0 ? a:1 : self.stop_no
+	if type(self.stops[id].placeholder) == type([])
+		for i in self.stops[id].placeholder
+			if type(i) == type([])
+				if type(i[1]) != type({})
+					call self.remove_nested(i[0])
+					call remove(self.stops, i[0])
+				else
+					call filter(self.stops[i[0]].mirrors, 'v:val isnot i[1]')
+				endif
+			endif
+			unlet i " Avoid E706
+		endfor
+	endif
+endfunction
+
+" Select the placeholder for the current tab stop
+function! s:state_select_word() dict abort
+	let len = self.stop_len
+	if !len | return '' | endif
+	let l = col('.') != 1 ? 'l' : ''
+	if &sel == 'exclusive'
+		return "\<esc>".l.'v'.len."l\<c-g>"
+	endif
+	return len == 1 ? "\<esc>".l.'gh' : "\<esc>".l.'v'.(len - 1)."l\<c-g>"
+endfunction
+
+" Update the snippet as text is typed. The self.update_mirrors() function does
+" the actual work.
+" If the cursor moves outside of a placeholder, call self.remove()
+function! s:state_update_changes() dict abort
+	let change_len = col('$') - self.prev_len
+	let self.changed = self.changed || change_len != 0
+	let self.end_col += change_len
+	let col = col('.')
+
+	if line('.') != self.cur_stop.line || col < self.start_col || col > self.end_col
+		return self.remove()
+	endif
+
+	call self.update(self.cur_stop, change_len, change_len)
+	if !empty(self.mirrors)
+		call self.update_mirrors(change_len)
+	endif
+
+	let self.prev_len = col('$')
+endfunction
+
+" Actually update the mirrors for any changed text
+function! s:state_update_mirrors(change) dict abort
+	let newWordLen = self.end_col - self.start_col
+	let newWord = strpart(getline('.'), self.start_col - 1, newWordLen)
+	let changeLen = a:change
+	let curLine = line('.')
+	let curCol = col('.')
+	let oldStartSnip = self.start_col
+	let i = 0
+
+	for mirror in self.mirrors
+		for stop in values(filter(copy(self.stops), 'v:key != 0'))
+			if type(stop.placeholder) == type(0)
+				if mirror.line == stop.line && mirror.col > stop.col
+							\ && mirror.col < stop.col + stop.placeholder
+					let stop.placeholder += changeLen
+				endif
+			endif
+		endfor
+
+		if has_key(mirror, 'oldSize')
+			" recover the old size deduce the endline
+			let oldSize = mirror.oldSize
+		else
+			" first time, we use the intitial size
+			let oldSize = strlen(newWord)
+		endif
+
+		" Split the line into three parts: the mirror, what's before it, and
+		" what's after it. Then combine them using the new mirror string.
+		" Subtract one to go from column index to byte index
+
+		let theline = getline(mirror.line)
+
+		" part before the current mirror
+		let beginline  = strpart(theline, 0, mirror.col - 1)
+
+		" current mirror transformation, and save size
+		let wordMirror= substitute(newWord, get(mirror, 'pat', ''), get(mirror, 'sub', ''), get(mirror, 'flags', ''))
+		let mirror.oldSize = strlen(wordMirror)
+
+		" end of the line, use the oldSize because with the transformation,
+		" the size of the mirror can be different from those of the snippet
+		let endline    = strpart(theline, mirror.col + oldSize -1)
+
+		" Update other object on the line
+		call self.update(mirror, changeLen, mirror.oldSize - oldSize)
+
+		" reconstruct the line
+		let update = beginline.wordMirror.endline
+
+		call setline(mirror.line, update)
+	endfor
+
+	" Reposition the cursor in case a var updates on the same line but before
+	" the current tabstop
+	if oldStartSnip != self.start_col || mode() == 'i'
+		call cursor(0, curCol + self.start_col - oldStartSnip)
+	endif
+endfunction
+
+function! s:state_find_update_objects(item) dict abort
+	let item = a:item
+	let item.update_objects = []
+
+	" Filter the zeroth stop because it's duplicated as the last
+	for stop in values(filter(copy(self.stops), 'v:key != 0'))
+		if stop.line == item.line && stop.col > item.col
+			call add(item.update_objects, stop)
+		endif
+
+		for mirror in get(stop, 'mirrors', [])
+			if mirror.line == item.line && mirror.col > item.col
+				call add(item.update_objects, mirror)
+			endif
+		endfor
+	endfor
+
+	return item.update_objects
+endfunction
+
+function! s:state_update(item, change_len, mirror_change) dict abort
+	let item = a:item
+	if !exists('item.update_objects')
+		let item.update_objects = self.find_update_objects(a:item)
+	endif
+	let to_update = item.update_objects
+
+	for obj in to_update
+		" object does not necessarly have the same decalage
+		" than mirrors if mirrors use regexp
+		let obj.col += a:mirror_change
+		if obj is self.cur_stop
+			let self.start_col += a:change_len
+			let self.end_col += a:change_len
+		endif
+	endfor
+endfunction
+
+call extend(s:state_proto, snipmate#util#add_methods(s:sfile(), 'state',
+			\ [ 'remove', 'set_stop', 'jump_stop', 'remove_nested',
+			\ 'select_word', 'update_changes', 'update_mirrors',
+			\ 'find_next_stop', 'find_update_objects', 'update' ]), 'error')
+
+" vim:noet:sw=4:ts=4:ft=vim
diff --git a/vim/.vim/bundle/snipmate/autoload/snipmate/legacy.vim b/vim/.vim/bundle/snipmate/autoload/snipmate/legacy.vim
new file mode 100644
index 0000000..7ff39cb
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/autoload/snipmate/legacy.vim
@@ -0,0 +1,139 @@
+let s:sigil = nr2char(31)
+let snipmate#legacy#sigil = s:sigil
+
+" Prepare snippet to be processed by s:BuildTabStops
+function! snipmate#legacy#process_snippet(snip) abort
+	let snippet = a:snip
+	let esc_bslash = '\%(\\\@<!\%(\\\\\)*\)\@<='
+
+	if exists('b:snipmate_visual')
+		let visual = substitute(b:snipmate_visual, "\n$", '', '')
+		unlet b:snipmate_visual
+	else
+		let visual = ''
+	endif
+        let snippet = s:substitute_visual(snippet, visual)
+
+	" Evaluate eval (`...`) expressions.
+	" Backquotes prefixed with a backslash "\" are ignored.
+	" And backslash can be escaped by doubling it.
+	" Using a loop here instead of a regex fixes a bug with nested "\=".
+	if stridx(snippet, '`') != -1
+		let new = []
+		let snip = split(snippet, esc_bslash . '`', 1)
+		let isexp = 0
+		for i in snip
+			if isexp
+				call add(new, substitute(snipmate#util#eval(i),
+                                            \ "\n\\%$", '', ''))
+			else
+				call add(new, i)
+			endif
+			let isexp = !isexp
+		endfor
+		let snippet = join(new, '')
+		let snippet = substitute(snippet, "\r", "\n", 'g')
+		let snippet = substitute(snippet, '\\`', "`", 'g')
+	endif
+
+	" Place all text after a colon in a tab stop after the tab stop
+	" (e.g. "${#:foo}" becomes "${:foo}foo").
+	" This helps tell the position of the tab stops later.
+	let snippet = substitute(snippet, esc_bslash . '\$\({\d\+:\(.\{-}\)}\|{\d\+}\)', s:sigil . '\1\2', 'g')
+	let snippet = substitute(snippet, esc_bslash . '\$\(\d\+\)', s:sigil . '\1', 'g')
+	let snippet = substitute(snippet, esc_bslash . '\\\$', '$', 'g')
+	let snippet = substitute(snippet, '\\\\', "\\", 'g')
+
+	" Update the a:snip so that all the $# become the text after
+	" the colon in their associated ${#}.
+	" (e.g. "${1:foo}" turns all "$1"'s into "foo")
+	let i = 0
+	if snippet !~ s:sigil . '{0'
+		let snippet .= s:sigil . '{0}'
+	endif
+	while snippet =~ s:sigil.'{'.i
+		let s = matchstr(snippet, s:sigil . '{' . i . ':\zs.\{-}\ze}')
+		if s != ''
+			let snippet = substitute(snippet, s:sigil . i, s.'&', 'g')
+		endif
+		let i += 1
+	endw
+
+	if &et " Expand tabs to spaces if 'expandtab' is set.
+		return substitute(snippet, '\t', repeat(' ', snipmate#util#tabwidth()), 'g')
+	endif
+	return snippet
+endfunction
+
+" Builds a list of a list of each tab stop in the snippet containing:
+" 1.) The tab stop's line number.
+" 2.) The tab stop's column number
+"     (by getting the length of the string between the last "\n" and the
+"     tab stop).
+" 3.) The length of the text after the colon for the current tab stop
+"     (e.g. "${1:foo}" would return 3).
+" 4.) If the "${#:}" construct is given, another list containing all
+"     the matches of "$#", to be replaced with the placeholder. This list is
+"     composed the same way as the parent; the first item is the line number,
+"     and the second is the column.
+function! snipmate#legacy#build_stops(snip, lnum, col, indent) abort
+	let stops = {}
+	let i = 0
+	let withoutVars = substitute(a:snip, s:sigil . '\d\+', '', 'g')
+	while a:snip =~ s:sigil . '{' . i
+		let beforeTabStop = matchstr(withoutVars, '^.*\ze'.s:sigil .'{'.i.'\D')
+		let withoutOthers = substitute(withoutVars, ''.s:sigil .'{\('.i.'\D\)\@!\d\+.\{-}}', '', 'g')
+
+		let stops[i] = {}
+		let stops[i].line = a:lnum + s:count(beforeTabStop, "\n")
+		let stops[i].col = a:indent + len(matchstr(withoutOthers, '[^\n]\{-}\ze'.s:sigil .'{'.i.'\D'))
+		let stops[i].placeholder = 0
+		let stops[i].mirrors = []
+		if stops[i].line == a:lnum
+			let stops[i].col += a:col
+		endif
+
+		" Get all $# matches in another list, if ${#:name} is given
+		if withoutVars =~ printf('%s{%d:', s:sigil, i)
+			let stops[i].placeholder = len(matchstr(withoutVars, ''.s:sigil .'{'.i.':\zs.\{-}\ze}'))
+			let withoutOthers = substitute(a:snip, ''.s:sigil .'{\d\+.\{-}}\|'.s:sigil .''.i.'\@!\d\+', '', 'g')
+
+			while match(withoutOthers, ''.s:sigil .''.i.'\(\D\|$\)') != -1
+				let stops[i].mirrors = get(stops[i], 'mirrors', [])
+				let beforeMark = matchstr(withoutOthers,
+							\ printf('^.\{-}\ze%s%s%d\(\D\|$\)',
+							\ repeat('.', stops[i].placeholder), s:sigil, i))
+				let line = a:lnum + s:count(beforeMark, "\n")
+				let col = a:indent + (line > a:lnum
+				                           \ ? len(matchstr(beforeMark, '.*\n\zs.*'))
+				                           \ : a:col + len(beforeMark))
+				call add(stops[i].mirrors, { 'line' : line, 'col' : col })
+				let withoutOthers = substitute(withoutOthers, ''.s:sigil .''.i.'\ze\(\D\|$\)', '', '')
+			endw
+		endif
+		let i += 1
+	endw
+	let stops[i] = stops[0]
+	return [stops, i + 1]
+endfunction
+
+function! s:substitute_visual(snippet, visual) abort
+    let lines = []
+    for line in split(a:snippet, "\n")
+        let indent = matchstr(line, '^\t\+')
+        call add(lines, substitute(line, '{VISUAL}',
+                    \ substitute(escape(a:visual, '%\'), "\n", "\n" . indent, 'g'), 'g'))
+    endfor
+    return join(lines, "\n")
+endfunction
+
+" Counts occurences of haystack in needle
+function! s:count(haystack, needle) abort
+	let counter = 0
+	let index = stridx(a:haystack, a:needle)
+	while index != -1
+		let index = stridx(a:haystack, a:needle, index+1)
+		let counter += 1
+	endw
+	return counter
+endfunction
diff --git a/vim/.vim/bundle/snipmate/autoload/snipmate/parse.vim b/vim/.vim/bundle/snipmate/autoload/snipmate/parse.vim
new file mode 100644
index 0000000..dd495e9
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/autoload/snipmate/parse.vim
@@ -0,0 +1,309 @@
+" Snippet definition parsing code
+
+function! s:sfile() abort
+    return expand('<sfile>')
+endfunction
+
+let s:parser_proto = {}
+let s:special_chars = "$`\n"
+
+function! s:new_parser(text) abort
+    let ret = copy(s:parser_proto)
+    let ret.input = a:text
+    let ret.len = strlen(ret.input)
+    let ret.pos = -1
+    let ret.indent = 0
+    let ret.value = []
+    let ret.vars = {}
+    let ret.stored_lines = []
+    call ret.advance()
+    return ret
+endfunction
+
+function! s:parser_advance(...) dict abort
+    let self.pos += a:0 ? a:1 : 1
+    let self.next = self.input[self.pos]
+endfunction
+
+function! s:parser_same(tok) dict abort
+    if self.next == a:tok
+        call self.advance()
+        return 1
+    else
+        return 0
+    endif
+endfunction
+
+function! s:parser_id() dict abort
+    if self.input[(self.pos):(self.pos+5)] == 'VISUAL'
+        call self.advance(6)
+        return 'VISUAL'
+    elseif self.next =~ '\d'
+        let end = matchend(self.input, '\d\+', self.pos)
+        let res = strpart(self.input, self.pos, end - self.pos)
+        call self.advance(end - self.pos)
+        return +res " force conversion to Number
+    endif
+    return -1
+endfunction
+
+function! s:parser_add_var(var) dict abort
+    let id = a:var[0]
+    if !has_key(self.vars, id)
+        let self.vars[id] = { 'instances' : [] }
+    endif
+    call add(self.vars[id].instances, a:var)
+endfunction
+
+function! s:parser_var() dict abort
+    let ret = []
+    if self.same('{')
+        let id = self.id()
+        if id >= 0
+            call add(ret, id)
+            call extend(ret, self.varend())
+        endif
+    else
+        let id = self.id()
+        if id >= 0
+            call add(ret, id)
+        endif
+    endif
+    return ret
+endfunction
+
+function! s:parser_varend() dict abort
+    let ret = []
+    if self.same(':')
+        call extend(ret, self.placeholder())
+    elseif self.same('/')
+        call add(ret, self.subst())
+    endif
+    call self.same('}')
+    return ret
+endfunction
+
+function! s:parser_placeholder() dict abort
+    let ret = self.text('}')
+    return empty(ret) ? [''] : ret
+endfunction
+
+function! s:parser_subst() dict abort
+    let ret = {}
+    let ret.pat = self.pat()
+    if self.same('/')
+        let ret.sub = self.pat(1)
+    endif
+    if self.same('/')
+        let ret.flags = self.pat(1)
+    endif
+    return ret
+endfunction
+
+function! s:parser_pat(...) dict abort
+    let val = ''
+
+    while self.pos < self.len
+        if self.same('\')
+            if self.next == '/'
+                let val .= '/'
+                call self.advance()
+            elseif a:0 && self.next == '}'
+                let val .= '}'
+                call self.advance()
+            else
+                let val .= '\'
+            endif
+        elseif self.next == '/' || a:0 && self.next == '}'
+            break
+        else
+            let val .= self.next
+            call self.advance()
+        endif
+    endwhile
+
+    return val
+endfunction
+
+function! s:parser_expr() dict abort
+    let str = self.string('`')
+    call self.same('`')
+    return snipmate#util#eval(str)
+endfunction
+
+function! s:parser_string(till, ...) dict abort
+    let val = ''
+    let till = '\V\[' . escape(a:till, '\') . ']'
+
+    while self.pos < self.len
+        if self.same('\')
+            if self.next != "\n"
+                let val .= self.next
+            endif
+            call self.advance()
+        elseif self.next =~# till
+            break
+        elseif self.next == "\t"
+            let self.indent += 1
+            let val .= s:indent(1)
+            call self.advance()
+        else
+            let val .= self.next
+            call self.advance()
+        endif
+    endwhile
+
+    return val
+endfunction
+
+function! s:join_consecutive_strings(list) abort
+    let list = a:list
+    let pos = 0
+    while pos + 1 < len(list)
+        if type(list[pos]) == type('') && type(list[pos+1]) == type('')
+            let list[pos] .= list[pos+1]
+            call remove(list, pos + 1)
+        else
+            let pos += 1
+        endif
+    endwhile
+endfunction
+
+function! s:parser_text(till) dict abort
+    let ret = []
+
+    while self.pos < self.len
+        let lines = []
+
+        if self.same('$')
+            let var = self.var()
+            if !empty(var)
+                if var[0] is# 'VISUAL'
+                    let lines = s:visual_placeholder(var, self.indent)
+                elseif var[0] >= 0
+                    call add(ret, var)
+                    call self.add_var(var)
+                endif
+            endif
+        elseif self.same('`')
+            let lines = split(self.expr(), "\n", 1)
+        else
+            let lines = [self.string(a:till . s:special_chars)]
+        endif
+
+        if !empty(lines)
+            call add(ret, lines[0])
+            call extend(self.stored_lines, lines[1:])
+        endif
+
+        " Empty lines are ignored if this is tested at the start of an iteration
+        if self.next ==# a:till
+            break
+        endif
+    endwhile
+
+    call s:join_consecutive_strings(ret)
+    return ret
+endfunction
+
+function! s:parser_line() dict abort
+    let ret = []
+    if !empty(self.stored_lines)
+        call add(ret, remove(self.stored_lines, 0))
+    else
+        call extend(ret, self.text("\n"))
+        call self.same("\n")
+    endif
+    let self.indent = 0
+    return ret
+endfunction
+
+function! s:parser_parse() dict abort
+    while self.pos < self.len || !empty(self.stored_lines)
+        let line = self.line()
+        call add(self.value, line)
+    endwhile
+endfunction
+
+function! s:indent(count) abort
+    if &expandtab
+        let shift = repeat(' ', snipmate#util#tabwidth())
+    else
+        let shift = "\t"
+    endif
+    return repeat(shift, a:count)
+endfunction
+
+function! s:visual_placeholder(var, indent) abort
+    let arg = get(a:var, 1, {})
+    if type(arg) == type({})
+        let pat = get(arg, 'pat', '')
+        let sub = get(arg, 'sub', '')
+        let flags = get(arg, 'flags', '')
+        let content = split(substitute(get(b:, 'snipmate_visual', ''), pat, sub, flags), "\n", 1)
+    else
+        let content = split(get(b:, 'snipmate_visual', arg), "\n", 1)
+    endif
+
+    let indent = s:indent(a:indent)
+    call map(content, '(v:key != 0) ? indent . v:val : v:val')
+
+    return content
+endfunction
+
+function! s:parser_create_stubs() dict abort
+
+    for [id, dict] in items(self.vars)
+        for i in dict.instances
+            if len(i) > 1 && type(i[1]) != type({})
+                if !has_key(dict, 'placeholder')
+                    let dict.placeholder = i[1:]
+                    call add(i, dict)
+                else
+                    unlet i[1:]
+                    call s:create_mirror_stub(i, dict)
+                endif
+            else
+                call s:create_mirror_stub(i, dict)
+            endif
+        endfor
+        if !has_key(dict, 'placeholder')
+            let dict.placeholder = []
+            let j = 0
+            while len(dict.instances[j]) > 2
+                let j += 1
+            endwhile
+            let oldstub = remove(dict.instances[j], 1, -1)[-1]
+            call add(dict.instances[j], '')
+            call add(dict.instances[j], dict)
+            call filter(dict.mirrors, 'v:val isnot oldstub')
+        endif
+        unlet dict.instances
+    endfor
+
+endfunction
+
+function! s:create_mirror_stub(mirror, dict)
+    let mirror = a:mirror
+    let dict = a:dict
+    let stub = get(mirror, 1, {})
+    call add(mirror, stub)
+    let dict.mirrors = get(dict, 'mirrors', [])
+    call add(dict.mirrors, stub)
+endfunction
+
+function! snipmate#parse#snippet(text, ...) abort
+    let parser = s:new_parser(a:text)
+    call parser.parse()
+    if !(a:0 && a:1)
+        call parser.create_stubs()
+    endif
+    unlet! b:snipmate_visual
+    return [parser.value, parser.vars]
+endfunction
+
+call extend(s:parser_proto, snipmate#util#add_methods(s:sfile(), 'parser',
+            \ [ 'advance', 'same', 'id', 'add_var', 'var', 'varend',
+            \   'line', 'string', 'create_stubs', 'pat',
+            \   'placeholder', 'subst', 'expr', 'text', 'parse',
+            \ ]), 'error')
diff --git a/vim/.vim/bundle/snipmate/autoload/snipmate/util.vim b/vim/.vim/bundle/snipmate/autoload/snipmate/util.vim
new file mode 100644
index 0000000..a80d307
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/autoload/snipmate/util.vim
@@ -0,0 +1,30 @@
+" The next function was based on s:function and s:add_methods in fugitive
+" <https://github.com/tpope/vim-fugitive/blob/master/plugin/fugitive.vim>
+function! snipmate#util#add_methods(sfile, namespace, methods) abort
+	let dict = {}
+	for name in a:methods
+		let dict[name] = function(join([matchstr(a:sfile, '<SNR>\d\+'),
+                    \ a:namespace, name], '_'))
+	endfor
+	return dict
+endfunction
+
+function! snipmate#util#eval(arg)
+    try
+        let ret = eval(a:arg)
+    catch
+        echohl ErrorMsg
+        echom 'SnipMate:Expression: ' . v:exception
+        echohl None
+        let ret = ''
+    endtry
+    return type(ret) == type('') ? ret : string(ret)
+endfunction
+
+function! snipmate#util#tabwidth()
+    if &sts > 0
+        return &sts
+    else
+        return exists('*shiftwidth') ? shiftwidth() : &sw
+    endif
+endfunction
diff --git a/vim/.vim/bundle/snipmate/doc/SnipMate.txt b/vim/.vim/bundle/snipmate/doc/SnipMate.txt
new file mode 100644
index 0000000..c97205a
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/doc/SnipMate.txt
@@ -0,0 +1,652 @@
+*SnipMate.txt*  Plugin for using TextMate-style snippets in Vim.
+
+SnipMate                                       *snippet* *snippets* *SnipMate*
+
+1. Description                        |SnipMate-description|
+2. Usage                              |SnipMate-usage|
+3. Interface and Settings             |SnipMate-interface| |SnipMate-settings|
+4. Snippets                           |SnipMate-snippets|
+  - Snippet files                     |SnipMate-snippet-files|
+  - Snippet syntax                    |SnipMate-syntax|
+5. Snippet sources                    |SnipMate-snippet-sources|
+6. Disadvantages to TextMate          |SnipMate-disadvantages|
+7. Contact                            |SnipMate-contact|
+8. License                            |SnipMate-license|
+
+For Vim version 7.0 or later.
+This plugin only works if 'compatible' is not set.
+{Vi does not have any of these features.}
+
+SnipMate depends on vim-addon-mw-utils and tlib.
+
+==============================================================================
+DESCRIPTION                                             *SnipMate-description*
+
+SnipMate implements snippet features in Vim. A snippet is like a template,
+reducing repetitive insertion of pieces of text. Snippets can contain
+placeholders for modifying the text if necessary or interpolated code for
+evaluation. For example, in C, typing "for" then pushing <Tab> could expand
+to: >
+
+    for (i = 0; i < count; i++) {
+        /* code */
+    }
+
+SnipMate is inspired by TextMate's snippet features.
+
+==============================================================================
+USAGE                                                         *SnipMate-usage*
+
+Every snippet consists of an expansion and a trigger. Typing a trigger into
+your buffer and then hitting your trigger key (<Tab> by default, see
+|SnipMate-mappings|) will replace the trigger with the expansion text.
+
+The expansion text can optionally include tab stops. When it does, upon
+expansion of the snippet, the cursor is placed at the first one, and the user
+can jump between each tab stop. Each of these tab stops can be represented by
+default placeholder text. If such a placeholder is provided, then the text of
+the placeholder can be repeated in the snippet at specified mirrors. Any edits
+to the placeholder are instantly updated at every mirror.
+
+SnipMate allows multiple snippets to use the same trigger. When triggered,
+a list of all snippets with that trigger is provided and prompts for which
+snippet to use.
+
+                                                             *SnipMate-scopes*
+SnipMate searches for snippets inside a directory named "snippets" inside each
+entry in 'runtimepath'. Which files are loaded depends on 'filetype' and
+'syntax'; see |SnipMate-syntax| for more information. Snippets are loaded and
+refreshed automatically on demand.
+
+Note: SnipMate does not ship with any snippets. In order to use it, the user
+must either write their own snippets or obtain some from a repository like
+https://github.com/honza/vim-snippets
+
+==============================================================================
+INTERFACE AND SETTINGS                *SnipMate-interface* *SnipMate-settings*
+
+                                                           *SnipMate-commands*
+Commands~
+
+                                                   *:SnipMateOpenSnippetFiles*
+:SnipMateOpenSnippetFiles       Opens a list of all valid snippet locations
+                                based on the current scope |SnipMate-scopes|.
+                                Only existing files and non-existing .snippets
+                                files will be shown, with the existing files
+                                shown first.
+
+:SnipMateLoadScope[!] scope [scope ...]
+                                Load snippets from additional scopes. Without
+                                [!] the additional scopes are loaded only in
+                                the current buffer. For example >
+                                    :SnipMateLoadScopes rails
+<                               will load all rails.snippets in the current
+                                buffer.
+
+                                                            *SnipMate-options*
+Options~
+
+g:snips_author                  A variable used in some snippets in place of
+                                the author's (your) name. Similar to
+                                $TM_FULLNAME in TextMate. For example, >
+                                    snippet name
+                                        `g:snips_author`
+<                               creates a snippet "name" that expands to your
+                                name.
+
+g:snipMate                      This |Dictionary| contains other SnipMate
+                                options. In short add >
+                                    let g:snipMate = {}
+<                               to your .vimrc before setting other SnipMate
+                                options.
+
+g:snipMate.scope_aliases        A |Dictionary| associating certain filetypes
+                                with other scopes |SnipMate-scopes|. The
+                                entries consist of a filetype as the key and
+                                a comma-separated list of aliases as the
+                                value. For example, >
+                                    let g:snipMate.scope_aliases = {}
+                                    let g:snipMate.scope_aliases['ruby']
+                                                \ = 'ruby,ruby-rails'
+<                               tells SnipMate that "ruby-rails" snippets in
+                                addition to "ruby" snippets should be loaded
+                                when editing files with 'filetype' set to
+                                "ruby" or contains "ruby" as an entry in the
+                                case of dotted filetypes. A buffer local
+                                variant b:snipMate_scope_aliases is merged
+                                with the global variant.
+
+g:snipMate_no_default_aliases   Note: This has been renamed to the following.
+
+g:snipMate.no_default_aliases
+                                When set to 1, prevents SnipMate from loading
+                                default scope aliases. The defaults are:
+                                    Filetype    Alias ~
+                                    cpp         c
+                                    cu          c
+                                    eruby       eruby-rails,html
+                                    html        javascript
+                                    mxml        actionscript
+                                    objc        c
+                                    php         php,html,javascript
+                                    ur          html,javascript
+                                    xhtml       html
+                                Individual defaults can be disabled by setting
+                                them to an empty value: >
+                                    let g:snipMate.scope_aliases.php = ''
+<                                will disable the default PHP alias.
+                                Note: Setting this option does not disable
+                                scope aliases entirely, only those made by
+                                SnipMate itself. Any scope aliases created by
+                                the user or someone else will still be in
+                                effect.
+
+g:snipMate.snippet_version
+                                The snippet parser version to use. The
+                                possible values are:
+                                    0   Use the older parser
+                                    1   Use the newer parser
+                                If unset, SnipMate defaults to version 0. The
+                                value of this option is also used for all
+                                .snippet files.
+
+g:snipMate.override
+                                As detailed below, when two snippets with the
+                                same name and description are loaded, both are
+                                kept and differentiated by the location of the
+                                file they were in. When this option is enabled
+                                (set to 1), the snippet originating in the
+                                last loaded file is kept, similar to how Vim
+                                maps and other settings work. Note: Load order
+                                is determined by 'runtimepath'.
+
+g:snipMate.description_in_completion
+                                If set to 1 (default is 0), snippet
+                                descriptions will be included in the popup
+                                menu used for snippet completion, like with
+                                <Plug>snipMateShow.
+
+g:snipMate['no_match_completion_feedkeys_chars']
+                                A string inserted when no match for a trigger
+                                is found. By default a tab is inserted
+                                according to 'expandtab', 'tabstop', and
+                                'softtabstop'. Set it to the empty string to
+                                prevent anything from being inserted.
+
+                                                           *SnipMate-mappings*
+Mappings~
+
+The mappings SnipMate uses can be customized with the |:map| commands. For
+example, to change the key that triggers snippets and moves to the next
+tab stop, >
+
+        :imap <C-J> <Plug>snipMateNextOrTrigger
+        :smap <C-J> <Plug>snipMateNextOrTrigger
+
+Note: The noremap variants of the map commands must NOT be used.
+
+The list of possible <Plug> mappings is as follows:
+
+<Plug>snipMateNextOrTrigger     Default: <Tab>          Mode: Insert, Select
+                                Jumps to the next tab stop or, if none exists,
+                                try to expand a snippet. Use in both insert
+                                and select modes.
+
+<Plug>snipMateTrigger           Default: unmapped       Mode: Insert
+                                Try to expand a snippet regardless of any
+                                existing snippet expansion. If done within an
+                                expanded snippet, the outer snippet's tab
+                                stops are lost, unless expansion failed.
+
+<Plug>snipMateBack              Default: <S-Tab>        Mode: Insert, Select
+                                Jump to the previous tab stop, if it exists.
+                                Use in both insert and select modes.
+
+<Plug>snipMateShow              Default: <C-R><Tab>     Mode: Insert
+                                Show all available snippets (that start with
+                                the previous text, if it exists). Use in
+                                insert mode.
+
+<Plug>snipMateVisual            Default: <Tab>          Mode: Visual
+                                See |SnipMate-visual|.
+
+Additionally, <CR> is mapped in visual mode in .snippets files for retabbing
+snippets.
+
+==============================================================================
+SNIPPETS                                                   *SnipMate-snippets*
+
+                                                      *SnipMate-snippet-files*
+Snippet Files ~
+
+Note: SnipMate does not ship with any snippets.
+
+SnipMate looks inside of each entry of 'rtp' (or |SnipMate-snippet-sources|)
+for a directory named /snippets/. Based on the 'filetype' and 'syntax'
+settings (dotted filetypes are parsed), the following files are read for
+snippets: >
+
+    .../snippets/<scope>.snippets
+    .../snippets/<scope>_<name>.snippets
+    .../snippets/<scope>/<name>.snippets
+    .../snippets/<scope>/<trigger>.snippet
+    .../snippets/<scope>/<trigger>/<description>.snippet
+
+where <scope> is a scope or 'filetype' or 'syntax', <name> is an arbitrary
+name, <trigger> is the trigger for a snippet, and <description> is
+a description used for |SnipMate-multisnip|.
+
+A .snippet file defines a single snippet with the trigger (and description)
+determined by the filename. The entire contents of the file are used as the
+snippet expansion text.
+
+Multiple snippets can be defined in *.snippets files. Each snippet definition
+looks something like: >
+
+    snippet trigger optional description
+        expanded text
+        more expanded text
+
+<                                                         *SnipMate-multisnip*
+The description is optional. If it is left out, the description "default" is
+used. When two snippets in the same scope have the same name and the same
+description, SnipMate will try to preserve both. The g:snipMate.override
+option disables this, in favor of keeping the last-loaded snippet. This can be
+overridden on a per-snippet basis by defining the snippet with a bang (!): >
+
+    snippet! trigger optional description
+        expanded text
+        more expanded text
+
+Two bangs will remove the trigger entirely from SnipMate's lookup. In this
+case any snippet text is unused.
+
+Note: Hard tabs in the expansion text are required. When the snippet is
+expanded in the text and 'expandtab' is set, each tab will be replaced with
+spaces based on 'softtabstop' if nonzero or 'shiftwidth' otherwise.
+
+Which version parser the snippets in a file should be used with can be
+specified with a version line, e.g.: >
+
+    version 1
+
+Specification of a version applies to the snippets following it. Multiple
+version specifications can appear in a single file to intermix version 0 and
+version 1 snippets.
+
+Comments can be made in .snippets files by starting a line with a # character.
+However these can't be used inside of snippet definitions: >
+
+    # this is a correct comment
+    snippet trigger
+        expanded text
+    snippet another_trigger
+        # this isn't a comment!
+        expanded text
+
+This should hopefully be clear with the included syntax highlighting.
+
+                                                            *snipMate-extends*
+Borrowing from UltiSnips, .snippets files can also contain an extends
+directive, for example: >
+
+ extends html, javascript, css
+
+will tell SnipMate to also read html, javascript, and css snippets.
+
+SNIPPET SYNTAX                             *snippet-syntax* *SnipMate-syntax*
+
+Anywhere in a snippet, a backslash escapes the character following it,
+regardless of whether that character is special or not. That is, '\a' will
+always result in an 'a' in the output. A single backslash can be output by
+using '\\'.
+
+                                                          *SnipMate-tabstops*
+Tab stops~
+
+When triggering a snippet, SnipMate will by default jump to the very end of
+the snippet text. This can be changed through the use of tab stops: $1, $2,
+and so on. After expansion, SnipMate will jump to the first tab stop. From
+then on, the <Plug>snipMateNextOrTrigger map will jump to the next higher
+numbered tabs top.
+
+In the case of an ambiguity, for example if a stop occurs just before
+a literal number, braces may be placed around the stop number to resolve it:
+${3}79 is the third tab stop followed by the string "79".
+
+NOTE: In the version 0 snippet parser, the braces are mandatory.
+
+                                                       *SnipMate-zero-tabstop*
+SnipMate will always stop at the special zero tab stop $0. Once it jumps to
+the zero tab stop, snippet expansion is finished. If the zero tab stop is not
+present in a definition, it will be put at the end.
+
+For example, to place the cursor first on the id of a <div> tag, then on its
+class, and finally end editing its contents: >
+
+    snippet div
+        <div id="$1" class="$2">
+            $0
+        </div>
+
+<                                                      *SnipMate-placeholders*
+In addition to being simply a location, each tab stop contains a placeholder,
+or some default text. The placeholder can be specified for every tab stop
+(including the zero tab stop) with a colon after the stop ID, as in
+${1:default text}. The braces are required only when specifying a placeholder.
+Once a tab stop with a placeholder is reached, the placeholder will be
+selected in |Select-mode|. For example, >
+
+    snippet div
+        <div id="${1:id}" class="${2:class}">
+            $0
+        </div>
+
+Finally, placeholders can contain mirrors and evaluations (detailed below) and
+even entire other tab stops. If the placeholder is edited, then these nested
+tab stops are removed and skipped entirely. For example, >
+
+    snippet div
+        <div${1: id="${2:id}"}${3: class="${4:class}"}>
+            $0
+        </div>
+
+When expanded, this snippet selects the entirety of the id attribute. If this
+stop is edited, then the second tab stop is removed and the third tab stop
+becomes the next one. If the first tab stop is left unedited, then SnipMate
+jumps to the second tab stop. This allows the user to use a single div snippet
+that can be used for instances where the id or class attributes are desired
+and those where they are not.
+
+                                                            *SnipMate-mirrors*
+Mirrors~
+
+A mirror is simply a copy of a tab stop's text, updated as the tab stop is
+edited. These look like a tab stop without a placeholder; $1 for example. In
+the event that no placeholder is specified for a certain tab stop--say $1--the
+first instance becomes the tab stop and the rest become mirrors.
+
+Additionally substitutions similar to |:substitute| can be performed. For
+instance ${1/foo/bar/g} will replace all instances of "foo" in the $1 mirror
+with "bar". This uses |substitute()| behind the scenes.
+
+Note: Just like with tab stops, braces can be used to avoid ambiguities: ${1}2
+is a mirror of the first tab stop followed by a 2. Version 0 of the snippet
+parser offers no way to resolve such ambiguities.
+
+As an example, >
+
+    snippet for
+        for ($1 = ${2:start}; ${1:i} < ${3:end}; $1${4:++}) {
+            ${0:/* code */}
+        }
+
+<                                                              *SnipMate-eval*
+Expression Evaluation~
+
+Snippets can contain Vim script expressions that are evaluated as the snippet
+is expanded. Expressions are specified inside backticks: >
+
+ snippet date
+        `strftime("%Y-%m-%d")`
+
+If the expression results in any Vim error, the error will be displayed (or
+found in :messages) and the result of the expression will be the empty string.
+
+Filename([{expr}] [, {defaultText}])                     *SnipMate-Filename()*
+
+Since the current filename is used often in snippets, a default function
+has been defined for it in SnipMate.vim, appropriately called Filename().
+
+With no arguments, the default filename without an extension is returned;
+the first argument specifies what to place before or after the filename,
+and the second argument supplies the default text to be used if the file
+has not been named. "$1" in the first argument is replaced with the filename;
+if you only want the filename to be returned, the first argument can be left
+blank. Examples: >
+
+ snippet filename
+        `Filename()`
+ snippet filename_with_default
+        `Filename('', 'name')`
+ snippet filename_foo
+        `Filename('$1_foo')`
+
+The first example returns the filename if it the file has been named, and an
+empty string if it hasn't. The second returns the filename if it's been named,
+and "name" if it hasn't. The third returns the filename followed by "_foo" if
+it has been named, and an empty string if it hasn't.
+
+                                                             *SnipMate-visual*
+The VISUAL Stop~
+
+While tab stops have numeric IDs, a special one exists with the ID 'VISUAL'.
+When a snippet is expanded, if any text had been grabbed with the
+snipMateVisual mapping (see |SnipMate-mappings|), all instances of the VISUAL
+stop will be replaced with it. Both transformations as well as a default
+placeholder can be used with the VISUAL stop.
+
+Note: Both $VISUAL and ${VISUAL} are valid in version 1 of the snippet parser.
+In version 0, only {VISUAL} is valid (without the $), and neither
+transformations nor a default placeholder can be used.
+
+Example: >
+
+    snippet div
+        <div>
+            ${0:${VISUAL:<!-- content -->}}
+        </div>
+
+==============================================================================
+SNIPPET SOURCES                                     *SnipMate-snippet-sources*
+
+SnipMate is configurable.
+
+plugin/SnipMate.vim assigns a couple important keys: >
+
+    " default implementation collecting snippets by handlers
+    let g:SnipMate['get_snippets'] = SnipMate#GetSnippets
+    " default handler:
+    let g:SnipMateSources['default'] = SnipMate#DefaultPool
+
+You can override both of those settings.
+
+You can see that the default set of snippets is determined by Vim's 'rtp'.
+
+Example 1:~
+autoload/SnipMate_python_demo.vim shows how you can register additional
+sources such as creating snippets on the fly representing python function
+definitions found in the current file.
+
+Example 2:~
+Add to your ~/.vimrc: For each know snippet add a second version ending in _
+adding folding markers >
+
+    let g:commentChar = {
+                \   'vim': '"',
+                \   'c': '//',
+                \   'cpp': '//',
+                \   'sh': '#',
+                \   'python': '#'
+                \ }
+    " url https://github.com/garbas/vim-snipmate/issues/49
+    fun! AddFolding(text)
+        return substitute(a:text,'\n'," ".g:commentChar[&ft]." {{{\n",1)."\n".g:commentChar[&ft]." }}}"
+    endf
+
+    fun! SnippetsWithFolding(scopes, trigger, result)
+        " hacky: temporarely remove this function to prevent infinite recursion:
+        call remove(g:SnipMateSources, 'with_folding')
+        " get list of snippets:
+        let result = SnipMate#GetSnippets(a:scopes, substitute(a:trigger,'_\(\*\)\?$','\1',''))
+        let g:SnipMateSources['with_folding'] = funcref#Function('SnippetsWithFolding')
+
+        " add folding:
+        for k in keys(result)
+        let a:result[k.'_'] = map(result[k],'AddFolding(v:val)')
+        endfor
+    endf
+
+    " force setting default:
+    runtime plugin/SnipMate.vim
+    " add our own source
+    let g:SnipMateSources['with_folding'] = funcref#Function('SnippetsWithFolding')
+
+See |SnipMate-syntax| for more details about all possible relative locations
+to 'rtp' can be found in.
+
+==============================================================================
+KNOWN ISSUES                                         *SnipMate-known-issues*
+
+SnipMate.vim currently has the following disadvantages to TextMate's snippets:
+    - Placeholders cannot span multiple lines.
+    - Activating snippets in different scopes of the same file is
+      not possible.
+    - Vim formatting with fo=t or fo=a can mess up SnipMate.
+
+Perhaps some of these features will be added in a later release.
+
+==============================================================================
+CHANGELOG                                                 *SnipMate-changelog*
+
+0.89 - 2016-05-29
+-----------------
+
+* Various regex updates to legacy parser Addition of double bang syntax to
+* completely remove a snippet from lookup Group various SnipMate autocommands
+* Support setting 'shiftwidth' to 0 Parser now operates linewise, adding some
+* flexibility Mirror substitutions are more literal Mirror length is
+* calculated correctly when substitutions occur
+
+0.88 - 2015-04-04
+-----------------
+
+* Implement simple caching
+* Remove expansion guards
+* Add `:SnipMateLoadScope` command and buffer-local scope aliases
+* Load `<scope>_*.snippets` files
+* Use CursorMoved autocmd events entirely
+
+* The nested branch has been merged
+    * A new snippet parser has been added. The g:snipmate.version as well as
+      version lines in snippet files determines which is used
+    * The new parser supports tab stops placed within placeholders,
+      substitutions, non-consecutive stop numbers, and fewer ambiguities
+    * The stop jumping code has been updated
+    * Tests have been added for the jumping code and the new parser
+
+* The override branch has been merged
+    * The g:snipMate.override option is added. When enabled, if two snippets
+      share the same name, the later-loaded one is kept and the other discarded
+    * Override behavior can be enabled on a per-snippet basis with a bang (!) in
+      the snippet file
+    * Otherwise, SnipMate tries to preserve all snippets loaded
+
+* Fix bug with mirrors in the first column
+* Fix bug with tabs in indents
+  <http://github.com/garbas/vim-snipmate/issues/143>
+* Fix bug with mirrors in placeholders
+* Fix reading single snippet files
+* Fix the use of the visual map at the end of a line
+* Fix expansion of stops containing only the zero tab stop
+* Remove select mode mappings
+* Indent visual placeholder expansions and remove extraneous lines
+  <http://github.com/garbas/vim-snipmate/issues/177>
+  <http://github.com/garbas/vim-snipmate/issues/178>
+
+0.87 - 2014-01-04
+-----------------
+
+* Stop indenting empty lines when expanding snippets
+* Support extends keyword in .snippets files
+* Fix visual placeholder support
+* Add zero tabstop support
+* Support negative 'softtabstop'
+* Add g:snipMate_no_default_aliases option
+* Add <Plug>snipMateTrigger for triggering an expansion inside a snippet
+* Add snipMate#CanBeTriggered() function
+
+0.86 - 2013-06-15
+-----------------
+* Use more idiomatic <Plug> maps
+* Remove most select mode mappings
+
+* Fix disappearing variables bug (hpesoj)
+* Fix cursor position bug when a variable is on the same line as the stop
+* Fix undo point creation causing problems with Supertab
+* Fix bug where SnipMate would use a typed trigger as a regular expression
+
+0.85 - 2013-04-03
+-----------------
+
+* Allow trigger key customization
+* Enable undoing of snippet expansion
+* Support backslash escaping in snippets
+* Add support for {VISUAL}
+* Expand filetype extension with scope_aliases
+* Add expansion guards
+* Enable per-buffer expansion of snippets
+* Fix 'cpo' compatibility
+* Update supertab compatibility
+* Enable customization of various things through g:SnipMate
+
+* Disable spelling in snippet files
+* Highlight trigger names in .snippets files
+
+* Update many snippets
+* Separate sample snippets into separate repository
+
+0.84
+----
+
+* Unreleased version by Michael Sanders, available on his GitHub,
+  <https://github.com/msanders/snipmate.vim>
+
+0.83 - 2009-07-13
+-----------------
+
+* Last release done by Michael Sanders, available at
+  <http://www.vim.org/scripts/script.php?script_id=2540>
+
+==============================================================================
+CONTACT                                   *SnipMate-contact* *SnipMate-author*
+
+SnipMate is currently maintained by:
+  - Rok Garbas
+  - Marc Weber (marco-oweber@gmx.de)
+  - Adnan Zafar
+
+For bug reports, issues, or questions, check out the Issues page on GitHub:
+https://github.com/garbas/vim-snipmate/issues
+
+The original author, Michael Sanders, can be reached at:
+msanders42+snipmate <at> gmail <dot> com
+
+
+==============================================================================
+LICENSE                                                     *SnipMate-license*
+
+SnipMate is released under the MIT license:
+
+Copyright 2009-2010 Michael Sanders. All rights reserved.
+
+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.
+
+==============================================================================
+ vim:tw=78:ts=8:ft=help:norl:
diff --git a/vim/.vim/bundle/snipmate/ftplugin/html_snip_helper.vim b/vim/.vim/bundle/snipmate/ftplugin/html_snip_helper.vim
new file mode 100644
index 0000000..4d52392
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/ftplugin/html_snip_helper.vim
@@ -0,0 +1,10 @@
+" Helper function for (x)html snippets
+if exists('s:did_snip_helper') || &cp || !exists('loaded_snips')
+	finish
+endif
+let s:did_snip_helper = 1
+
+" Automatically closes tag if in xhtml
+fun! Close() abort
+	return stridx(&ft, 'xhtml') == -1 ? '' : ' /'
+endf
diff --git a/vim/.vim/bundle/snipmate/ftplugin/snippets.vim b/vim/.vim/bundle/snipmate/ftplugin/snippets.vim
new file mode 100644
index 0000000..dde00e4
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/ftplugin/snippets.vim
@@ -0,0 +1,20 @@
+" Vim filetype plugin for SnipMate snippets (.snippets and .snippet files)
+
+if exists("b:did_ftplugin")
+    finish
+endif
+let b:did_ftplugin = 1
+
+let b:undo_ftplugin = "setl et< sts< cms< fdm< fde<"
+
+" Use hard tabs
+setlocal noexpandtab softtabstop=0
+
+setlocal foldmethod=expr foldexpr=getline(v:lnum)!~'^\\t\\\\|^$'?'>1':1
+
+setlocal commentstring=#\ %s
+setlocal nospell
+
+command! -buffer -range=% RetabSnip
+            \ echom "This command is deprecated. Use :retab and = instead. Doing that now."
+            \ | <line1>,<line2>retab! | <line1>,<line2>normal =
diff --git a/vim/.vim/bundle/snipmate/indent/snippets.vim b/vim/.vim/bundle/snipmate/indent/snippets.vim
new file mode 100644
index 0000000..0d28f32
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/indent/snippets.vim
@@ -0,0 +1,32 @@
+" Simple indent support for SnipMate snippets files
+
+if exists('b:did_indent')
+    finish
+endif
+let b:did_indent = 1
+
+setlocal nosmartindent
+setlocal indentkeys=!^F,o,O,=snippet,=version,=extends
+setlocal indentexpr=GetSnippetIndent()
+
+if exists("*GetSnippetIndent")
+    finish
+endif
+
+function! GetSnippetIndent()
+    let line = getline(v:lnum)
+    let prev_lnum = v:lnum - 1
+    let prev_line = prev_lnum != 0 ? getline(prev_lnum) : ""
+
+    if line =~# '\v^(snippet|extends|version) '
+        return 0
+    elseif indent(v:lnum) > 0
+        return indent(v:lnum)
+    elseif prev_line =~# '^snippet '
+        return &sw
+    elseif indent(prev_lnum) > 0
+        return indent(prev_lnum)
+    endif
+
+    return 0
+endfunction
diff --git a/vim/.vim/bundle/snipmate/plugin/snipMate.vim b/vim/.vim/bundle/snipmate/plugin/snipMate.vim
new file mode 100644
index 0000000..837f0dc
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/plugin/snipMate.vim
@@ -0,0 +1,137 @@
+" File:          snipMate.vim
+" Description:   snipMate.vim implements some of TextMate's snippets features in
+"                Vim. A snippet is a piece of often-typed text that you can
+"                insert into your document using a trigger word followed by a "<tab>".
+"
+"                For more help see snipMate.txt; you can do this by using:
+"                :helptags ~/.vim/doc
+"                :h SnipMate
+
+if exists('loaded_snips') || &cp || version < 700
+	finish
+endif
+let loaded_snips = 1
+
+" Save and reset 'cpo'
+let s:save_cpo = &cpo
+set cpo&vim
+
+try
+	call funcref#Function('')
+catch /.*/
+	echoe "you're missing vim-addon-mw-utils. See install instructions at ".expand('<sfile>:h:h').'/README.md'
+endtry
+
+if (!exists('g:snipMateSources'))
+  let g:snipMateSources = {}
+  " Default source: get snippets based on runtimepath
+  let g:snipMateSources['default'] = funcref#Function('snipMate#DefaultPool')
+endif
+
+augroup SnipMateDetect
+	au BufRead,BufNewFile *.snippet,*.snippets setlocal filetype=snippets
+	au FileType snippets if expand('<afile>:e') =~# 'snippet$'
+				\ | setlocal syntax=snippet
+				\ | else
+					\ | setlocal syntax=snippets
+					\ | endif
+augroup END
+
+inoremap <silent> <Plug>snipMateNextOrTrigger  <C-R>=snipMate#TriggerSnippet()<CR>
+snoremap <silent> <Plug>snipMateNextOrTrigger  <Esc>a<C-R>=snipMate#TriggerSnippet()<CR>
+inoremap <silent> <Plug>snipMateTrigger        <C-R>=snipMate#TriggerSnippet(1)<CR>
+inoremap <silent> <Plug>snipMateBack           <C-R>=snipMate#BackwardsSnippet()<CR>
+snoremap <silent> <Plug>snipMateBack           <Esc>a<C-R>=snipMate#BackwardsSnippet()<CR>
+inoremap <silent> <Plug>snipMateShow           <C-R>=snipMate#ShowAvailableSnips()<CR>
+xnoremap <silent> <Plug>snipMateVisual         :<C-U>call <SID>grab_visual()<CR>gv"_c
+
+" config variables
+if !exists('g:snips_author')
+	let g:snips_author = 'Me'
+endif
+if !exists('g:snipMate')
+	let g:snipMate = {}
+endif
+
+" SnipMate inserts this string when no snippet expansion can be done
+let g:snipMate['no_match_completion_feedkeys_chars'] =
+			\ get(g:snipMate, 'no_match_completion_feedkeys_chars', "\t")
+
+" Add default scope aliases, without overriding user settings
+let g:snipMate.scope_aliases = get(g:snipMate, 'scope_aliases', {})
+if exists('g:snipMate_no_default_aliases')
+	echom 'The g:snipMate_no_default_aliases option has been renamed.'
+				\ 'See :h snipMate-options.'
+endif
+if (!exists('g:snipMate_no_default_aliases') || !g:snipMate_no_default_aliases)
+			\ && (!exists('g:snipMate.no_default_aliases')
+				\ || !g:snipMate.no_default_aliases)
+	let g:snipMate.scope_aliases.objc =
+				\ get(g:snipMate.scope_aliases, 'objc', 'c')
+	let g:snipMate.scope_aliases.cpp =
+				\ get(g:snipMate.scope_aliases, 'cpp', 'c')
+	let g:snipMate.scope_aliases.cu =
+				\ get(g:snipMate.scope_aliases, 'cu', 'c')
+	let g:snipMate.scope_aliases.xhtml =
+				\ get(g:snipMate.scope_aliases, 'xhtml', 'html')
+	let g:snipMate.scope_aliases.html =
+				\ get(g:snipMate.scope_aliases, 'html', 'javascript')
+	let g:snipMate.scope_aliases.php =
+				\ get(g:snipMate.scope_aliases, 'php', 'php,html,javascript')
+	let g:snipMate.scope_aliases.ur =
+				\ get(g:snipMate.scope_aliases, 'ur', 'html,javascript')
+	let g:snipMate.scope_aliases.mxml =
+				\ get(g:snipMate.scope_aliases, 'mxml', 'actionscript')
+	let g:snipMate.scope_aliases.eruby =
+				\ get(g:snipMate.scope_aliases, 'eruby', 'eruby-rails,html')
+	let g:snipMate.scope_aliases.scss =
+				\ get(g:snipMate.scope_aliases, 'scss', 'css')
+	let g:snipMate.scope_aliases.less =
+				\ get(g:snipMate.scope_aliases, 'less', 'css')
+endif
+
+let g:snipMate['get_snippets'] = get(g:snipMate, 'get_snippets', funcref#Function("snipMate#GetSnippets"))
+
+" List of paths where snippets/ dirs are located
+let g:snipMate['snippet_dirs'] = get(g:snipMate, 'snippet_dirs', split(&rtp, ','))
+if type(g:snipMate['snippet_dirs']) != type([])
+	echohl WarningMsg
+	echom "g:snipMate['snippet_dirs'] must be a List"
+	echohl None
+endif
+
+" _ is default scope added always
+"
+" &ft honors multiple filetypes and syntax such as in set ft=html.javascript syntax=FOO
+let g:snipMate['get_scopes'] = get(g:snipMate, 'get_scopes', funcref#Function('return split(&ft,"\\.")+[&syntax, "_"]'))
+
+" Modified from Luc Hermitte's function on StackOverflow
+" <http://stackoverflow.com/a/1534347>
+function! s:grab_visual() abort
+	let a_save = @a
+	try
+		normal! gv"ay
+		let b:snipmate_visual = @a
+	finally
+		let @a = a_save
+	endtry
+endfunction
+
+" TODO: Allow specifying an arbitrary snippets file
+function! s:load_scopes(bang, ...) abort
+	let gb = a:bang ? g: : b:
+	let gb.snipMate = get(gb, 'snipMate', {})
+	let gb.snipMate.scope_aliases = get(gb.snipMate, 'scope_aliases', {})
+	let gb.snipMate.scope_aliases['_'] = join(split(get(gb.snipMate.scope_aliases, '_', ''), ',') + a:000, ',')
+endfunction
+
+command! -bang -bar -nargs=+ SnipMateLoadScope
+			\ call s:load_scopes(<bang>0, <f-args>)
+
+" Edit snippet files
+command! SnipMateOpenSnippetFiles call snipMate#OpenSnippetFiles()
+
+" restore 'cpo'
+let &cpo = s:save_cpo
+
+" vim:noet:sw=4:ts=4:ft=vim
diff --git a/vim/.vim/bundle/snipmate/syntax/snippet.vim b/vim/.vim/bundle/snipmate/syntax/snippet.vim
new file mode 100644
index 0000000..a947356
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/syntax/snippet.vim
@@ -0,0 +1,11 @@
+" Syntax highlighting for .snippet files (used for snipMate.vim)
+" Hopefully this should make snippets a bit nicer to write!
+syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand
+syn match tabStop '\$\d\+'
+syn match snipEscape '\\\\\|\\`'
+syn match snipCommand '\%(\\\@<!\%(\\\\\)*\)\@<=`.\{-}\%(\\\@<!\%(\\\\\)*\)\@<=`'
+
+hi link placeHolder   Special
+hi link tabStop       Special
+hi link snipEscape    SpecialChar
+hi link snipCommand   String
diff --git a/vim/.vim/bundle/snipmate/syntax/snippets.vim b/vim/.vim/bundle/snipmate/syntax/snippets.vim
new file mode 100644
index 0000000..63bda4e
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/syntax/snippets.vim
@@ -0,0 +1,23 @@
+" Syntax highlighting for .snippets files (used for snipMate.vim)
+" Hopefully this should make snippets a bit nicer to write!
+syn match snipComment '^#.*'
+syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand
+syn match tabStop '\$\d\+'
+syn match snipEscape '\\\\\|\\`'
+syn match snipCommand '\%(\\\@<!\%(\\\\\)*\)\@<=`.\{-}\%(\\\@<!\%(\\\\\)*\)\@<=`'
+syn match snippet '^snippet.*' contains=multiSnipText,snipKeyword
+syn match snippet '^extends.*' contains=snipKeyword
+syn match snippet '^version.*' contains=snipKeyword
+syn match multiSnipText '\S\+ \zs.*' contained
+syn match snipKeyword '^(snippet|extends|version)'me=s+8 contained
+syn match snipError "^[^#vse\t].*$"
+
+hi link snippet       Identifier
+hi link snipComment   Comment
+hi link multiSnipText String
+hi link snipKeyword   Keyword
+hi link snipEscape    SpecialChar
+hi link placeHolder   Special
+hi link tabStop       Special
+hi link snipCommand   String
+hi link snipError     Error
diff --git a/vim/.vim/bundle/snipmate/t/jumping.vim b/vim/.vim/bundle/snipmate/t/jumping.vim
new file mode 100644
index 0000000..1c3ab0d
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/t/jumping.vim
@@ -0,0 +1,175 @@
+function! Setup(snip) abort
+    return snipMate#expandSnip(join(a:snip, "\n"), 1)
+endfunction
+
+function! s:to_be_file(expected) abort
+    return a:expected == getline(1,'$')
+endfunction
+
+function! s:to_be_in(item, list) abort
+    return !empty(filter(copy(a:list), 'v:val is a:item'))
+endfunction
+
+call vspec#customize_matcher('to_be_file', function('s:to_be_file'))
+call vspec#customize_matcher('to_be_in', function('s:to_be_in'))
+
+describe 'snippet state'
+
+    before
+        enew
+        let b:snip_state = snipmate#jumping#state()
+    end
+
+    after
+        bwipeout!
+    end
+
+    describe '.remove()'
+
+        it 'removes the state object'
+            Expect exists('b:snip_state') to_be_true
+            call b:snip_state.remove()
+            Expect exists('b:snip_state') to_be_false
+        end
+
+        it 'removes snippet related autocommands'
+            function! ReadAutocmds()
+                redir => autocmds
+                0verbose au snipmate_changes * <buffer>
+                redir END
+                return split(autocmds, "\n")
+            endfunction
+            aug snipmate_changes
+                au CursorMoved,CursorMovedI <buffer> echo 'event'
+            aug END
+
+            Expect len(ReadAutocmds()) > 1
+            call b:snip_state.remove()
+            Expect len(ReadAutocmds()) == 1
+        end
+
+    end
+
+    describe '.find_next_stop()'
+
+        it 'increments/decrements the stop_no'
+            let b:snip_state.stops = { 1 : {}, 2 : {} }
+            let b:snip_state.stop_no = 1
+            let b:snip_state.stop_count = 4
+
+            call b:snip_state.find_next_stop(0)
+            Expect b:snip_state.stop_no == 2
+            call b:snip_state.find_next_stop(1)
+            Expect b:snip_state.stop_no == 1
+        end
+
+        it 'continues iterating if the next/previous stop does not exist'
+            let b:snip_state.stops = { 3 : {} }
+            let b:snip_state.stop_count = 6
+            let b:snip_state.stop_no = 1
+            call b:snip_state.find_next_stop(0)
+            Expect b:snip_state.stop_no == 3
+            let b:snip_state.stop_no = 5
+            call b:snip_state.find_next_stop(1)
+            Expect b:snip_state.stop_no == 3
+        end
+
+        it 'does something at the ends'
+            "
+        end
+
+    end
+
+    describe '.remove_nested()'
+
+        it 'removes nested mirrors and only nested mirrors'
+            let mirror = { 'line' : 0 }
+            let b:snip_state.stops = { 1 : { 'placeholder' : [[2, mirror]] },
+                                    \  2 : { 'mirrors' : [mirror, {}] } }
+
+            call b:snip_state.remove_nested(1)
+            Expect len(b:snip_state.stops[2].mirrors) == 1
+            Expect b:snip_state.stops[2].mirrors[0] isnot mirror
+        end
+
+        it 'removes nested stops'
+            let stop = [2, 'abc']
+            let b:snip_state.stops = { 1 : { 'placeholder' : [stop] },
+                                    \  2 : { 'placeholder' : stop[1:1] } }
+
+            call b:snip_state.remove_nested(1)
+            Expect len(b:snip_state.stops) == 1
+            Expect keys(b:snip_state.stops) == ['1']
+        end
+
+    end
+
+    describe '.find_update_objects()'
+
+        it 'finds mirrors/stops on the same line and after cur_stop'
+            let b:snip_state.stops = {
+                        \ 1 : { 'line' : 1, 'col' : 5,
+                            \ 'placeholder' : ['x'] },
+                        \ 2 : { 'line' : 1, 'col' : 7,
+                            \ 'mirrors' : [{ 'line' : 1, 'col' : 7  }] }
+                        \ }
+            let stop = b:snip_state.stops[1]
+
+            call b:snip_state.find_update_objects(stop)
+            for obj in stop.update_objects
+                Expect obj to_be_in [ b:snip_state.stops[2],
+                            \ b:snip_state.stops[2].mirrors[0] ]
+            endfor
+        end
+
+        it 'finds mirrors/stops on the same line and after cur_stop mirrors'
+            let b:snip_state.stops = {
+                        \ 1 : { 'line' : 1, 'col' : 5,
+                            \ 'mirrors' : [{ 'line' : 2, 'col' : 5 }],
+                            \ 'placeholder' : ['x'] },
+                        \ 2 : { 'line' : 2, 'col' : 7,
+                            \ 'mirrors' : [{ 'line' : 2, 'col' : 7  }] }
+                        \ }
+            let stop = b:snip_state.stops[1]
+
+            call b:snip_state.find_update_objects(stop)
+            for obj in stop.update_objects
+                Expect obj to_be_in [ b:snip_state.stops[2],
+                            \ b:snip_state.stops[2].mirrors[0] ]
+            endfor
+        end
+
+        it 'ignores mirrors/stops on other lines'
+            let b:snip_state.stops = {
+                        \ 1 : { 'line' : 2, 'col' : 5,
+                            \ 'placeholder' : ['x'] },
+                        \ 2 : { 'line' : 1, 'col' : 7,
+                            \ 'mirrors' : [{ 'line' : 1, 'col' : 7  }] },
+                        \ 3 : { 'line' : 3, 'col' : 7,
+                            \ 'mirrors' : [{ 'line' : 3, 'col' : 7  }] }
+                        \ }
+            let stop = b:snip_state.stops[1]
+
+            call b:snip_state.find_update_objects(stop)
+            Expect empty(stop.update_objects) to_be_true
+        end
+
+        it 'ignores mirrors/stops on the same line but before cur_stop/mirrors'
+            let b:snip_state.stops = {
+                        \ 1 : { 'line' : 1, 'col' : 5,
+                            \ 'mirrors' : [{ 'line' : 2, 'col' : 5 }],
+                            \ 'placeholder' : ['x'] },
+                        \ 2 : { 'line' : 1, 'col' : 1,
+                            \ 'mirrors' : [{ 'line' : 2, 'col' : 1  }] },
+                        \ 3 : { 'line' : 2, 'col' : 3,
+                            \ 'mirrors' : [{ 'line' : 1, 'col' : 3  }] },
+                        \ }
+            let stop = b:snip_state.stops[1]
+
+            call b:snip_state.find_update_objects(stop)
+            Expect empty(stop.update_objects) to_be_true
+        end
+
+    end
+
+end
diff --git a/vim/.vim/bundle/snipmate/t/parser.vim b/vim/.vim/bundle/snipmate/t/parser.vim
new file mode 100644
index 0000000..c5cf873
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/t/parser.vim
@@ -0,0 +1,142 @@
+describe 'snippet parser'
+
+    before
+        function! Parse(snippet, ...)
+            let [snip, stops] = snipmate#parse#snippet(a:snippet, (a:0 ? a:1 : 1))
+            return (a:0 > 1 && a:2) ? [snip, stops] : snip
+        endfunction
+        let b:snipmate_visual = 'testvisual'
+    end
+
+    it 'parses numeric $id and ${id} vars as [id] lists'
+        let expect = [[[1234567890]]]
+        Expect Parse('$1234567890') == expect
+        Expect Parse('${1234567890}') == expect
+    end
+
+    it 'disregards $ or ${ followed by a non-id'
+        Expect Parse('$x1') == [['x1']]
+        Expect Parse('${x}1') == [['x}1']]
+        Expect Parse('$VISUA1') == [['VISUA1']]
+        Expect Parse('${VISUA}1') == [['VISUA}1']]
+    end
+
+    it 'gathers references to each instance of each stop id'
+        let [snip, b:stops] = Parse('x$1x${2:x$1x}x$1x${1/a/b}x$VISUALx', 1, 1)
+        function! InstanceFound(list)
+            return !empty(filter(copy(b:stops[a:list[0]].instances),
+                        \ 'v:val is a:list'))
+        endfunction
+        function! CheckList(list)
+            for item in a:list
+                if type(item) == type([])
+                    Expect InstanceFound(item) to_be_true
+                    call CheckList(item)
+                endif
+                unlet item " E732
+            endfor
+        endfunction
+        call CheckList(snip[0])
+    end
+
+    it 'parses mirror substitutions ${n/pat/sub} as [n, {...}]'
+        let expect = [[[1, { 'pat' : 'abc', 'sub' : 'def' }]]]
+        Expect Parse('${1/abc/def}') == expect
+        let expect[0][0][1].flags = ''
+        Expect Parse('${1/abc/def/}') == expect
+        let expect[0][0][1].flags = 'g'
+        Expect Parse('${1/abc/def/g}') == expect
+    end
+
+    it 'reads patterns literally except for "\/"'
+        Expect Parse('${1/\a\/b/\c\/d\}}') == [[[1, { 'pat' : '\a/b', 'sub' : '\c/d}' }]]]
+    end
+
+    it 'parses vars with placeholders as [id, placeholder] lists'
+        Expect Parse('${1:abc}') == [[[1, 'abc']]]
+    end
+
+    it 'evaluates backtick expressions'
+        Expect Parse('`fnamemodify("x.y", ":r")`') == [['x']]
+    end
+
+    it 'parses placeholders for vars and other specials'
+        let text = 'a `fnamemodify("x.y", ":r")` ${2:(${3/a/b})}'
+        let expect = ['a x ', [2, '(', [3, { 'pat' : 'a', 'sub' : 'b' }], ')']]
+        Expect Parse(text) == [expect]
+        Expect Parse(printf('${1:%s}', text)) == [[[1] + expect]]
+    end
+
+    it 'converts tabs according to &et, &sts, &sw, &ts'
+        " &noet -> leave tabs alone
+        setl noet
+        Expect Parse("abc\tdef\n\t\tghi") == [["abc\tdef"], ["\t\tghi"]]
+
+        " &et -> &sts or &sw
+        setl et sts=2 sw=3
+        Expect Parse("abc\tdef\n\t\tghi") == [["abc  def"], ["    ghi"]]
+
+        setl et sts=0 sw=3
+        Expect Parse("abc\tdef\n\t\tghi") == [["abc   def"], ["      ghi"]]
+
+        setl et sts=-1 sw=3
+        Expect Parse("abc\tdef\n\t\tghi") == [["abc   def"], ["      ghi"]]
+
+        " See #227
+        if exists('*shiftwidth')
+            setl et sts=0 sw=0 ts=3
+            Expect Parse("abc\tdef\n\t\tghi") == [["abc   def"], ["      ghi"]]
+        endif
+    end
+
+    it 'parses backslashes as escaping the next character or joining lines'
+        Expect Parse('x\x') == [['xx']]
+        Expect Parse('x\\x') == [['x\x']]
+        Expect Parse("x\\\nx") == [['xx']]
+        Expect Parse('x\$1') == [['x$1']]
+        Expect Parse('${1:\}}') == [[[1, '}']]]
+        Expect Parse('`fnamemodify("\`.x", ":r")`') == [['`']]
+        Expect Parse('\`x\`') == [['`x`']]
+    end
+
+    it 'splits text at newlines'
+        Expect Parse("x\nx") == [['x'], ['x']]
+    end
+
+    it 'joins evaluated expressions to surrounding text on the same line'
+        let g:foo = 'bar'
+        Expect Parse("x`g:foo`x") == [['xbarx']]
+        Expect Parse("x`g:foo`\nx") == [['xbar'], ['x']]
+        Expect Parse("x\n`g:foo`x") == [['x'], ['barx']]
+    end
+
+    it 'expands $VISUAL placeholders with any indents'
+        Expect Parse("x$VISUALx") == [['xtestvisualx']]
+        let b:snipmate_visual = "  foo\nbar\n  baz"
+        setl noet
+        Expect Parse("\tx\n\t$VISUAL\nx") == [["\tx"], ["\t  foo"], ["\tbar"],
+                    \ ["\t  baz"], ["x"]]
+    end
+
+    it 'determines which var with an id is the stop'
+        let [snip, stops] = Parse("$1$1$1", 0, 1)
+        Expect snip == [[[1, "", stops[1]], [1, {}], [1, {}]]]
+
+        let [snip, stops] = Parse("$1${1}$1", 0, 1)
+        Expect snip == [[[1, "", stops[1]], [1, {}], [1, {}]]]
+
+        let [snip, stops] = Parse("$1${1:}$1", 0, 1)
+        Expect snip == [[[1, {}], [1, "", stops[1]], [1, {}]]]
+
+    end
+
+    it 'picks the first of many possible stops'
+        let [snip, stops] = Parse("$1${1:foo}${1:bar}", 0, 1)
+        Expect snip == [[[1, {}], [1, "foo", stops[1]], [1, {}]]]
+    end
+
+    it 'represents empty lines as an empty string'
+        Expect Parse("foo\n\nbar") == [['foo'], [''], ['bar']]
+    end
+
+end
diff --git a/vim/.vim/bundle/snipmate/t/tests.sh b/vim/.vim/bundle/snipmate/t/tests.sh
new file mode 100755
index 0000000..c1da250
--- /dev/null
+++ b/vim/.vim/bundle/snipmate/t/tests.sh
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+tmp="$(mktemp || tmpfile)"
+vim -Es $tmp <<- EOF
+    source ~/.vimrc
+    %delete _
+    call append(0, split(&rtp, ','))
+    delete _
+    wq
+EOF
+
+rtp="$(grep -iE 'vspec|snipmate|tlib|mw-utils' < $tmp | grep -v after)"
+vspec="$(grep -iE 'vspec' < $tmp | grep -v after)"
+test_files="${*:-parser jumping}"
+
+for test in $test_files; do
+    $vspec/bin/vspec $rtp ${test%%.vim}.vim
+done
+
+rm $tmp
diff --git a/vim/.vim/bundle/supertab/Makefile b/vim/.vim/bundle/supertab/Makefile
new file mode 100644
index 0000000..7a3c371
--- /dev/null
+++ b/vim/.vim/bundle/supertab/Makefile
@@ -0,0 +1,17 @@
+SHELL=/bin/bash
+
+all: dist
+
+dist:
+	@rm supertab.vmb 2> /dev/null || true
+	@vim -c 'r! git ls-files doc plugin' \
+		-c '$$,$$d _' -c '%MkVimball supertab .' -c 'q!'
+
+clean:
+	@rm -R build 2> /dev/null || true
+
+install: supertab.vmb
+	vim $< -c 'so %' -c 'q'
+
+uninstall:
+	vim -c 'RmVimball supertab.vmb' -c 'q'
diff --git a/vim/.vim/bundle/supertab/README.rst b/vim/.vim/bundle/supertab/README.rst
new file mode 100644
index 0000000..89bafdb
--- /dev/null
+++ b/vim/.vim/bundle/supertab/README.rst
@@ -0,0 +1,172 @@
+.. Copyright (c) 2012 - 2014, Eric Van Dewoestine
+   All rights reserved.
+
+   Redistribution and use of this software in source and binary forms, with
+   or without modification, are permitted provided that the following
+   conditions are met:
+
+   * Redistributions of source code must retain the above
+     copyright notice, this list of conditions and the
+     following disclaimer.
+
+   * Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions and the
+     following disclaimer in the documentation and/or other
+     materials provided with the distribution.
+
+   * Neither the name of Eric Van Dewoestine nor the names of its
+     contributors may be used to endorse or promote products derived from
+     this software without specific prior written permission of
+     Eric Van Dewoestine.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+.. _overview:
+
+==================
+Overview
+==================
+
+Supertab is a vim plugin which allows you to use <Tab> for all your insert
+completion needs (:help ins-completion).
+
+Features
+--------
+
+- Configurable to suit you needs:
+
+  - Default completion type to use.
+  - Prevent <Tab> from completing after/before defined patterns.
+  - Close vim's completion preview window when code completion is finished.
+  - When using other completion types, you can configure how long to 'remember'
+    the current completion type before returning to the default.
+  - Don't like using <Tab>? You can also configure a different pair of keys to
+    scroll forwards and backwards through completion results.
+
+- Optional improved 'longest' completion support (after typing some characters,
+  hitting <Tab> will highlight the next longest match).
+- Built in 'context' completion option which chooses the appropriate completion
+  type based on the text preceding the cursor.
+
+  - You can also plug in your own functions to determine which completion type
+    to use.
+
+- Support for simple completion chaining (falling back to a different
+  completion type, keyword completion for example, if omni or user completion
+  returns no results).
+
+Installation
+------------
+
+You have a few options when it comes to installing supertab:
+
+1. Use your linux package manager:
+
+   Some linux distributions include a supertab package so you don't have to
+   manage the install/upgrade of supertab separately from other software on your
+   system.
+
+2. Use a vim plugin manager:
+
+   There are several plugin managers for vim, which will either allow you to
+   manually clone vim plugin repositories, or will do so for you. Probably the
+   two most popular ones currently are `pathogen
+   <https://github.com/tpope/vim-pathogen>`_ and `vundle
+   <https://github.com/gmarik/Vundle.vim>`_. Please refer to their docs for
+   instructions on how to install plugins.
+
+3. And lastly you can use the vimball (.vmb) file found on
+   `vim.org <http://www.vim.org/scripts/script.php?script_id=1643>`_:
+
+   Vimball files are installed by simply opening them in vim and then sourcing
+   the file:
+
+   ::
+
+     $ vim supertab.vmb
+     :source %
+
+Frequently Asked Questions
+--------------------------
+
+- **Why isn't supertab honoring my configured settings (attempts to complete at the
+  start of a line, always performs keyword completion instead of my configured
+  default, etc.)?**
+
+  Chances are that you have a very old version of `snipmate
+  <https://github.com/msanders/snipmate.vim>`_ installed, or something similar,
+  which will issue a `<c-n>` when no snippet is found. Supertab use to map to
+  `<c-n>`, so this behavior would act as a fallback to supertab, but current
+  versions of supertab no longer do so, resulting in snipmate bypassing supertab
+  entirely.
+
+  You can check if this is the case by running the following in vim to see what
+  is mapped to `<tab>`:
+
+  ::
+
+    :verbose imap <tab>
+
+  To resolve the issue you can either:
+
+  #. Install my `fork <https://github.com/ervandew/snipmate.vim>`_ or
+  #. Upgrade to a more recent snipmate fork, like `garbas/vim-snipmate
+     <https://github.com/garbas/vim-snipmate>`_
+
+  See `#74 <https://github.com/ervandew/supertab/issues/74>`_ for additional
+  details.
+
+- **Why does <tab> navigate the completion menu from bottom to top?**
+
+  First, if after reading the explanation below (or if you don't want to bother
+  reading it), you still want the default to scroll down the list then you can
+  use:
+
+  ::
+
+    let g:SuperTabDefaultCompletionType = "<c-n>"
+
+  or if your default completion type is currently `context` then you can use
+  this instead:
+
+  ::
+
+    let g:SuperTabContextDefaultCompletionType = "<c-n>"
+
+  Now on to the reasoning behind this. When using `<c-p>` or `<c-n>` to start
+  insert completion, both populate the completion popup with the same list of
+  words in the same order, the only difference is that `<c-p>` highlights the
+  nearest matching word located above the current cursor position, which is the
+  result at the bottom of the completion popup. Without supertab installed,
+  continuing to hit `<c-p>` will walk up the list to next nearest word above the
+  cursor.
+
+  I think Bram chose to display the results like this so that
+
+  #. the completion logic is the same for `<c-n>` and `<c-p>`, only the first
+     entry to highlight differs
+  #. so that the behavior of `<c-p>` mode is consistent, always moving up the
+     list and
+  #. when starting `<c-p>` mode you don't have to switch over to
+     using `<c-n>` to get the next nearest entry, just continue to hit `<c-p>`.
+
+  So, with supertab I wanted to preserve the same behavior. If `<c-p>` is your
+  default completion method (supertab defaults to this being the case), then
+  `<tab>` will start it and additional uses of `<tab>` will move up the list
+  instead of down so that you don't have to suddenly switch to using `<s-tab>`
+  to get the next nearest result.
+
+  Why is `<c-p>` the supertab default? The original supertab author found (and I
+  agree with his finding) that while coding, the keyword match you want is
+  typically the closer of the matches above the cursor, which `<c-p>` naturally
+  provides.
diff --git a/vim/.vim/bundle/supertab/doc/supertab.txt b/vim/.vim/bundle/supertab/doc/supertab.txt
new file mode 100644
index 0000000..941a9a0
--- /dev/null
+++ b/vim/.vim/bundle/supertab/doc/supertab.txt
@@ -0,0 +1,473 @@
+*supertab.txt*
+
+Author: Eric Van Dewoestine <ervandew@gmail.com>
+        Original concept and versions up to 0.32 written by
+        Gergely Kontra <kgergely@mcl.hu>
+
+This plugin is licensed under the terms of the BSD License.  Please see
+supertab.vim for the license in its entirety.
+
+==============================================================================
+Supertab                                    *supertab*
+
+1. Introduction                             |supertab-intro|
+2. Supertab Usage                           |supertab-usage|
+3. Supertab Options                         |supertab-options|
+    Default completion type                 |supertab-defaultcompletion|
+    Secondary default completion type       |supertab-contextdefault|
+    Completion contexts                     |supertab-completioncontexts|
+        Context text                        |supertab-contexttext|
+        Context Discover                    |supertab-contextdiscover|
+        Example                             |supertab-contextexample|
+    Completion Duration                     |supertab-duration|
+    Preventing Completion After/Before...   |supertab-preventcomplete|
+    Changing default mapping                |supertab-forwardbackward|
+    Inserting true tabs                     |supertab-mappingtabliteral|
+    Enhanced longest match support          |supertab-longestenhanced|
+    Preselecting the first entry            |supertab-longesthighlight|
+    Mapping <cr> to end completion          |supertab-crmapping|
+    Auto close the preview window           |supertab-closepreviewonpopupclose|
+    Keyword completion ignore/match case    |supertab-completecase|
+    Completion Chaining                     |supertab-completionchaining|
+
+==============================================================================
+1. Introduction                             *supertab-intro*
+
+Supertab is a plugin which allows you to perform all your insert completion
+(|ins-completion|) using the tab key.
+
+Supertab requires Vim version 7.0 or above.
+
+==============================================================================
+2. Supertab usage                           *supertab-usage*
+
+Using Supertab is as easy as hitting <Tab> or <S-Tab> (shift+tab) while in
+insert mode, with at least one non whitespace character before the cursor, to
+start the completion and then <Tab> or <S-Tab> again to cycle forwards or
+backwards through the available completions.
+
+Example ('|' denotes the cursor location):
+
+bar
+baz
+b|<Tab>    Hitting <Tab> here will start the completion, allowing you to
+           then cycle through the suggested words ('bar' and 'baz').
+
+==============================================================================
+3. Supertab Options                         *supertab-options*
+
+Supertab is configured via several global variables that you can set in your
+|vimrc| file according to your needs. Below is a comprehensive list of
+the variables available.
+
+
+Default Completion Type             *supertab-defaultcompletion*
+                                    *g:SuperTabDefaultCompletionType*
+
+g:SuperTabDefaultCompletionType (default value: "<c-p>")
+
+Used to set the default completion type. There is no need to escape this
+value as that will be done for you when the type is set.
+
+  Example: setting the default completion to 'user' completion:
+
+>
+    let g:SuperTabDefaultCompletionType = "<c-x><c-u>"
+<
+
+Note: a special value of 'context' is supported which will result in
+super tab attempting to use the text preceding the cursor to decide which
+type of completion to attempt. Currently supertab can recognize method calls
+or attribute references via '.', '::' or '->', and file path references
+containing '/'. If the language you are using doesn't use any of the member
+reference characters listed above, or you'd like to add additional patterns,
+you can write a custom context function also described in the next section
+(Completion context).
+
+  Example: setting the default completion to supertab's 'context' completion:
+>
+    let g:SuperTabDefaultCompletionType = "context"
+<
+
+    /usr/l<tab>     # will use filename completion
+    myvar.t<tab>    # will use user completion if completefunc set,
+                    # or omni completion if omnifunc set.
+    myvar-><tab>    # same as above
+
+When using context completion, super tab will fall back to a secondary default
+completion type set by |g:SuperTabContextDefaultCompletionType|.
+
+Note: once the buffer has been initialized, changing the value of this setting
+will not change the default complete type used. If you want to change the
+default completion type for the current buffer after it has been set, perhaps
+in an ftplugin, you'll need to call *SuperTabSetDefaultCompletionType* like so,
+supplying the completion type you wish to switch to:
+
+>
+    call SuperTabSetDefaultCompletionType("<c-x><c-u>")
+<
+
+
+Secondary default completion type   *supertab-contextdefault*
+                                    *g:SuperTabContextDefaultCompletionType*
+
+g:SuperTabContextDefaultCompletionType (default value: "<c-p>")
+
+Sets the default completion type used when g:SuperTabDefaultCompletionType is
+set to 'context' and no completion type is returned by any of the configured
+contexts.
+
+  Note: supertab also supports the b:SuperTabContextDefaultCompletionType
+  variable allowing you to set the default type separately for the current
+  buffer, like from an ftplugin for example.
+
+
+Completion contexts                 *supertab-completioncontexts*
+                                    *g:SuperTabCompletionContexts*
+
+g:SuperTabCompletionContexts (default value: ['s:ContextText'])
+
+Sets the list of contexts used for context completion. This value should
+be a list of function names which provide the context implementation.
+
+When supertab starts context completion, each of these contexts will be
+consulted, in the order they were supplied, to determine the completion type
+to use. If a context returns a completion type, that type will be used,
+otherwise the next context in the list will be consulted. If after executing
+all the context functions, no completion type has been determined, then the
+value of |g:SuperTabContextDefaultCompletionType| will be used.
+
+  Note: supertab also supports the b:SuperTabCompletionContexts variable
+  allowing you to set the list of contexts separately for the current buffer,
+  like from an ftplugin for example.
+
+Built in completion contexts:
+
+  s:ContextText                     *supertab-contexttext*
+
+  The text context will examine the text near the cursor to decide which type
+  of completion to attempt. Currently the text context can recognize method
+  calls or attribute references via '.', '::' or '->', and file path
+  references containing '/'.
+
+      /usr/l<tab>  # will use filename completion
+      myvar.t<tab> # will use user completion if completefunc set, or
+                   # omni completion if omnifunc set.
+      myvar-><tab> # same as above
+
+  Supported configuration attributes:
+
+    *g:SuperTabContextTextFileTypeExclusions*
+    List of file types for which the text context will be skipped.
+
+    *g:SuperTabContextTextOmniPrecedence* (default: ['&completefunc', '&omnifunc'])
+    *b:SuperTabContextTextOmniPrecedence*
+    List of omni completion option names in the order of precedence that they
+    should be used if available. By default, user completion will be given
+    precedence over omni completion, but you can use this variable to give
+    omni completion higher precedence by placing it first in the list.
+
+    *g:SuperTabContextTextMemberPatterns* (default: ['\.', '>\?::', '->'])
+    *b:SuperTabContextTextMemberPatterns*
+    List of patterns used to determine when omni/user completion should be
+    used. The default list consists of the most common patterns used to access
+    module/class/object members.
+
+    Note: For html and xml based files, the buffer local version of the above
+    two settings are set to trigger omni completion first when encountering a
+    potential end tag pattern of '</'.
+
+  s:ContextDiscover                 *supertab-contextdiscover*
+
+  This context will use the 'g:SuperTabContextDiscoverDiscovery' variable to
+  determine the completion type to use. It will evaluate each value, in the
+  order they were defined, until a variable evaluates to a non-zero or
+  non-empty value, then the associated completion type is used.
+
+  Supported configuration properties:
+
+    g:SuperTabContextDiscoverDiscovery
+    List of variable:completionType mappings.
+
+  Example context configuration:    *supertab-contextexample*
+
+>
+    let g:SuperTabCompletionContexts = ['s:ContextText', 's:ContextDiscover']
+    let g:SuperTabContextTextOmniPrecedence = ['&omnifunc', '&completefunc']
+    let g:SuperTabContextDiscoverDiscovery =
+        \ ["&completefunc:<c-x><c-u>", "&omnifunc:<c-x><c-o>"]
+<
+
+  In addition to the default completion contexts, you can plug in your own
+  implementation by creating a globally accessible function that returns
+  the completion type to use (eg. "\<c-x>\<c-u>").
+
+>
+    function MyTagContext()
+      if filereadable(expand('%:p:h') . '/tags')
+        return "\<c-x>\<c-]>"
+      endif
+      " no return will result in the evaluation of the next
+      " configured context
+    endfunction
+    let g:SuperTabCompletionContexts =
+        \ ['MyTagContext', 's:ContextText', 's:ContextDiscover']
+<
+
+  Here is another example that could be used to add context support for
+  clojure, and perhaps other lisp variants:
+
+>
+    let b:SuperTabCompletionContexts =
+      \ ['ClojureContext'] + g:SuperTabCompletionContexts
+
+    function! ClojureContext()
+      let curline = getline('.')
+      let cnum = col('.')
+      let synname = synIDattr(synID(line('.'), cnum - 1, 1), 'name')
+      if curline =~ '(\S\+\%' . cnum . 'c' && synname !~ '\(String\|Comment\)'
+        return "\<c-x>\<c-o>"
+      endif
+    endfunction
+<
+
+
+Completion Duration                 *supertab-duration*
+                                    *g:SuperTabRetainCompletionDuration*
+
+g:SuperTabRetainCompletionDuration (default value: 'insert')
+
+Determines if, and for how long, the current completion type is retained.
+The possible values include:
+'completion' - The current completion type is only retained for the
+               current completion. Once you have chosen a completion
+               result or exited the completion mode, the default
+               completion type is restored.
+'insert'     - The current completion type is saved until you exit insert
+               mode (via ESC). Once you exit insert mode the default
+               completion type is restored. (supertab default)
+'session'    - The current completion type is saved for the duration of
+               your vim session or until you enter a different completion
+               mode.
+
+
+Preventing completion after...      *supertab-preventcomplete*
+                                    *g:SuperTabNoCompleteBefore*
+                                    *g:SuperTabNoCompleteAfter*
+
+g:SuperTabNoCompleteBefore (default value: [])
+g:SuperTabNoCompleteAfter (default value: ['^', '\s'])
+
+These two variables are used to control when supertab will attempt completion
+or instead fall back to inserting a literal <tab>. There are two possible ways
+to define these variables:
+
+  1) by specifying a list of patterns which are tested against the text before
+  and after the current cursor position that when matched, prevent completion.
+  So if you don't want supertab to start completion at the start of a line,
+  after a comma, or after a space, you can set g:SuperTabNoCompleteAfter
+  to ['^', ',', '\s'].
+
+  2) by specifying a funcref to a global accessible function which expects
+  as parameter the text to be inspected (before or after) and, based on that (or
+  other factors), it returns 1 if completion must be prevented, 0 otherwise.
+
+Note: That a buffer local version of these variables
+(b:SuperTabNoCompleteBefore, b:SuperTabNoCompleteAfter) are also supported
+should you wish to have different values depending on the file type for
+instance.
+
+Changing the default mapping        *supertab-forwardbackward*
+                                    *g:SuperTabMappingForward*
+                                    *g:SuperTabMappingBackward*
+
+g:SuperTabMappingForward  (default value: '<tab>')
+g:SuperTabMappingBackward (default value: '<s-tab>')
+
+These two variables allow you to set the keys used to kick off the current
+completion. By default this is <tab> and <s-tab>. To change to something
+like <c-space> and <s-c-space>, you can add the following to your |vimrc|.
+
+>
+    let g:SuperTabMappingForward = '<c-space>'
+    let g:SuperTabMappingBackward = '<s-c-space>'
+>
+
+Note: if the above does not have the desired effect (which may happen in
+console version of vim), you can try the following mappings. Although the
+backwards mapping still doesn't seem to work in the console for me, your
+milage may vary.
+
+>
+    let g:SuperTabMappingForward = '<nul>'
+    let g:SuperTabMappingBackward = '<s-nul>'
+<
+
+
+Inserting true tabs                 *supertab-mappingtabliteral*
+                                    *g:SuperTabMappingTabLiteral*
+
+g:SuperTabMappingTabLiteral (default value: '<c-tab>')
+
+Sets the key mapping used to insert a literal tab where supertab would
+otherwise attempt to kick off insert completion. The default is '<c-tab>'
+(ctrl-tab) which unfortunately might not work at the console. So if you are
+using a console vim and want this functionality, you may have to change it to
+something that is supported. Alternatively, you can escape the <tab> with
+<c-v> (see |i_CTRL-V| for more infos).
+
+See also |supertab-preventcomplete|.
+
+
+Enhanced longest match support      *supertab-longestenhanced*
+                                    *g:SuperTabLongestEnhanced*
+
+g:SuperTabLongestEnhanced (default value: 0)
+
+When enabled and 'longest' is in your |completeopt| setting, supertab will
+provide an enhanced longest match support where typing one or more letters and
+hitting tab again while in a completion mode will complete the longest common
+match using the new text in the buffer.
+
+For example, say you have a buffer with the following contents:
+  FooBarFoo
+  FooBar
+  Foo
+  FooBarBaz
+And you then type F<tab>. Vim's builtin longest support will complete the
+longest common text 'Foo' and offer 'FooBarFoo', 'FooBar', 'Foo', and
+'FooBarBaz' as possible completions. With supertab's longest match
+enhancement disabled, typing B<tab> while still in the completion mode will
+end up completing 'FooBarBaz' or 'FooBarFoo' depending your settings, instead
+of the next longest common match of 'FooBar'. With supertab's enhanced
+longest match feature enabled, the typing of B<tab> will result in the next
+longest text being completed.
+
+
+Preselecting the first entry        *supertab-longesthighlight*
+                                    *g:SuperTabLongestHighlight*
+
+g:SuperTabLongestHighlight (default value: 0)
+
+Sets whether or not to pre-highlight the first match when completeopt has the
+popup menu enabled and the 'longest' option as well. When enabled, <tab> will
+kick off completion and pre-select the first entry in the popup menu, allowing
+you to simply hit <enter> to use it.
+
+
+Mapping <cr> to end completion      *supertab-crmapping*
+                                    *g:SuperTabCrMapping*
+
+g:SuperTabCrMapping (default value: 0)
+
+When enabled, <cr> will cancel completion mode preserving the current text.
+
+Compatibility with other plugins:
+  - endwise:     compatible
+  - delimitMate: not compatible (disabled if the delimitMate <cr> mapping is
+    detected.)
+
+Note: if you have an insert expression mapping with a <cr> in it or an insert
+abbreviation containing a <cr>, then supertab will not create a <cr> mapping
+which could potentially cause problems with those.
+
+
+Auto close the preview window       *supertab-closepreviewonpopupclose*
+                                    *g:SuperTabClosePreviewOnPopupClose*
+
+g:SuperTabClosePreviewOnPopupClose (default value: 0)
+
+When enabled, supertab will attempt to close vim's completion preview window
+when the completion popup closes (completion is finished or canceled).
+
+
+Completion ignore/match case        *supertab-completecase*
+                                    *g:SuperTabCompleteCase*
+
+g:SuperTabCompleteCase (default value: 'inherit')
+
+When issuing completions (keyword and potentially others), the value of your
+|'ignorecase'| setting will determine what results are returned based on
+whether or not you've chosen to ignore case or not. However, you may have
+|'ignorecase'| set or unset for other reasons and don't want that value
+considered when using insert completion. SuperTab allows you temporarily
+override |'ignorecase'| by setting g:SuperTabCompleteCase to either 'ignore'
+or 'match' depending on whether you want to always ignore or match case when
+using insert completion.
+
+Note: third party omni/user completion plugins may or may not honor
+|'ignorecase'|. If they do not, then you can probably contact them to add that
+support.
+
+Completion Chaining                  *supertab-completionchaining*
+
+SuperTab provides the ability to chain one of the completion functions
+(|completefunc| or |omnifunc|) together with one of the default vim
+completion key sequences (|ins-completion|), giving you the ability to attempt
+completion with the first, and upon no results, fall back to the second.
+
+To utilize this feature you need to call the *SuperTabChain* function where
+the first argument is the name of a vim compatible |complete-function| and the
+second is one of vim's insert completion (|ins-completion|) key bindings
+(<c-p>, <c-n>, <c-x><c-]>, etc). Calling this function will set the current
+buffer's |completefunc| option to a supertab provided implementation which
+utilizes the supplied arguments to perform the completion.
+
+Here is an example that can be added to your .vimrc which will setup the
+supertab chaining for any filetype that has a provided |omnifunc| to first
+try that, then fall back to supertab's default, <c-p>, completion:
+
+>
+  autocmd FileType *
+    \ if &omnifunc != '' |
+    \   call SuperTabChain(&omnifunc, "<c-p>") |
+    \ endif
+<
+
+You can also specify whether or not the 'context' completion method will
+be used as part of your completion chaining. If you've already set your
+default completion type to 'context', then no further action is needed. If
+however you haven't set that or don't want to use 'context' completion in this
+case, then you can supply a third argument to SuperTabChain which is a boolean
+(1 or 0) indicationg whether you want to use 'context' completion (1) or not
+(0).
+
+Here is an example where 'context' is the global default and completion
+chaining is enabled for file types that have omni completion support:
+
+>
+  let g:SuperTabDefaultCompletionType = 'context'
+  autocmd FileType *
+    \ if &omnifunc != '' |
+    \   call SuperTabChain(&omnifunc, "<c-p>") |
+    \ endif
+<
+
+This configuration will result in a completion flow like so:
+
+  if text before the cursor looks like a file path:
+    use file completion
+  elif text before the cursor looks like an attempt to access a member
+  (method, field, etc):
+    use user completion
+      where user completion is currently set to supertab's
+      completion chaining, resulting in:
+        if omni completion has results:
+          use omni completion
+        else:
+          use keyword completion
+  else:
+    use keyword completion
+
+Note: Completion chaining only supports chaining 1 completion function (omni
+or user) with 1 regular completion keybinding. All other combinations of
+completions (2 or more completion functions, 2 or more key bindings, etc.) are
+not supported due to limitations imposed by vim's code completion
+implementation.
+
+Note: If the |completefunc| or |omnifunc| use vim's |complete_add()| instead
+of returning completion results as a list, then Supertab's completion chaining
+won't work properly with it since Supertab uses the function result to
+determine if it should fallback to the next completion type.
+
+vim:tw=78:ts=8:ft=help:norl:
diff --git a/vim/.vim/bundle/supertab/ftplugin/html.vim b/vim/.vim/bundle/supertab/ftplugin/html.vim
new file mode 100644
index 0000000..4bd2385
--- /dev/null
+++ b/vim/.vim/bundle/supertab/ftplugin/html.vim
@@ -0,0 +1,61 @@
+" Author: Eric Van Dewoestine <ervandew@gmail.com>
+"
+" License: {{{
+"   Copyright (c) 2014
+"   All rights reserved.
+"
+"   Redistribution and use of this software in source and binary forms, with
+"   or without modification, are permitted provided that the following
+"   conditions are met:
+"
+"   * Redistributions of source code must retain the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer.
+"
+"   * Redistributions in binary form must reproduce the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer in the documentation and/or other
+"     materials provided with the distribution.
+"
+"   * Neither the name of Gergely Kontra or Eric Van Dewoestine nor the names
+"   of its contributors may be used to endorse or promote products derived
+"   from this software without specific prior written permission of Gergely
+"   Kontra or Eric Van Dewoestine.
+"
+"   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+"   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+"   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+"   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+"   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+"   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+"   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+"   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+"   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+"   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+"   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+" }}}
+
+if !exists('b:SuperTabContextTextMemberPatterns')
+  let b:SuperTabContextTextMemberPatterns = ['</']
+endif
+if !exists('b:SuperTabContextTextOmniPrecedence')
+  let set_precedence = 1
+
+  " don't set omni precedence when user is using eclim + php
+  if &ft == 'php'
+    try
+      let project = eclim#project#util#GetCurrentProjectName()
+      if project != ''
+        let natures = eclim#project#util#GetProjectNatureAliases(project)
+        let set_precedence = !eclim#util#ListContains(natures, 'php')
+      endif
+    catch /E117/
+    endtry
+  endif
+
+  if set_precedence
+    let b:SuperTabContextTextOmniPrecedence = ['&omnifunc', '&completefunc']
+  endif
+endif
+
+" vim:ft=vim:fdm=marker
diff --git a/vim/.vim/bundle/supertab/ftplugin/xml.vim b/vim/.vim/bundle/supertab/ftplugin/xml.vim
new file mode 100644
index 0000000..2b23d88
--- /dev/null
+++ b/vim/.vim/bundle/supertab/ftplugin/xml.vim
@@ -0,0 +1,45 @@
+" Author: Eric Van Dewoestine <ervandew@gmail.com>
+"
+" License: {{{
+"   Copyright (c) 2014
+"   All rights reserved.
+"
+"   Redistribution and use of this software in source and binary forms, with
+"   or without modification, are permitted provided that the following
+"   conditions are met:
+"
+"   * Redistributions of source code must retain the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer.
+"
+"   * Redistributions in binary form must reproduce the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer in the documentation and/or other
+"     materials provided with the distribution.
+"
+"   * Neither the name of Gergely Kontra or Eric Van Dewoestine nor the names
+"   of its contributors may be used to endorse or promote products derived
+"   from this software without specific prior written permission of Gergely
+"   Kontra or Eric Van Dewoestine.
+"
+"   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+"   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+"   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+"   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+"   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+"   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+"   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+"   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+"   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+"   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+"   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+" }}}
+
+if !exists('b:SuperTabContextTextMemberPatterns')
+  let b:SuperTabContextTextMemberPatterns = ['</']
+endif
+if !exists('b:SuperTabContextTextOmniPrecedence')
+  let b:SuperTabContextTextOmniPrecedence = ['&omnifunc', '&completefunc']
+endif
+
+" vim:ft=vim:fdm=marker
diff --git a/vim/.vim/bundle/supertab/plugin/supertab.vim b/vim/.vim/bundle/supertab/plugin/supertab.vim
new file mode 100644
index 0000000..5c15ea4
--- /dev/null
+++ b/vim/.vim/bundle/supertab/plugin/supertab.vim
@@ -0,0 +1,1144 @@
+" Author: Eric Van Dewoestine <ervandew@gmail.com>
+"         Original concept and versions up to 0.32 written by
+"         Gergely Kontra <kgergely@mcl.hu>
+" Version: 2.1
+" GetLatestVimScripts: 1643 1 :AutoInstall: supertab.vim
+"
+" Description: {{{
+"   Use your tab key to do all your completion in insert mode!
+"   You can cycle forward and backward with the <Tab> and <S-Tab> keys
+"   Note: you must press <Tab> once to be able to cycle back
+"
+"   http://www.vim.org/scripts/script.php?script_id=1643
+" }}}
+"
+" License: {{{
+"   Copyright (c) 2002 - 2015
+"   All rights reserved.
+"
+"   Redistribution and use of this software in source and binary forms, with
+"   or without modification, are permitted provided that the following
+"   conditions are met:
+"
+"   * Redistributions of source code must retain the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer.
+"
+"   * Redistributions in binary form must reproduce the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer in the documentation and/or other
+"     materials provided with the distribution.
+"
+"   * Neither the name of Gergely Kontra or Eric Van Dewoestine nor the names
+"   of its contributors may be used to endorse or promote products derived
+"   from this software without specific prior written permission of Gergely
+"   Kontra or Eric Van Dewoestine.
+"
+"   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+"   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+"   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+"   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+"   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+"   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+"   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+"   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+"   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+"   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+"   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+" }}}
+"
+" Testing Info: {{{
+"   Running vim + supertab with the absolute bare minimum settings:
+"     $ vim -u NONE -U NONE -c "set nocp | runtime plugin/supertab.vim"
+" }}}
+
+if v:version < 700
+  finish
+endif
+
+if exists('complType') " Integration with other completion functions.
+  finish
+endif
+
+if exists("loaded_supertab")
+  finish
+endif
+let loaded_supertab = 1
+
+let s:save_cpo=&cpo
+set cpo&vim
+
+" Global Variables {{{
+
+  if !exists("g:SuperTabDefaultCompletionType")
+    let g:SuperTabDefaultCompletionType = "<c-p>"
+  endif
+
+  if !exists("g:SuperTabContextDefaultCompletionType")
+    let g:SuperTabContextDefaultCompletionType = "<c-p>"
+  endif
+
+  if !exists("g:SuperTabContextTextMemberPatterns")
+    let g:SuperTabContextTextMemberPatterns = ['\.', '>\?::', '->']
+  endif
+
+  if !exists("g:SuperTabCompletionContexts")
+    let g:SuperTabCompletionContexts = ['s:ContextText']
+  endif
+
+  if !exists("g:SuperTabRetainCompletionDuration")
+    let g:SuperTabRetainCompletionDuration = 'insert'
+  endif
+
+  if !exists("g:SuperTabNoCompleteBefore")
+    " retain backwards compatability
+    if exists("g:SuperTabMidWordCompletion") && !g:SuperTabMidWordCompletion
+      let g:SuperTabNoCompleteBefore = ['\k']
+    else
+      let g:SuperTabNoCompleteBefore = []
+    endif
+  endif
+
+  if !exists("g:SuperTabNoCompleteAfter")
+    " retain backwards compatability
+    if exists("g:SuperTabLeadingSpaceCompletion") && g:SuperTabLeadingSpaceCompletion
+      let g:SuperTabNoCompleteAfter = []
+    else
+      let g:SuperTabNoCompleteAfter = ['^', '\s']
+    endif
+  endif
+
+  if !exists("g:SuperTabMappingForward")
+    let g:SuperTabMappingForward = '<tab>'
+  endif
+  if !exists("g:SuperTabMappingBackward")
+    let g:SuperTabMappingBackward = '<s-tab>'
+  endif
+
+  if !exists("g:SuperTabMappingTabLiteral")
+    let g:SuperTabMappingTabLiteral = '<c-tab>'
+  endif
+
+  if !exists("g:SuperTabLongestEnhanced")
+    let g:SuperTabLongestEnhanced = 0
+  endif
+
+  if !exists("g:SuperTabLongestHighlight")
+    let g:SuperTabLongestHighlight = 0
+  endif
+
+  if !exists("g:SuperTabCrMapping")
+    let g:SuperTabCrMapping = 0
+  endif
+
+  if !exists("g:SuperTabClosePreviewOnPopupClose")
+    let g:SuperTabClosePreviewOnPopupClose = 0
+  endif
+
+  if !exists("g:SuperTabUndoBreak")
+    let g:SuperTabUndoBreak = 0
+  endif
+
+  if !exists("g:SuperTabCompleteCase")
+    let g:SuperTabCompleteCase = 'inherit'
+  endif
+
+" }}}
+
+" Script Variables {{{
+
+  " construct the help text.
+  let s:tabHelp =
+    \ "Hit <CR> or CTRL-] on the completion type you wish to switch to.\n" .
+    \ "Use :help ins-completion for more information.\n" .
+    \ "\n" .
+    \ "|<c-n>|      - Keywords in 'complete' searching down.\n" .
+    \ "|<c-p>|      - Keywords in 'complete' searching up (SuperTab default).\n" .
+    \ "|<c-x><c-l>| - Whole lines.\n" .
+    \ "|<c-x><c-n>| - Keywords in current file.\n" .
+    \ "|<c-x><c-k>| - Keywords in 'dictionary'.\n" .
+    \ "|<c-x><c-t>| - Keywords in 'thesaurus', thesaurus-style.\n" .
+    \ "|<c-x><c-i>| - Keywords in the current and included files.\n" .
+    \ "|<c-x><c-]>| - Tags.\n" .
+    \ "|<c-x><c-f>| - File names.\n" .
+    \ "|<c-x><c-d>| - Definitions or macros.\n" .
+    \ "|<c-x><c-v>| - Vim command-line.\n" .
+    \ "|<c-x><c-u>| - User defined completion.\n" .
+    \ "|<c-x><c-o>| - Omni completion.\n" .
+    \ "|<c-x>s|     - Spelling suggestions."
+
+  " set the available completion types and modes.
+  let s:types =
+    \ "\<c-e>\<c-y>\<c-l>\<c-n>\<c-k>\<c-t>\<c-i>\<c-]>" .
+    \ "\<c-f>\<c-d>\<c-v>\<c-n>\<c-p>\<c-u>\<c-o>\<c-n>\<c-p>s"
+  let s:modes = '/^E/^Y/^L/^N/^K/^T/^I/^]/^F/^D/^V/^P/^U/^O/s'
+  let s:types = s:types . "np"
+  let s:modes = s:modes . '/n/p'
+
+" }}}
+
+function! SuperTabSetDefaultCompletionType(type) " {{{
+  " Globally available function that users can use to set the default
+  " completion type for the current buffer, like in an ftplugin.
+
+  " don't allow overriding what SuperTabChain has set, otherwise chaining may
+  " not work.
+  if exists('b:SuperTabChain')
+    return
+  endif
+
+  " init hack for <c-x><c-v> workaround.
+  let b:complCommandLine = 0
+
+  let b:SuperTabDefaultCompletionType = a:type
+
+  " set the current completion type to the default
+  call SuperTabSetCompletionType(b:SuperTabDefaultCompletionType)
+endfunction " }}}
+
+function! SuperTabSetCompletionType(type) " {{{
+  " Globally available function that users can use to create mappings to quickly
+  " switch completion modes.  Useful when a user wants to restore the default or
+  " switch to another mode without having to kick off a completion of that type
+  " or use SuperTabHelp.  Note, this function only changes the current
+  " completion type, not the default, meaning that the default will still be
+  " restored once the configured retension duration has been met (see
+  " g:SuperTabRetainCompletionDuration).  To change the default for the current
+  " buffer, use SuperTabDefaultCompletionType(type) instead.  Example mapping to
+  " restore SuperTab default:
+  "   nmap <F6> :call SetSuperTabCompletionType("<c-p>")<cr>
+
+  " don't allow overriding what SuperTabChain has set, otherwise chaining may
+  " not work.
+  if exists('b:SuperTabChain')
+    return
+  endif
+
+  call s:InitBuffer()
+  exec "let b:complType = \"" . escape(a:type, '<') . "\""
+endfunction " }}}
+
+function! SuperTabAlternateCompletion(type) " {{{
+  " Function which can be mapped to a key to kick off an alternate completion
+  " other than the default.  For instance, if you have 'context' as the default
+  " and want to map ctrl+space to issue keyword completion.
+  " Note: due to the way vim expands ctrl characters in mappings, you cannot
+  " create the alternate mapping like so:
+  "    imap <c-space> <c-r>=SuperTabAlternateCompletion("<c-p>")<cr>
+  " instead, you have to use \<lt> to prevent vim from expanding the key
+  " when creating the mapping.
+  "    gvim:
+  "      imap <c-space> <c-r>=SuperTabAlternateCompletion("\<lt>c-p>")<cr>
+  "    console:
+  "      imap <nul> <c-r>=SuperTabAlternateCompletion("\<lt>c-p>")<cr>
+
+  call SuperTabSetCompletionType(a:type)
+  " end any current completion before attempting to start the new one.
+  " use feedkeys to prevent possible remapping of <c-e> from causing issues.
+  "call feedkeys("\<c-e>", 'n')
+  " ^ since we can't detect completion mode vs regular insert mode, we force
+  " vim into keyword completion mode and end that mode to prevent the regular
+  " insert behavior of <c-e> from occurring.
+  call feedkeys("\<c-x>\<c-p>\<c-e>", 'n')
+  call feedkeys(b:complType, 'n')
+  return ''
+endfunction " }}}
+
+function! SuperTabLongestHighlight(dir) " {{{
+  " When longest highlight is enabled, this function is used to do the actual
+  " selection of the completion popup entry.
+
+  if !s:CompletionMode()
+    return ''
+  endif
+  return a:dir == -1 ? "\<up>" : "\<down>"
+endfunction " }}}
+
+function! s:Init() " {{{
+  " Setup mechanism to restore original completion type upon leaving insert
+  " mode if configured to do so
+  if g:SuperTabRetainCompletionDuration == 'insert'
+    augroup supertab_retain
+      autocmd!
+      autocmd InsertLeave * call s:SetDefaultCompletionType()
+    augroup END
+  endif
+endfunction " }}}
+
+function! s:InitBuffer() " {{{
+  if exists('b:SuperTabNoCompleteBefore')
+    return
+  endif
+
+  let b:complReset = 0
+  let b:complTypeManual = !exists('b:complTypeManual') ? '' : b:complTypeManual
+  let b:complTypeContext = ''
+
+  " init hack for <c-x><c-v> workaround.
+  let b:complCommandLine = 0
+
+  if !exists('b:SuperTabNoCompleteBefore')
+    let b:SuperTabNoCompleteBefore = g:SuperTabNoCompleteBefore
+  endif
+  if !exists('b:SuperTabNoCompleteAfter')
+    let b:SuperTabNoCompleteAfter = g:SuperTabNoCompleteAfter
+  endif
+
+  if !exists('b:SuperTabDefaultCompletionType')
+    let b:SuperTabDefaultCompletionType = g:SuperTabDefaultCompletionType
+  endif
+
+  if !exists('b:SuperTabContextDefaultCompletionType')
+    let b:SuperTabContextDefaultCompletionType =
+      \ g:SuperTabContextDefaultCompletionType
+  endif
+
+  " set the current completion type to the default
+  call SuperTabSetCompletionType(b:SuperTabDefaultCompletionType)
+
+  " hack to programatically revert a change to snipmate that breaks supertab
+  " but which the new maintainers don't care about:
+  " http://github.com/garbas/vim-snipmate/issues/37
+  let snipmate = maparg('<tab>', 'i')
+  if snipmate =~ '<C-G>u' && g:SuperTabMappingForward =~? '<tab>'
+    let snipmate = substitute(snipmate, '<C-G>u', '', '')
+    iunmap <tab>
+    exec "inoremap <silent> <tab> " . snipmate
+  endif
+endfunction " }}}
+
+function! s:ManualCompletionEnter() " {{{
+  " Handles manual entrance into completion mode.
+
+  if &smd
+    echo '' | echohl ModeMsg | echo '-- ^X++ mode (' . s:modes . ')' | echohl None
+  endif
+  let complType = nr2char(getchar())
+  if stridx(s:types, complType) != -1
+    if !exists('b:supertab_close_preview')
+      let b:supertab_close_preview = !s:IsPreviewOpen()
+    endif
+
+    if stridx("\<c-e>\<c-y>", complType) != -1 " no memory, just scroll...
+      return "\<c-x>" . complType
+    elseif stridx('np', complType) != -1
+      let complType = nr2char(char2nr(complType) - 96)
+    else
+      let complType = "\<c-x>" . complType
+    endif
+
+    let b:complTypeManual = complType
+
+    if index(['insert', 'session'], g:SuperTabRetainCompletionDuration) != -1
+      let b:complType = complType
+    endif
+
+    " Hack to workaround bug when invoking command line completion via <c-r>=
+    if complType == "\<c-x>\<c-v>"
+      return s:CommandLineCompletion()
+    endif
+
+    call s:InitBuffer()
+
+    " optionally enable enhanced longest completion
+    if g:SuperTabLongestEnhanced && &completeopt =~ 'longest'
+      call s:EnableLongestEnhancement()
+    " handle backspacing which triggers g:SuperTabNoCompleteAfter match
+    elseif s:IsNoCompleteAfterReset()
+      call s:EnableNoCompleteAfterReset()
+    endif
+
+    if g:SuperTabLongestHighlight &&
+     \ &completeopt =~ 'longest' &&
+     \ &completeopt =~ 'menu' &&
+     \ !s:CompletionMode()
+      let dir = (complType == "\<c-x>\<c-p>") ? -1 : 1
+      call feedkeys("\<c-r>=SuperTabLongestHighlight(" . dir . ")\<cr>", 'n')
+    endif
+
+    call s:StartCompletionMode()
+    return complType
+  endif
+
+  echohl "Unknown mode"
+  return complType
+endfunction " }}}
+
+function! s:SetCompletionType() " {{{
+  " Sets the completion type based on what the user has chosen from the help
+  " buffer.
+
+  let chosen = substitute(getline('.'), '.*|\(.*\)|.*', '\1', '')
+  if chosen != getline('.')
+    let winnr = b:winnr
+    close
+    exec winnr . 'winc w'
+    call SuperTabSetCompletionType(chosen)
+  endif
+endfunction " }}}
+
+function! s:SetDefaultCompletionType() " {{{
+  if exists('b:SuperTabDefaultCompletionType') &&
+  \ (!exists('b:complCommandLine') || !b:complCommandLine)
+    call SuperTabSetCompletionType(b:SuperTabDefaultCompletionType)
+  endif
+endfunction " }}}
+
+function! SuperTab(command) " {{{
+  " Used to perform proper cycle navigation as the user requests the next or
+  " previous entry in a completion list, and determines whether or not to simply
+  " retain the normal usage of <tab> based on the cursor position.
+
+  if exists('b:SuperTabDisabled') && b:SuperTabDisabled
+    if exists('s:Tab')
+      return s:Tab()
+    endif
+    return (
+        \ g:SuperTabMappingForward ==? '<tab>' ||
+        \ g:SuperTabMappingBackward ==? '<tab>'
+      \ ) ? "\<tab>" : ''
+  endif
+
+  call s:InitBuffer()
+
+  if s:WillComplete()
+    if !exists('b:supertab_close_preview')
+      let b:supertab_close_preview = !s:IsPreviewOpen()
+    endif
+
+    " optionally enable enhanced longest completion
+    if g:SuperTabLongestEnhanced && &completeopt =~ 'longest'
+      call s:EnableLongestEnhancement()
+    " handle backspacing which triggers g:SuperTabNoCompleteAfter match
+    elseif s:IsNoCompleteAfterReset()
+      call s:EnableNoCompleteAfterReset()
+    endif
+
+    if !s:CompletionMode()
+      let b:complTypeManual = ''
+    endif
+
+    " exception: if in <c-p> mode, then <c-n> should move up the list, and
+    " <c-p> down the list.
+    if a:command == 'p' && !b:complReset &&
+      \ (b:complType == "\<c-p>" ||
+      \   (b:complType == 'context' &&
+      \    b:complTypeManual == '' &&
+      \    b:complTypeContext == "\<c-p>"))
+      return "\<c-n>"
+
+    elseif a:command == 'p' && !b:complReset &&
+      \ (b:complType == "\<c-n>" ||
+      \   (b:complType == 'context' &&
+      \    b:complTypeManual == '' &&
+      \    b:complTypeContext == "\<c-n>"))
+      return "\<c-p>"
+
+    " already in completion mode and not resetting for longest enhancement, so
+    " just scroll to next/previous
+    elseif s:CompletionMode() && !b:complReset
+      let type = b:complType == 'context' ? b:complTypeContext : b:complType
+      if a:command == 'n'
+        return type == "\<c-p>" || type == "\<c-x>\<c-p>" ? "\<c-p>" : "\<c-n>"
+      endif
+      return type == "\<c-p>" || type == "\<c-x>\<c-p>" ? "\<c-n>" : "\<c-p>"
+    endif
+
+    " handle 'context' completion.
+    if b:complType == 'context'
+      let complType = s:ContextCompletion()
+      if complType == ''
+        exec "let complType = \"" .
+          \ escape(b:SuperTabContextDefaultCompletionType, '<') . "\""
+      endif
+      let b:complTypeContext = complType
+
+    " Hack to workaround bug when invoking command line completion via <c-r>=
+    elseif b:complType == "\<c-x>\<c-v>"
+      let complType = s:CommandLineCompletion()
+    else
+      let complType = b:complType
+    endif
+
+    " switch <c-x><c-p> / <c-x><c-n> completion in <c-p> mode
+    if a:command == 'p'
+      if complType == "\<c-x>\<c-p>"
+        let complType = "\<c-x>\<c-n>"
+      elseif complType == "\<c-x>\<c-n>"
+        let complType = "\<c-x>\<c-p>"
+      endif
+    endif
+
+    " highlight first result if longest enabled
+    if g:SuperTabLongestHighlight &&
+     \ &completeopt =~ 'longest' &&
+     \ &completeopt =~ 'menu' &&
+     \ (!s:CompletionMode() || b:complReset)
+      let dir = (complType == "\<c-p>") ? -1 : 1
+      call feedkeys("\<c-r>=SuperTabLongestHighlight(" . dir . ")\<cr>", 'n')
+    endif
+
+    if b:complReset
+      let b:complReset = 0
+      " not an accurate condition for everyone, but better than sending <c-e>
+      " at the wrong time.
+      if s:CompletionMode()
+        return "\<c-e>" . complType
+      endif
+    endif
+
+    if g:SuperTabUndoBreak && !s:CompletionMode()
+      call s:StartCompletionMode()
+      return "\<c-g>u" . complType
+    endif
+
+    if g:SuperTabCompleteCase == 'ignore' ||
+     \ g:SuperTabCompleteCase == 'match'
+      if exists('##CompleteDone')
+        let ignorecase = g:SuperTabCompleteCase == 'ignore' ? 1 : 0
+        if &ignorecase != ignorecase
+          let b:supertab_ignorecase_save = &ignorecase
+          let &ignorecase = ignorecase
+          augroup supertab_ignorecase
+            autocmd CompleteDone <buffer>
+              \ let &ignorecase = b:supertab_ignorecase_save |
+              \ unlet b:supertab_ignorecase_save |
+              \ autocmd! supertab_ignorecase
+          augroup END
+        endif
+      endif
+    endif
+
+    call s:StartCompletionMode()
+    return complType
+  endif
+
+  if (a:command == 'n' && g:SuperTabMappingForward ==? '<tab>') ||
+   \ (a:command == 'p' && g:SuperTabMappingBackward ==? '<tab>')
+
+    " trigger our func ref to the smart tabs plugin if present.
+    if exists('s:Tab')
+      return s:Tab()
+    endif
+
+    return "\<tab>"
+  endif
+
+  if (a:command == 'n' && g:SuperTabMappingForward ==? '<s-tab>') ||
+   \ (a:command == 'p' && g:SuperTabMappingBackward ==? '<s-tab>')
+    " support triggering <s-tab> mappings users might have.
+    if exists('s:ShiftTab')
+      if type(s:ShiftTab) == 2
+        return s:ShiftTab()
+      else
+        call feedkeys(s:ShiftTab, 'n')
+      endif
+    endif
+  endif
+
+  return ''
+endfunction " }}}
+
+function! s:SuperTabHelp() " {{{
+  " Opens a help window where the user can choose a completion type to enter.
+
+  let winnr = winnr()
+  if bufwinnr("SuperTabHelp") == -1
+    keepalt botright split SuperTabHelp
+
+    setlocal noswapfile
+    setlocal buftype=nowrite
+    setlocal bufhidden=wipe
+
+    silent put =s:tabHelp
+    call cursor(1, 1)
+    silent 1,delete _
+    call cursor(4, 1)
+    exec "resize " . line('$')
+
+    syntax match Special "|.\{-}|"
+
+    setlocal readonly
+    setlocal nomodifiable
+
+    nmap <silent> <buffer> <cr> :call <SID>SetCompletionType()<cr>
+    nmap <silent> <buffer> <c-]> :call <SID>SetCompletionType()<cr>
+  else
+    exec bufwinnr("SuperTabHelp") . "winc w"
+  endif
+  let b:winnr = winnr
+endfunction " }}}
+
+function! s:CompletionMode() " {{{
+  return pumvisible() || exists('b:supertab_completion_mode')
+endfunction " }}}
+
+function! s:StartCompletionMode() " {{{
+  if exists('##CompleteDone')
+    let b:supertab_completion_mode = 1
+    augroup supertab_completion_mode
+      autocmd CompleteDone <buffer>
+        \ if exists('b:supertab_completion_mode') |
+          \ unlet b:supertab_completion_mode |
+        \ endif |
+        \ autocmd! supertab_completion_mode
+    augroup END
+  endif
+endfunction " }}}
+
+function! s:WillComplete(...) " {{{
+  " Determines if completion should be kicked off at the current location.
+  " Optional arg:
+  "   col: The column to check at, otherwise use the current column.
+
+  " if an arg was supplied, then we will re-check even if already in
+  " completion mode.
+  if s:CompletionMode() && !a:0
+    return 1
+  endif
+
+  let line = getline('.')
+  let cnum = a:0 ? a:1 : col('.')
+
+  " honor SuperTabNoCompleteAfter
+  let pre = cnum >= 2 ? line[:cnum - 2] : ''
+  let complAfterType = type(b:SuperTabNoCompleteAfter)
+  if complAfterType == 3
+    " the option was provided as a list of patterns
+    for pattern in b:SuperTabNoCompleteAfter
+      if pre =~ pattern . '$'
+        return 0
+      endif
+    endfor
+  elseif complAfterType == 2
+    " the option was provided as a funcref
+    return !b:SuperTabNoCompleteAfter(pre)
+  endif
+
+  " honor SuperTabNoCompleteBefore
+  " Within a word, but user does not have mid word completion enabled.
+  let post = line[cnum - 1:]
+  let complBeforeType = type(b:SuperTabNoCompleteBefore)
+  if complBeforeType == 3
+    " a list of patterns
+    for pattern in b:SuperTabNoCompleteBefore
+      if post =~ '^' . pattern
+        return 0
+      endif
+    endfor
+  elseif complBeforeType == 2
+    " the option was provided as a funcref
+    return !b:SuperTabNoCompleteBefore(post)
+  endif
+
+  return 1
+endfunction " }}}
+
+function! s:EnableLongestEnhancement() " {{{
+  augroup supertab_reset
+    autocmd!
+    autocmd InsertLeave,CursorMovedI <buffer>
+      \ call s:ReleaseKeyPresses() | autocmd! supertab_reset
+  augroup END
+  call s:CaptureKeyPresses()
+endfunction " }}}
+
+function! s:IsNoCompleteAfterReset() " {{{
+  " if the user has g:SuperTabNoCompleteAfter set, then re-map <bs> so that
+  " backspacing to a point where one of the g:SuperTabNoCompleteAfter
+  " entries matches will cause completion mode to exit.
+  let complAfterType = type(b:SuperTabNoCompleteAfter)
+  if complAfterType == 2
+    return 1
+  endif
+  return len(g:SuperTabNoCompleteAfter) && g:SuperTabNoCompleteAfter != ['^', '\s']
+endfunction " }}}
+
+function! s:EnableNoCompleteAfterReset() " {{{
+  augroup supertab_reset
+    autocmd!
+    autocmd InsertLeave,CursorMovedI <buffer>
+      \ call s:ReleaseKeyPresses() | autocmd! supertab_reset
+  augroup END
+
+  " short version of s:CaptureKeyPresses
+  if !exists('b:capturing') || !b:capturing
+    let b:capturing = 1
+    let b:capturing_start = col('.')
+    let b:captured = {
+        \ '<bs>': s:CaptureKeyMap('<bs>'),
+        \ '<c-h>': s:CaptureKeyMap('<c-h>'),
+      \ }
+    imap <buffer> <bs> <c-r>=<SID>CompletionReset("\<lt>bs>")<cr>
+    imap <buffer> <c-h> <c-r>=<SID>CompletionReset("\<lt>c-h>")<cr>
+  endif
+endfunction " }}}
+
+function! s:CompletionReset(char) " {{{
+  let b:complReset = 1
+
+  " handle exiting completion mode if user has g:SuperTabNoCompleteAfter set
+  " and they are about to backspace to a point where that maches one of the
+  " entries in that var.
+  if (a:char == "\<bs>" || a:char == "\<c-h>") && s:IsNoCompleteAfterReset()
+    if !s:WillComplete(col('.') - 1)
+      " Exit from completion mode then issue the currently requested
+      " backspace (mapped).
+      call feedkeys("\<space>\<bs>", 'n')
+      call s:ReleaseKeyPresses()
+      call feedkeys("\<bs>", 'mt')
+      return ''
+    endif
+  endif
+
+  return a:char
+endfunction " }}}
+
+function! s:CaptureKeyPresses() " {{{
+  if !exists('b:capturing') || !b:capturing
+    let b:capturing = 1
+    let b:capturing_start = col('.')
+    " save any previous mappings
+    let b:captured = {
+        \ '<bs>': s:CaptureKeyMap('<bs>'),
+        \ '<c-h>': s:CaptureKeyMap('<c-h>'),
+      \ }
+    " TODO: use &keyword to get an accurate list of chars to map
+    for c in split('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_', '.\zs')
+      let existing = s:CaptureKeyMap(c)
+      let b:captured[c] = existing
+      exec 'imap <buffer> ' . c . ' <c-r>=<SID>CompletionReset("' . c . '")<cr>'
+    endfor
+    imap <buffer> <bs> <c-r>=<SID>CompletionReset("\<lt>bs>")<cr>
+    imap <buffer> <c-h> <c-r>=<SID>CompletionReset("\<lt>c-h>")<cr>
+  endif
+endfunction " }}}
+
+function! s:CaptureKeyMap(key) " {{{
+  " as of 7.3.032 maparg supports obtaining extended information about the
+  " mapping.
+  if s:has_dict_maparg
+    return maparg(a:key, 'i', 0, 1)
+  endif
+  return maparg(a:key, 'i')
+endfunction " }}}
+
+function! s:IsPreviewOpen() " {{{
+  let wins = tabpagewinnr(tabpagenr(), '$')
+  let winnr = 1
+  while winnr <= wins
+    if getwinvar(winnr, '&previewwindow') == 1
+      return 1
+    endif
+    let winnr += 1
+  endwhile
+  return 0
+endfunction " }}}
+
+function! s:ClosePreview() " {{{
+  if exists('b:supertab_close_preview') && b:supertab_close_preview
+    let preview = 0
+    for bufnum in tabpagebuflist()
+      if getwinvar(bufwinnr(bufnum), '&previewwindow')
+        let preview = 1
+        break
+      endif
+    endfor
+    if preview
+      pclose
+      try
+        doautocmd <nomodeline> supertab_preview_closed User <supertab>
+      catch /E216/
+        " ignore: no autocmds defined
+      endtry
+    endif
+  endif
+  silent! unlet b:supertab_close_preview
+endfunction " }}}
+
+function! s:ReleaseKeyPresses() " {{{
+  if exists('b:capturing') && b:capturing
+    let b:capturing = 0
+    for c in keys(b:captured)
+      exec 'iunmap <buffer> ' . c
+    endfor
+
+    " restore any previous mappings
+    for [key, mapping] in items(b:captured)
+      if !len(mapping)
+        continue
+      endif
+
+      if type(mapping) == 4
+        let restore = mapping.noremap ? "inoremap" : "imap"
+        let restore .= " <buffer>"
+        if mapping.silent
+          let restore .= " <silent>"
+        endif
+        if mapping.expr
+          let restore .= " <expr>"
+        endif
+        let rhs = substitute(mapping.rhs, '<SID>\c', '<SNR>' . mapping.sid . '_', 'g')
+        let restore .= ' ' . key . ' ' . rhs
+        exec restore
+      elseif type(c) == 1
+        let args = substitute(mapping, '.*\(".\{-}"\).*', '\1', '')
+        if args != mapping
+          let args = substitute(args, '<', '<lt>', 'g')
+          let expr = substitute(mapping, '\(.*\)".\{-}"\(.*\)', '\1%s\2', '')
+          let mapping = printf(expr, args)
+        endif
+        exec printf("imap <silent> <buffer> %s %s", key, mapping)
+      endif
+    endfor
+    unlet b:captured
+
+    if mode() == 'i' && &completeopt =~ 'menu' && b:capturing_start != col('.')
+      " force full exit from completion mode (don't exit insert mode since
+      " that will break repeating with '.')
+      call feedkeys("\<space>\<bs>", 'n')
+    endif
+    unlet b:capturing_start
+  endif
+endfunction " }}}
+
+function! s:CommandLineCompletion() " {{{
+  " Hack needed to account for apparent bug in vim command line mode completion
+  " when invoked via <c-r>=
+
+  " This hack will trigger InsertLeave which will then invoke
+  " s:SetDefaultCompletionType.  To prevent default completion from being
+  " restored prematurely, set an internal flag for s:SetDefaultCompletionType
+  " to check for.
+  let b:complCommandLine = 1
+  return "\<c-\>\<c-o>:call feedkeys('\<c-x>\<c-v>\<c-v>', 'n') | " .
+    \ "let b:complCommandLine = 0\<cr>"
+endfunction " }}}
+
+function! s:ContextCompletion() " {{{
+  let contexts = exists('b:SuperTabCompletionContexts') ?
+    \ b:SuperTabCompletionContexts : g:SuperTabCompletionContexts
+
+  for context in contexts
+    try
+      let Context = function(context)
+      let complType = Context()
+      unlet Context
+      if type(complType) == 1 && complType != ''
+        return complType
+      endif
+    catch /E700/
+      echohl Error
+      echom 'supertab: no context function "' . context . '" found.'
+      echohl None
+    endtry
+  endfor
+  return ''
+endfunction " }}}
+
+function! s:ContextDiscover() " {{{
+  let discovery = exists('g:SuperTabContextDiscoverDiscovery') ?
+    \ g:SuperTabContextDiscoverDiscovery : []
+
+  " loop through discovery list to find the default
+  if !empty(discovery)
+    for pair in discovery
+      let var = substitute(pair, '\(.*\):.*', '\1', '')
+      let type = substitute(pair, '.*:\(.*\)', '\1', '')
+      exec 'let value = ' . var
+      if value !~ '^\s*$' && value != '0'
+        exec "let complType = \"" . escape(type, '<') . "\""
+        return complType
+      endif
+    endfor
+  endif
+endfunction " }}}
+
+function! s:ContextText() " {{{
+  let exclusions = exists('g:SuperTabContextTextFileTypeExclusions') ?
+    \ g:SuperTabContextTextFileTypeExclusions : []
+
+  if index(exclusions, &ft) == -1
+    let curline = getline('.')
+    let cnum = col('.')
+    let synname = synIDattr(synID(line('.'), cnum - 1, 1), 'name')
+
+    let member_patterns = exists('b:SuperTabContextTextMemberPatterns') ?
+      \ b:SuperTabContextTextMemberPatterns : g:SuperTabContextTextMemberPatterns
+    let member_pattern = join(member_patterns, '\|')
+
+    " don't kick off file completion if the pattern is '</' (to account for
+    " sgml languanges), that's what the following <\@<! pattern is doing.
+    if curline =~ '<\@<!/\.\?\w*\%' . cnum . 'c' ||
+      \ ((has('win32') || has('win64')) && curline =~ '\\\w*\%' . cnum . 'c')
+
+      return "\<c-x>\<c-f>"
+
+    elseif curline =~ '\(' . member_pattern . '\)\w*\%' . cnum . 'c' &&
+      \ synname !~ '\(String\|Comment\)'
+      let omniPrecedence = exists('g:SuperTabContextTextOmniPrecedence') ?
+        \ g:SuperTabContextTextOmniPrecedence : ['&completefunc', '&omnifunc']
+      let omniPrecedence = exists('b:SuperTabContextTextOmniPrecedence') ?
+        \ b:SuperTabContextTextOmniPrecedence : omniPrecedence
+
+      for omniFunc in omniPrecedence
+        if omniFunc !~ '^&'
+          let omniFunc = '&' . omniFunc
+        endif
+        if getbufvar(bufnr('%'), omniFunc) != ''
+          return omniFunc == '&omnifunc' ? "\<c-x>\<c-o>" : "\<c-x>\<c-u>"
+        endif
+      endfor
+    endif
+  endif
+endfunction " }}}
+
+function! s:ExpandMap(map) " {{{
+  let map = a:map
+  if map =~ '<Plug>'
+    let plug = substitute(map, '.\{-}\(<Plug>\w\+\).*', '\1', '')
+    let plug_map = maparg(plug, 'i')
+    let map = substitute(map, '.\{-}\(<Plug>\w\+\).*', plug_map, '')
+  endif
+  return map
+endfunction " }}}
+
+function! SuperTabChain(completefunc, completekeys, ...) " {{{
+  if a:completefunc != 'SuperTabCodeComplete'
+    call s:InitBuffer()
+    if (a:0 && a:1) || (!a:0 && b:SuperTabDefaultCompletionType == 'context')
+      let b:SuperTabContextTextOmniPrecedence = ['&completefunc', '&omnifunc']
+      call SuperTabSetDefaultCompletionType("context")
+    else
+      call SuperTabSetDefaultCompletionType("<c-x><c-u>")
+    endif
+
+    let b:SuperTabChain = [a:completefunc, a:completekeys]
+    setlocal completefunc=SuperTabCodeComplete
+  endif
+endfunction " }}}
+
+function! SuperTabCodeComplete(findstart, base) " {{{
+  if !exists('b:SuperTabChain')
+    echoe 'No completion chain has been set.'
+    return -2
+  endif
+
+  if len(b:SuperTabChain) != 2
+    echoe 'Completion chain can only be used with 1 completion function ' .
+        \ 'and 1 fallback completion key binding.'
+    return -2
+  endif
+
+  let Func = function(b:SuperTabChain[0])
+
+  if a:findstart
+    let start = Func(a:findstart, a:base)
+    if start >= 0
+      return start
+    endif
+
+    return col('.') - 1
+  endif
+
+  let results = Func(a:findstart, a:base)
+  " Handle dict case, with 'words' and 'refresh' (optional).
+  " This is used by YouCompleteMe. (See complete-functions).
+  if type(results) == type({}) && has_key(results, 'words')
+    if len(results.words)
+      return results
+    endif
+  elseif len(results)
+    return results
+  endif
+
+  exec 'let keys = "' . escape(b:SuperTabChain[1], '<') . '"'
+  " <c-e>: stop completion and go back to the originally typed text.
+  call feedkeys("\<c-e>" . keys, 'nt')
+  return []
+endfunction " }}}
+
+" Autocmds {{{
+  if g:SuperTabClosePreviewOnPopupClose
+    augroup supertab_close_preview
+      autocmd!
+      autocmd InsertLeave,CursorMovedI * call s:ClosePreview()
+    augroup END
+  endif
+" }}}
+
+" Key Mappings {{{
+  " map a regular tab to ctrl-tab (note: doesn't work in console vim)
+  exec 'inoremap ' . g:SuperTabMappingTabLiteral . ' <tab>'
+
+  inoremap <silent> <c-x> <c-r>=<SID>ManualCompletionEnter()<cr>
+
+  imap <script> <Plug>SuperTabForward <c-r>=SuperTab('n')<cr>
+  imap <script> <Plug>SuperTabBackward <c-r>=SuperTab('p')<cr>
+
+  let s:has_dict_maparg = v:version > 703 || (v:version == 703 && has('patch32'))
+
+  " support delegating to smart tabs plugin
+  if g:SuperTabMappingForward ==? '<tab>' || g:SuperTabMappingBackward ==? '<tab>'
+    let existing_tab = maparg('<tab>', 'i')
+    if existing_tab =~ '\d\+_InsertSmartTab()$'
+      let s:Tab = function(substitute(existing_tab, '()$', '', ''))
+    endif
+  endif
+
+  " save user's existing <s-tab> mapping if they have one.
+  " Note: this could cause more problems than it solves if it picks up <s-tab>
+  " mappings from other plugins and misinterprets them, etc, so this block is
+  " experimental and could be removed later.
+  if g:SuperTabMappingForward ==? '<s-tab>' || g:SuperTabMappingBackward ==? '<s-tab>'
+    let stab = maparg('<s-tab>', 'i')
+    if s:has_dict_maparg
+      let existing_stab = maparg('<s-tab>', 'i', 0, 1)
+      if len(existing_stab) && existing_stab.expr
+        let stab = substitute(stab, '<SID>\c', '<SNR>' . existing_stab.sid . '_', '')
+        let stab = substitute(stab, '()$', '', '')
+        let s:ShiftTab = function(stab)
+        let stab = ''
+      endif
+    endif
+    if stab != ''
+      let stab = substitute(stab, '\(<[-a-zA-Z0-9]\+>\)', '\\\1', 'g')
+      exec "let stab = \"" . stab . "\""
+      let s:ShiftTab = stab
+    endif
+  endif
+
+  exec 'imap ' . g:SuperTabMappingForward . ' <Plug>SuperTabForward'
+  exec 'imap ' . g:SuperTabMappingBackward . ' <Plug>SuperTabBackward'
+
+  if g:SuperTabCrMapping
+    let expr_map = 0
+    if s:has_dict_maparg
+      let map_dict = maparg('<cr>', 'i', 0, 1)
+      let expr_map = has_key(map_dict, 'expr') && map_dict.expr
+    else
+      let expr_map = maparg('<cr>', 'i') =~? '\<cr>'
+    endif
+
+    redir => iabbrevs
+    silent iabbrev
+    redir END
+    let iabbrev_map = iabbrevs =~? '\<cr>'
+
+    if expr_map
+      " Not compatible w/ expr mappings. This is most likely a user mapping,
+      " typically with the same functionality anyways.
+      let g:SuperTabCrMapping = 0
+    elseif iabbrev_map
+      " Not compatible w/ insert abbreviations containing <cr>
+      let g:SuperTabCrMapping = 0
+    elseif maparg('<CR>', 'i') =~ '<Plug>delimitMateCR'
+      " Not compatible w/ delimitMate since it doesn't play well with others
+      " and will always return a <cr> which we don't want when selecting a
+      " completion.
+      let g:SuperTabCrMapping = 0
+    elseif maparg('<CR>', 'i') =~ '<CR>'
+      let map = maparg('<cr>', 'i')
+      let cr = !(map =~? '\(^\|[^)]\)<cr>' || map =~ 'ExpandCr')
+      let map = s:ExpandMap(map)
+      exec "inoremap <script> <cr> <c-r>=<SID>SelectCompletion(" . cr . ")<cr>" . map
+    else
+      inoremap <silent> <cr> <c-r>=<SID>SelectCompletion(1)<cr>
+    endif
+    function! s:SelectCompletion(cr)
+      " selecting a completion
+      if s:CompletionMode()
+        " ugly hack to let other <cr> mappings for other plugins cooperate
+        " with supertab
+        let b:supertab_pumwasvisible = 1
+
+        " close the preview window if configured to do so
+        if &completeopt =~ 'preview' && g:SuperTabClosePreviewOnPopupClose
+          if !exists('b:supertab_close_preview')
+            let b:supertab_close_preview = !s:IsPreviewOpen()
+          endif
+          call s:ClosePreview()
+        endif
+
+        return "\<c-y>"
+      endif
+
+      " only needed when chained with other mappings and one of them will
+      " issue a <cr>.
+      if exists('b:supertab_pumwasvisible') && !a:cr
+        unlet b:supertab_pumwasvisible
+        return ''
+      endif
+
+      " not so pleasant hack to keep <cr> working for abbreviations
+      let word = substitute(getline('.'), '^.*\s\+\(.*\%' . col('.') . 'c\).*', '\1', '')
+      let result = maparg(word, 'i', 1)
+      if result != ''
+        let bs = ""
+        let i = 0
+        while i < len(word)
+          let bs .= "\<bs>"
+          let i += 1
+        endwhile
+        " escape keys
+        let result = substitute(result, '\(<[a-zA-Z][-a-zA-Z]*>\)', '\\\1', 'g')
+        " ensure escaped keys are properly recognized
+        exec 'let result = "' . escape(result, '"') . '"'
+        return bs . result . (a:cr ? "\<cr>" : "")
+      endif
+
+      " only return a cr if nothing else is mapped to it since we don't want
+      " to duplicate a cr returned by another mapping.
+      return a:cr ? "\<cr>" : ""
+    endfunction
+  endif
+" }}}
+
+" Command Mappings {{{
+  if !exists(":SuperTabHelp")
+    command SuperTabHelp :call <SID>SuperTabHelp()
+  endif
+" }}}
+
+call s:Init()
+
+function! TestSuperTabCodeComplete(findstart, base) " {{{
+  " Test supertab completion chaining w/ a minimal vim environment:
+  " $ vim -u NONE -U NONE \
+  "   --cmd "set nocp | sy on" \
+  "   -c "so ~/.vim/plugin/supertab.vim" \
+  "   -c "let g:SuperTabDefaultCompletionType = '<c-x><c-u>'" \
+  "   -c "set completefunc=TestSuperTabCodeComplete" \
+  "   -c "call SuperTabChain(&completefunc, '<c-p>')"
+  if a:findstart
+    let line = getline('.')
+    let start = col('.') - 1
+    if line[start] =~ '\.'
+      let start -= 1
+    endif
+    while start > 0 && line[start - 1] =~ '\w'
+      let start -= 1
+    endwhile
+    return start
+  else
+    let completions = []
+    if getline('.') =~ 'TestC'
+      call add(completions, {
+          \ 'word': 'test1(',
+          \ 'kind': 'm',
+          \ 'menu': 'test1(...)',
+        \ })
+      call add(completions, {
+          \ 'word': 'testing2(',
+          \ 'kind': 'm',
+          \ 'menu': 'testing2(...)',
+        \ })
+    endif
+
+    return completions
+  endif
+endfunction " }}}
+
+let &cpo = s:save_cpo
+
+" vim:ft=vim:fdm=marker
diff --git a/vim/.vim/bundle/tagbar/.gitattributes b/vim/.vim/bundle/tagbar/.gitattributes
new file mode 100644
index 0000000..3b1db11
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/.gitattributes
@@ -0,0 +1,4 @@
+.gitignore     export-ignore
+.gitattributes export-ignore
+README         export-ignore
+.info          export-ignore
diff --git a/vim/.vim/bundle/tagbar/.info b/vim/.vim/bundle/tagbar/.info
new file mode 100644
index 0000000..f4d9137
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/.info
@@ -0,0 +1,2 @@
+tagbar
+3465
diff --git a/vim/.vim/bundle/tagbar/LICENSE b/vim/.vim/bundle/tagbar/LICENSE
new file mode 100644
index 0000000..5ae1a75
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/LICENSE
@@ -0,0 +1,82 @@
+TAGBAR LICENSE
+
+This is the normal Vim license (see ':h license' in Vim) with the necessary
+replacements for the project and maintainer information.
+
+I)  There are no restrictions on distributing unmodified copies of Tagbar
+    except that they must include this license text.  You can also distribute
+    unmodified parts of Tagbar, likewise unrestricted except that they must
+    include this license text.  You are also allowed to include executables
+    that you made from the unmodified Tagbar sources, plus your own usage
+    examples and scripts.
+
+II) It is allowed to distribute a modified (or extended) version of Tagbar,
+    including executables and/or source code, when the following four
+    conditions are met:
+    1) This license text must be included unmodified.
+    2) The modified Tagbar must be distributed in one of the following five ways:
+       a) If you make changes to Tagbar yourself, you must clearly describe in
+          the distribution how to contact you.  When the maintainer asks you
+          (in any way) for a copy of the modified Tagbar you distributed, you
+          must make your changes, including source code, available to the
+          maintainer without fee.  The maintainer reserves the right to
+          include your changes in the official version of Tagbar.  What the
+          maintainer will do with your changes and under what license they
+          will be distributed is negotiable.  If there has been no negotiation
+          then this license, or a later version, also applies to your changes.
+          The current maintainer is Jan Larres <jan@majutsushi.net>.  If this
+          changes it will be announced in appropriate places (most likely
+          majutsushi.github.io/tagbar and/or github.com/majutsushi/tagbar).
+          When it is completely impossible to contact the maintainer, the
+          obligation to send him your changes ceases.  Once the maintainer has
+          confirmed that he has received your changes they will not have to be
+          sent again.
+       b) If you have received a modified Tagbar that was distributed as
+          mentioned under a) you are allowed to further distribute it
+          unmodified, as mentioned at I).  If you make additional changes the
+          text under a) applies to those changes.
+       c) Provide all the changes, including source code, with every copy of
+          the modified Tagbar you distribute.  This may be done in the form of
+          a context diff.  You can choose what license to use for new code you
+          add.  The changes and their license must not restrict others from
+          making their own changes to the official version of Tagbar.
+       d) When you have a modified Tagbar which includes changes as mentioned
+          under c), you can distribute it without the source code for the
+          changes if the following three conditions are met:
+          - The license that applies to the changes permits you to distribute
+            the changes to the Tagbar maintainer without fee or restriction, and
+            permits the Tagbar maintainer to include the changes in the official
+            version of Tagbar without fee or restriction.
+          - You keep the changes for at least three years after last
+            distributing the corresponding modified Tagbar.  When the
+            maintainer or someone who you distributed the modified Tagbar to
+            asks you (in any way) for the changes within this period, you must
+            make them available to him.
+          - You clearly describe in the distribution how to contact you.  This
+            contact information must remain valid for at least three years
+            after last distributing the corresponding modified Tagbar, or as
+            long as possible.
+       e) When the GNU General Public License (GPL) applies to the changes,
+          you can distribute the modified Tagbar under the GNU GPL version 2
+          or any later version.
+    3) A message must be added, at least in the documentation, such that the
+       user of the modified Tagbar is able to see that it was modified.  When
+       distributing as mentioned under 2)e) adding the message is only
+       required for as far as this does not conflict with the license used for
+       the changes.
+    4) The contact information as required under 2)a) and 2)d) must not be
+       removed or changed, except that the person himself can make
+       corrections.
+
+III) If you distribute a modified version of Tagbar, you are encouraged to use
+     the Tagbar license for your changes and make them available to the
+     maintainer, including the source code.  The preferred way to do this is
+     by e-mail or by uploading the files to a server and e-mailing the URL. If
+     the number of changes is small (e.g., a modified Makefile) e-mailing a
+     context diff will do.  The e-mail address to be used is
+     <jan@majutsushi.net>
+
+IV)  It is not allowed to remove this license from the distribution of the
+     Tagbar sources, parts of it or from a modified version.  You may use this
+     license for previous Tagbar releases instead of the license that they
+     came with, at your option.
diff --git a/vim/.vim/bundle/tagbar/README.md b/vim/.vim/bundle/tagbar/README.md
new file mode 100644
index 0000000..eceddbe
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/README.md
@@ -0,0 +1,89 @@
+# Tagbar: a class outline viewer for Vim
+
+## What Tagbar is
+
+Tagbar is a Vim plugin that provides an easy way to browse the tags of the
+current file and get an overview of its structure. It does this by creating a
+sidebar that displays the ctags-generated tags of the current file, ordered by
+their scope. This means that for example methods in C++ are displayed under
+the class they are defined in.
+
+## What Tagbar is not
+
+Tagbar is not a general-purpose tool for managing `tags` files. It only
+creates the tags it needs on-the-fly in-memory without creating any files.
+`tags` file management is provided by other plugins, like for example
+[easytags](https://github.com/xolox/vim-easytags).
+
+## Dependencies
+
+[Vim 7.0](http://www.vim.org/) (But see note below)  
+[Exuberant ctags 5.5](http://ctags.sourceforge.net/)
+
+## Installation
+
+Extract the archive or clone the repository into a directory in your
+`'runtimepath'`, or use a plugin manager of your choice like
+[pathogen](https://github.com/tpope/vim-pathogen). Don't forget to run
+`:helptags` if your plugin manager doesn't do it for you so you can access the
+documentation with `:help tagbar`.
+
+Note: Vim versions < 7.0.167 have a bug that prevents Tagbar from working. If
+you are affected by this use this alternate Tagbar download instead:
+[zip](https://github.com/majutsushi/tagbar/zipball/70fix). It is on par with
+version 2.2 but probably won't be updated after that due to the amount of
+changes required.
+
+If the ctags executable is not installed in one of the directories in your
+`$PATH` environment variable you have to set the `g:tagbar_ctags_bin`
+variable, see the documentation for more info.
+
+## Quickstart
+
+Put something like the following into your ~/.vimrc:
+
+```vim
+nmap <F8> :TagbarToggle<CR>
+```
+
+If you do this the F8 key will toggle the Tagbar window. You can of course use
+any shortcut you want. For more flexible ways to open and close the window
+(and the rest of the functionality) see the documentation.
+
+## Support for additional filetypes
+
+For filetypes that are not supported by Exuberant Ctags check out [the
+wiki](https://github.com/majutsushi/tagbar/wiki) to see whether other projects
+offer support for them and how to use them. Please add any other
+projects/configurations that you find or create yourself so that others can
+benefit from them, too.
+
+## Note: If the file structure display is wrong
+
+If you notice that there are some errors in the way your file's structure is
+displayed in Tagbar, please make sure that the bug is actually in Tagbar
+before you report an issue. Since Tagbar uses
+[exuberant-ctags](http://ctags.sourceforge.net/) and compatible programs to do
+the actual file parsing, it is likely that the bug is actually in the program
+responsible for that filetype instead.
+
+There is an example in `:h tagbar-issues` about how to run ctags manually so
+you can determine where the bug actually is. If the bug is actually in ctags,
+please report it on their website instead, as there is nothing I can do about
+it in Tagbar. Thank you!
+
+You can also have a look at [ctags bugs that have previously been filed
+against Tagbar](https://github.com/majutsushi/tagbar/issues?labels=ctags-bug&page=1&state=closed).
+
+## Screenshots
+
+![screenshot1](https://i.imgur.com/Sf9Ls2r.png)
+![screenshot2](https://i.imgur.com/n4bpPv3.png)
+
+## License
+
+Vim license, see LICENSE
+
+## Maintainer
+
+Jan Larres <[jan@majutsushi.net](mailto:jan@majutsushi.net)>
diff --git a/vim/.vim/bundle/tagbar/autoload/tagbar.vim b/vim/.vim/bundle/tagbar/autoload/tagbar.vim
new file mode 100644
index 0000000..5b9d10b
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/autoload/tagbar.vim
@@ -0,0 +1,4370 @@
+" ============================================================================
+" File:        tagbar.vim
+" Description: List the current file's tags in a sidebar, ordered by class etc
+" Author:      Jan Larres <jan@majutsushi.net>
+" Licence:     Vim licence
+" Website:     http://majutsushi.github.com/tagbar/
+" Version:     2.6.1
+" Note:        This plugin was heavily inspired by the 'Taglist' plugin by
+"              Yegappan Lakshmanan and uses a small amount of code from it.
+"
+" Original taglist copyright notice:
+"              Permission is hereby granted to use and distribute this code,
+"              with or without modifications, provided that this copyright
+"              notice is copied with it. Like anything else that's free,
+"              taglist.vim is provided *as is* and comes with no warranty of
+"              any kind, either expressed or implied. In no event will the
+"              copyright holder be liable for any damamges resulting from the
+"              use of this software.
+" ============================================================================
+
+scriptencoding utf-8
+
+" Initialization {{{1
+
+" If another plugin calls an autoloaded Tagbar function on startup before the
+" plugin/tagbar.vim file got loaded, load it explicitly
+if exists(':Tagbar') == 0
+    runtime plugin/tagbar.vim
+endif
+
+if exists(':Tagbar') == 0
+    echomsg 'Tagbar: Could not load plugin code, check your runtimepath!'
+    finish
+endif
+
+" Basic init {{{2
+
+redir => s:ftype_out
+silent filetype
+redir END
+if s:ftype_out !~# 'detection:ON'
+    echomsg 'Tagbar: Filetype detection is turned off, skipping plugin'
+    unlet s:ftype_out
+    finish
+endif
+unlet s:ftype_out
+
+let s:icon_closed = g:tagbar_iconchars[0]
+let s:icon_open   = g:tagbar_iconchars[1]
+
+let s:type_init_done    = 0
+let s:autocommands_done = 0
+let s:statusline_in_use = 0
+
+" 0: not checked yet; 1: checked and found; 2: checked and not found
+let s:checked_ctags       = 0
+let s:checked_ctags_types = 0
+let s:ctags_is_uctags     = 0
+let s:ctags_types         = {}
+
+let s:new_window      = 1
+let s:is_maximized    = 0
+let s:winrestcmd      = ''
+let s:short_help      = 1
+let s:nearby_disabled = 0
+let s:paused = 0
+let s:pwin_by_tagbar = 0
+
+let s:window_expanded   = 0
+let s:expand_bufnr = -1
+let s:window_pos = {
+    \ 'pre'  : { 'x' : 0, 'y' : 0 },
+    \ 'post' : { 'x' : 0, 'y' : 0 }
+\}
+
+" Script-local variable needed since compare functions can't
+" take extra arguments
+let s:compare_typeinfo = {}
+
+let s:visibility_symbols = {
+    \ 'public'    : '+',
+    \ 'protected' : '#',
+    \ 'private'   : '-'
+\ }
+
+let g:loaded_tagbar = 1
+
+let s:last_highlight_tline = 0
+let s:debug = 0
+let s:debug_file = ''
+
+let s:warnings = {
+    \ 'type': [],
+    \ 'encoding': 0
+\ }
+
+" s:Init() {{{2
+function! s:Init(silent) abort
+    if s:checked_ctags == 2 && a:silent
+        return 0
+    elseif s:checked_ctags != 1
+        if !s:CheckForExCtags(a:silent)
+            return 0
+        endif
+    endif
+
+    if !s:checked_ctags_types
+        call s:GetSupportedFiletypes()
+    endif
+
+    if !s:type_init_done
+        call s:InitTypes()
+    endif
+
+    if !s:autocommands_done
+        call s:CreateAutocommands()
+        call s:AutoUpdate(fnamemodify(expand('%'), ':p'), 0)
+    endif
+
+    return 1
+endfunction
+
+" s:InitTypes() {{{2
+function! s:InitTypes() abort
+    call s:debug('Initializing types')
+
+    let s:known_types = {}
+
+    " Ant {{{3
+    let type_ant = s:TypeInfo.New()
+    let type_ant.ctagstype = 'ant'
+    let type_ant.kinds     = [
+        \ {'short' : 'p', 'long' : 'projects', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'targets',  'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.ant = type_ant
+    " Asm {{{3
+    let type_asm = s:TypeInfo.New()
+    let type_asm.ctagstype = 'asm'
+    let type_asm.kinds     = [
+        \ {'short' : 'm', 'long' : 'macros',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'types',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'd', 'long' : 'defines', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'l', 'long' : 'labels',  'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.asm = type_asm
+    " ASP {{{3
+    let type_aspvbs = s:TypeInfo.New()
+    let type_aspvbs.ctagstype = 'asp'
+    let type_aspvbs.kinds     = [
+        \ {'short' : 'd', 'long' : 'constants',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.aspvbs = type_aspvbs
+    " Asymptote {{{3
+    " Asymptote gets parsed well using filetype = c
+    let type_asy = s:TypeInfo.New()
+    let type_asy.ctagstype = 'c'
+    let type_asy.kinds     = [
+        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1, 'stl' : 0},
+        \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 's', 'long' : 'structs',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'u', 'long' : 'unions',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'members',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_asy.sro        = '::'
+    let type_asy.kind2scope = {
+        \ 'g' : 'enum',
+        \ 's' : 'struct',
+        \ 'u' : 'union'
+    \ }
+    let type_asy.scope2kind = {
+        \ 'enum'   : 'g',
+        \ 'struct' : 's',
+        \ 'union'  : 'u'
+    \ }
+    let s:known_types.asy = type_asy
+    " Awk {{{3
+    let type_awk = s:TypeInfo.New()
+    let type_awk.ctagstype = 'awk'
+    let type_awk.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.awk = type_awk
+    " Basic {{{3
+    let type_basic = s:TypeInfo.New()
+    let type_basic.ctagstype = 'basic'
+    let type_basic.kinds     = [
+        \ {'short' : 'c', 'long' : 'constants',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'g', 'long' : 'enumerations', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'l', 'long' : 'labels',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'types',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',    'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.basic = type_basic
+    " BETA {{{3
+    let type_beta = s:TypeInfo.New()
+    let type_beta.ctagstype = 'beta'
+    let type_beta.kinds     = [
+        \ {'short' : 'f', 'long' : 'fragments', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'slots',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'patterns',  'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.beta = type_beta
+    " C {{{3
+    let type_c = s:TypeInfo.New()
+    let type_c.ctagstype = 'c'
+    let type_c.kinds     = [
+        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1, 'stl' : 0},
+        \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 's', 'long' : 'structs',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'u', 'long' : 'unions',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'members',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_c.sro        = '::'
+    let type_c.kind2scope = {
+        \ 'g' : 'enum',
+        \ 's' : 'struct',
+        \ 'u' : 'union'
+    \ }
+    let type_c.scope2kind = {
+        \ 'enum'   : 'g',
+        \ 'struct' : 's',
+        \ 'union'  : 'u'
+    \ }
+    let s:known_types.c = type_c
+    " C++ {{{3
+    let type_cpp = s:TypeInfo.New()
+    let type_cpp.ctagstype = 'c++'
+    let type_cpp.kinds     = [
+        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1, 'stl' : 0},
+        \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 'n', 'long' : 'namespaces',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'structs',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'u', 'long' : 'unions',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'members',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_cpp.sro        = '::'
+    let type_cpp.kind2scope = {
+        \ 'g' : 'enum',
+        \ 'n' : 'namespace',
+        \ 'c' : 'class',
+        \ 's' : 'struct',
+        \ 'u' : 'union'
+    \ }
+    let type_cpp.scope2kind = {
+        \ 'enum'      : 'g',
+        \ 'namespace' : 'n',
+        \ 'class'     : 'c',
+        \ 'struct'    : 's',
+        \ 'union'     : 'u'
+    \ }
+    let s:known_types.cpp = type_cpp
+    let s:known_types.cuda = type_cpp
+    " C# {{{3
+    let type_cs = s:TypeInfo.New()
+    let type_cs.ctagstype = 'c#'
+    let type_cs.kinds     = [
+        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'fields',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'n', 'long' : 'namespaces',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'i', 'long' : 'interfaces',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'structs',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'E', 'long' : 'events',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'methods',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'properties',  'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_cs.sro        = '.'
+    let type_cs.kind2scope = {
+        \ 'n' : 'namespace',
+        \ 'i' : 'interface',
+        \ 'c' : 'class',
+        \ 's' : 'struct',
+        \ 'g' : 'enum'
+    \ }
+    let type_cs.scope2kind = {
+        \ 'namespace' : 'n',
+        \ 'interface' : 'i',
+        \ 'class'     : 'c',
+        \ 'struct'    : 's',
+        \ 'enum'      : 'g'
+    \ }
+    let s:known_types.cs = type_cs
+    " COBOL {{{3
+    let type_cobol = s:TypeInfo.New()
+    let type_cobol.ctagstype = 'cobol'
+    let type_cobol.kinds     = [
+        \ {'short' : 'd', 'long' : 'data items',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'file descriptions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'g', 'long' : 'group items',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'paragraphs',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'P', 'long' : 'program ids',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'sections',          'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.cobol = type_cobol
+    " DOS Batch {{{3
+    let type_dosbatch = s:TypeInfo.New()
+    let type_dosbatch.ctagstype = 'dosbatch'
+    let type_dosbatch.kinds     = [
+        \ {'short' : 'l', 'long' : 'labels',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.dosbatch = type_dosbatch
+    " Eiffel {{{3
+    let type_eiffel = s:TypeInfo.New()
+    let type_eiffel.ctagstype = 'eiffel'
+    let type_eiffel.kinds     = [
+        \ {'short' : 'c', 'long' : 'classes',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'features', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_eiffel.sro        = '.' " Not sure, is nesting even possible?
+    let type_eiffel.kind2scope = {
+        \ 'c' : 'class',
+        \ 'f' : 'feature'
+    \ }
+    let type_eiffel.scope2kind = {
+        \ 'class'   : 'c',
+        \ 'feature' : 'f'
+    \ }
+    let s:known_types.eiffel = type_eiffel
+    " Erlang {{{3
+    let type_erlang = s:TypeInfo.New()
+    let type_erlang.ctagstype = 'erlang'
+    let type_erlang.kinds     = [
+        \ {'short' : 'm', 'long' : 'modules',            'fold' : 0, 'stl' : 1},
+        \ {'short' : 'd', 'long' : 'macro definitions',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'r', 'long' : 'record definitions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_erlang.sro        = '.' " Not sure, is nesting even possible?
+    let type_erlang.kind2scope = {
+        \ 'm' : 'module'
+    \ }
+    let type_erlang.scope2kind = {
+        \ 'module' : 'm'
+    \ }
+    let s:known_types.erlang = type_erlang
+    " Flex {{{3
+    " Vim doesn't support Flex out of the box, this is based on rough
+    " guesses and probably requires
+    " http://www.vim.org/scripts/script.php?script_id=2909
+    " Improvements welcome!
+    let type_as = s:TypeInfo.New()
+    let type_as.ctagstype = 'flex'
+    let type_as.kinds     = [
+        \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'methods',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'properties',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'x', 'long' : 'mxtags',           'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_as.sro        = '.'
+    let type_as.kind2scope = {
+        \ 'c' : 'class'
+    \ }
+    let type_as.scope2kind = {
+        \ 'class' : 'c'
+    \ }
+    let s:known_types.mxml = type_as
+    let s:known_types.actionscript = type_as
+    " Fortran {{{3
+    let type_fortran = s:TypeInfo.New()
+    let type_fortran.ctagstype = 'fortran'
+    let type_fortran.kinds     = [
+        \ {'short' : 'm', 'long' : 'modules',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'programs',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'k', 'long' : 'components', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'derived types and structures', 'fold' : 0,
+         \ 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'common blocks', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'b', 'long' : 'block data',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 'e', 'long' : 'entry points',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'subroutines',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'l', 'long' : 'labels',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'n', 'long' : 'namelists',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',     'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_fortran.sro        = '.' " Not sure, is nesting even possible?
+    let type_fortran.kind2scope = {
+        \ 'm' : 'module',
+        \ 'p' : 'program',
+        \ 'f' : 'function',
+        \ 's' : 'subroutine'
+    \ }
+    let type_fortran.scope2kind = {
+        \ 'module'     : 'm',
+        \ 'program'    : 'p',
+        \ 'function'   : 'f',
+        \ 'subroutine' : 's'
+    \ }
+    let s:known_types.fortran = type_fortran
+    " HTML {{{3
+    let type_html = s:TypeInfo.New()
+    let type_html.ctagstype = 'html'
+    let type_html.kinds     = [
+        \ {'short' : 'f', 'long' : 'JavaScript funtions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'a', 'long' : 'named anchors',       'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.html = type_html
+    " Java {{{3
+    let type_java = s:TypeInfo.New()
+    let type_java.ctagstype = 'java'
+    let type_java.kinds     = [
+        \ {'short' : 'p', 'long' : 'packages',       'fold' : 1, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'fields',         'fold' : 0, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'enum types',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enum constants', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'i', 'long' : 'interfaces',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'methods',        'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_java.sro        = '.'
+    let type_java.kind2scope = {
+        \ 'g' : 'enum',
+        \ 'i' : 'interface',
+        \ 'c' : 'class'
+    \ }
+    let type_java.scope2kind = {
+        \ 'enum'      : 'g',
+        \ 'interface' : 'i',
+        \ 'class'     : 'c'
+    \ }
+    let s:known_types.java = type_java
+    " JavaScript {{{3
+    " jsctags/doctorjs will be used if available.
+    let type_javascript = s:TypeInfo.New()
+    let type_javascript.ctagstype = 'javascript'
+    let jsctags = s:CheckFTCtags('jsctags', 'javascript')
+    if jsctags != ''
+        let type_javascript.kinds = [
+            \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0},
+            \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+        \ ]
+        let type_javascript.sro        = '.'
+        let type_javascript.kind2scope = {
+            \ 'v' : 'namespace',
+            \ 'f' : 'namespace'
+        \ }
+        let type_javascript.scope2kind = {
+            \ 'namespace' : 'v'
+        \ }
+        let type_javascript.ctagsbin   = jsctags
+        let type_javascript.ctagsargs  = '-f -'
+    else
+        let type_javascript.kinds = [
+            \ {'short': 'v', 'long': 'global variables', 'fold': 0, 'stl': 0},
+            \ {'short': 'c', 'long': 'classes',          'fold': 0, 'stl': 1},
+            \ {'short': 'p', 'long': 'properties',       'fold': 0, 'stl': 0},
+            \ {'short': 'm', 'long': 'methods',          'fold': 0, 'stl': 1},
+            \ {'short': 'f', 'long': 'functions',        'fold': 0, 'stl': 1},
+        \ ]
+        let type_javascript.sro        = '.'
+        let type_javascript.kind2scope = {
+            \ 'c' : 'class',
+            \ 'f' : 'function',
+            \ 'm' : 'method',
+            \ 'p' : 'property',
+        \ }
+        let type_javascript.scope2kind = {
+            \ 'class'    : 'c',
+            \ 'function' : 'f',
+        \ }
+    endif
+    let s:known_types.javascript = type_javascript
+    " Lisp {{{3
+    let type_lisp = s:TypeInfo.New()
+    let type_lisp.ctagstype = 'lisp'
+    let type_lisp.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.lisp = type_lisp
+    let s:known_types.clojure = type_lisp
+    " Lua {{{3
+    let type_lua = s:TypeInfo.New()
+    let type_lua.ctagstype = 'lua'
+    let type_lua.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.lua = type_lua
+    " Make {{{3
+    let type_make = s:TypeInfo.New()
+    let type_make.ctagstype = 'make'
+    let type_make.kinds     = [
+        \ {'short' : 'm', 'long' : 'macros', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.make = type_make
+    " Matlab {{{3
+    let type_matlab = s:TypeInfo.New()
+    let type_matlab.ctagstype = 'matlab'
+    let type_matlab.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.matlab = type_matlab
+    " Ocaml {{{3
+    let type_ocaml = s:TypeInfo.New()
+    let type_ocaml.ctagstype = 'ocaml'
+    let type_ocaml.kinds     = [
+        \ {'short' : 'M', 'long' : 'modules or functors', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'global variables',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 'C', 'long' : 'constructors',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'methods',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'exceptions',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'type names',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'r', 'long' : 'structure fields',    'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_ocaml.sro        = '.' " Not sure, is nesting even possible?
+    let type_ocaml.kind2scope = {
+        \ 'M' : 'Module',
+        \ 'c' : 'class',
+        \ 't' : 'type'
+    \ }
+    let type_ocaml.scope2kind = {
+        \ 'Module' : 'M',
+        \ 'class'  : 'c',
+        \ 'type'   : 't'
+    \ }
+    let s:known_types.ocaml = type_ocaml
+    " Pascal {{{3
+    let type_pascal = s:TypeInfo.New()
+    let type_pascal.ctagstype = 'pascal'
+    let type_pascal.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.pascal = type_pascal
+    " Perl {{{3
+    let type_perl = s:TypeInfo.New()
+    let type_perl.ctagstype = 'perl'
+    let type_perl.kinds     = [
+        \ {'short' : 'p', 'long' : 'packages',    'fold' : 1, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'constants',   'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'formats',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'l', 'long' : 'labels',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.perl = type_perl
+    " PHP {{{3
+    let type_php = s:TypeInfo.New()
+    let type_php.ctagstype = 'php'
+    let type_php.kinds     = [
+        \ {'short' : 'i', 'long' : 'interfaces',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'd', 'long' : 'constant definitions', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',            'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',            'fold' : 0, 'stl' : 0},
+        \ {'short' : 'j', 'long' : 'javascript functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.php = type_php
+    " Python {{{3
+    let type_python = s:TypeInfo.New()
+    let type_python.ctagstype = 'python'
+    let type_python.kinds     = [
+        \ {'short' : 'i', 'long' : 'imports',   'fold' : 1, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'members',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_python.sro        = '.'
+    let type_python.kind2scope = {
+        \ 'c' : 'class',
+        \ 'f' : 'function',
+        \ 'm' : 'function'
+    \ }
+    let type_python.scope2kind = {
+        \ 'class'    : 'c',
+        \ 'function' : 'f'
+    \ }
+    if s:ctags_is_uctags
+        " Universal Ctags treats member functions differently from normal
+        " functions
+        let type_python.kind2scope.m = 'member'
+        let type_python.scope2kind.member = 'm'
+    endif
+    let s:known_types.python = type_python
+    let s:known_types.pyrex  = type_python
+    let s:known_types.cython = type_python
+    " REXX {{{3
+    let type_rexx = s:TypeInfo.New()
+    let type_rexx.ctagstype = 'rexx'
+    let type_rexx.kinds     = [
+        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.rexx = type_rexx
+    " Ruby {{{3
+    let type_ruby = s:TypeInfo.New()
+    let type_ruby.ctagstype = 'ruby'
+    let type_ruby.kinds     = [
+        \ {'short' : 'm', 'long' : 'modules',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'methods',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'F', 'long' : 'singleton methods', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_ruby.sro        = '.'
+    let type_ruby.kind2scope = {
+        \ 'c' : 'class',
+        \ 'm' : 'class'
+    \ }
+    let type_ruby.scope2kind = {
+        \ 'class' : 'c'
+    \ }
+    let s:known_types.ruby = type_ruby
+    " Scheme {{{3
+    let type_scheme = s:TypeInfo.New()
+    let type_scheme.ctagstype = 'scheme'
+    let type_scheme.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'sets',      'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.scheme = type_scheme
+    let s:known_types.racket = type_scheme
+    " Shell script {{{3
+    let type_sh = s:TypeInfo.New()
+    let type_sh.ctagstype = 'sh'
+    let type_sh.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.sh = type_sh
+    let s:known_types.csh = type_sh
+    let s:known_types.zsh = type_sh
+    " SLang {{{3
+    let type_slang = s:TypeInfo.New()
+    let type_slang.ctagstype = 'slang'
+    let type_slang.kinds     = [
+        \ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',  'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.slang = type_slang
+    " SML {{{3
+    let type_sml = s:TypeInfo.New()
+    let type_sml.ctagstype = 'sml'
+    let type_sml.kinds     = [
+        \ {'short' : 'e', 'long' : 'exception declarations', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'function definitions',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'functor definitions',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'signature declarations', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'r', 'long' : 'structure declarations', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'type definitions',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'value bindings',         'fold' : 0, 'stl' : 0}
+    \ ]
+    let s:known_types.sml = type_sml
+    " SQL {{{3
+    " The SQL ctags parser seems to be buggy for me, so this just uses the
+    " normal kinds even though scopes should be available. Improvements
+    " welcome!
+    let type_sql = s:TypeInfo.New()
+    let type_sql.ctagstype = 'sql'
+    let type_sql.kinds     = [
+        \ {'short' : 'P', 'long' : 'packages',               'fold' : 1, 'stl' : 1},
+        \ {'short' : 'd', 'long' : 'prototypes',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'cursors',                'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'F', 'long' : 'record fields',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'L', 'long' : 'block label',            'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'procedures',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'subtypes',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'tables',                 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'T', 'long' : 'triggers',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'i', 'long' : 'indexes',                'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'events',                 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'U', 'long' : 'publications',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'R', 'long' : 'services',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 'D', 'long' : 'domains',                'fold' : 0, 'stl' : 1},
+        \ {'short' : 'V', 'long' : 'views',                  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'n', 'long' : 'synonyms',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 'x', 'long' : 'MobiLink Table Scripts', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'y', 'long' : 'MobiLink Conn Scripts',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'z', 'long' : 'MobiLink Properties',    'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.sql = type_sql
+    " Tcl {{{3
+    let type_tcl = s:TypeInfo.New()
+    let type_tcl.ctagstype = 'tcl'
+    let type_tcl.kinds     = [
+        \ {'short' : 'c', 'long' : 'classes',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'methods',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.tcl = type_tcl
+    " LaTeX {{{3
+    let type_tex = s:TypeInfo.New()
+    let type_tex.ctagstype = 'tex'
+    let type_tex.kinds     = [
+        \ {'short' : 'i', 'long' : 'includes',       'fold' : 1, 'stl' : 0},
+        \ {'short' : 'p', 'long' : 'parts',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'chapters',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'sections',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'u', 'long' : 'subsections',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'b', 'long' : 'subsubsections', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'P', 'long' : 'paragraphs',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'G', 'long' : 'subparagraphs',  'fold' : 0, 'stl' : 0},
+        \ {'short' : 'l', 'long' : 'labels',         'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_tex.sro        = '""'
+    let type_tex.kind2scope = {
+        \ 'p' : 'part',
+        \ 'c' : 'chapter',
+        \ 's' : 'section',
+        \ 'u' : 'subsection',
+        \ 'b' : 'subsubsection'
+    \ }
+    let type_tex.scope2kind = {
+        \ 'part'          : 'p',
+        \ 'chapter'       : 'c',
+        \ 'section'       : 's',
+        \ 'subsection'    : 'u',
+        \ 'subsubsection' : 'b'
+    \ }
+    let type_tex.sort = 0
+    let s:known_types.tex = type_tex
+    " Vala {{{3
+    " Vala is supported by the ctags fork provided by Anjuta, so only add the
+    " type if the fork is used to prevent error messages otherwise
+    if has_key(s:ctags_types, 'vala') || executable('anjuta-tags')
+        let type_vala = s:TypeInfo.New()
+        let type_vala.ctagstype = 'vala'
+        let type_vala.kinds     = [
+            \ {'short' : 'e', 'long' : 'Enumerations',       'fold' : 0, 'stl' : 1},
+            \ {'short' : 'v', 'long' : 'Enumeration values', 'fold' : 0, 'stl' : 0},
+            \ {'short' : 's', 'long' : 'Structures',         'fold' : 0, 'stl' : 1},
+            \ {'short' : 'i', 'long' : 'Interfaces',         'fold' : 0, 'stl' : 1},
+            \ {'short' : 'd', 'long' : 'Delegates',          'fold' : 0, 'stl' : 1},
+            \ {'short' : 'c', 'long' : 'Classes',            'fold' : 0, 'stl' : 1},
+            \ {'short' : 'p', 'long' : 'Properties',         'fold' : 0, 'stl' : 0},
+            \ {'short' : 'f', 'long' : 'Fields',             'fold' : 0, 'stl' : 0},
+            \ {'short' : 'm', 'long' : 'Methods',            'fold' : 0, 'stl' : 1},
+            \ {'short' : 'E', 'long' : 'Error domains',      'fold' : 0, 'stl' : 1},
+            \ {'short' : 'r', 'long' : 'Error codes',        'fold' : 0, 'stl' : 1},
+            \ {'short' : 'S', 'long' : 'Signals',            'fold' : 0, 'stl' : 1}
+        \ ]
+        let type_vala.sro = '.'
+        " 'enum' doesn't seem to be used as a scope, but it can't hurt to have
+        " it here
+        let type_vala.kind2scope = {
+            \ 's' : 'struct',
+            \ 'i' : 'interface',
+            \ 'c' : 'class',
+            \ 'e' : 'enum'
+        \ }
+        let type_vala.scope2kind = {
+            \ 'struct'    : 's',
+            \ 'interface' : 'i',
+            \ 'class'     : 'c',
+            \ 'enum'      : 'e'
+        \ }
+        let s:known_types.vala = type_vala
+    endif
+    if !has_key(s:ctags_types, 'vala') && executable('anjuta-tags')
+        let s:known_types.vala.ctagsbin = 'anjuta-tags'
+    endif
+    " Vera {{{3
+    " Why are variables 'virtual'?
+    let type_vera = s:TypeInfo.New()
+    let type_vera.ctagstype = 'vera'
+    let type_vera.kinds     = [
+        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'T', 'long' : 'typedefs',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'm', 'long' : 'members',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'tasks',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0, 'stl' : 0},
+        \ {'short' : 'p', 'long' : 'programs',    'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_vera.sro        = '.' " Nesting doesn't seem to be possible
+    let type_vera.kind2scope = {
+        \ 'g' : 'enum',
+        \ 'c' : 'class',
+        \ 'v' : 'virtual'
+    \ }
+    let type_vera.scope2kind = {
+        \ 'enum'      : 'g',
+        \ 'class'     : 'c',
+        \ 'virtual'   : 'v'
+    \ }
+    let s:known_types.vera = type_vera
+    " Verilog {{{3
+    let type_verilog = s:TypeInfo.New()
+    let type_verilog.ctagstype = 'verilog'
+    let type_verilog.kinds     = [
+        \ {'short' : 'c', 'long' : 'constants',           'fold' : 0, 'stl' : 0},
+        \ {'short' : 'e', 'long' : 'events',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'modules',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 'n', 'long' : 'net data types',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'ports',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 'r', 'long' : 'register data types', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'tasks',               'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.verilog = type_verilog
+    " VHDL {{{3
+    " The VHDL ctags parser unfortunately doesn't generate proper scopes
+    let type_vhdl = s:TypeInfo.New()
+    let type_vhdl.ctagstype = 'vhdl'
+    let type_vhdl.kinds     = [
+        \ {'short' : 'P', 'long' : 'packages',   'fold' : 1, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'constants',  'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'types',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'T', 'long' : 'subtypes',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'r', 'long' : 'records',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'entities',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.vhdl = type_vhdl
+    " Vim {{{3
+    let type_vim = s:TypeInfo.New()
+    let type_vim.ctagstype = 'vim'
+    let type_vim.kinds     = [
+        \ {'short' : 'n', 'long' : 'vimball filenames',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',          'fold' : 1, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'a', 'long' : 'autocommand groups', 'fold' : 1, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'commands',           'fold' : 0, 'stl' : 0},
+        \ {'short' : 'm', 'long' : 'maps',               'fold' : 1, 'stl' : 0}
+    \ ]
+    let s:known_types.vim = type_vim
+    " YACC {{{3
+    let type_yacc = s:TypeInfo.New()
+    let type_yacc.ctagstype = 'yacc'
+    let type_yacc.kinds     = [
+        \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let s:known_types.yacc = type_yacc
+    " }}}3
+
+    for [type, typeinfo] in items(s:known_types)
+        let typeinfo.ftype = type
+    endfor
+
+    call s:LoadUserTypeDefs()
+
+    for typeinfo in values(s:known_types)
+        call typeinfo.createKinddict()
+    endfor
+
+    let s:type_init_done = 1
+endfunction
+
+" s:LoadUserTypeDefs() {{{2
+function! s:LoadUserTypeDefs(...) abort
+    if a:0 > 0
+        let type = a:1
+
+        call s:debug("Initializing user type '" . type . "'")
+
+        let defdict = {}
+        let defdict[type] = g:tagbar_type_{type}
+    else
+        call s:debug('Initializing user types')
+
+        let defdict = tagbar#getusertypes()
+    endif
+
+    let transformed = {}
+    for [type, def] in items(defdict)
+        let transformed[type] = s:TransformUserTypeDef(def)
+        let transformed[type].ftype = type
+    endfor
+
+    for [key, value] in items(transformed)
+        if !has_key(s:known_types, key) || get(value, 'replace', 0)
+            let s:known_types[key] = s:TypeInfo.New(value)
+        else
+            call extend(s:known_types[key], value)
+        endif
+    endfor
+
+    if a:0 > 0
+        call s:known_types[type].createKinddict()
+    endif
+endfunction
+
+" s:TransformUserTypeDef() {{{2
+" Transform the user definitions into the internal format
+function! s:TransformUserTypeDef(def) abort
+    let newdef = copy(a:def)
+
+    if has_key(a:def, 'kinds')
+        let newdef.kinds = []
+        let kinds = a:def.kinds
+        for kind in kinds
+            let kindlist = split(kind, ':')
+            let kinddict = {'short' : kindlist[0], 'long' : kindlist[1]}
+            let kinddict.fold = get(kindlist, 2, 0)
+            let kinddict.stl  = get(kindlist, 3, 1)
+            call add(newdef.kinds, kinddict)
+        endfor
+    endif
+
+    " If the user only specified one of kind2scope and scope2kind then use it
+    " to generate the respective other
+    if has_key(a:def, 'kind2scope') && !has_key(a:def, 'scope2kind')
+        let newdef.scope2kind = {}
+        for [key, value] in items(a:def.kind2scope)
+            let newdef.scope2kind[value] = key
+        endfor
+    elseif has_key(a:def, 'scope2kind') && !has_key(a:def, 'kind2scope')
+        let newdef.kind2scope = {}
+        for [key, value] in items(a:def.scope2kind)
+            let newdef.kind2scope[value] = key
+        endfor
+    endif
+
+    return newdef
+endfunction
+
+" s:RestoreSession() {{{2
+" Properly restore Tagbar after a session got loaded
+function! s:RestoreSession() abort
+    call s:debug('Restoring session')
+
+    let curfile = fnamemodify(bufname('%'), ':p')
+
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr == -1
+        " Tagbar wasn't open in the saved session, nothing to do
+        return
+    else
+        let in_tagbar = 1
+        if winnr() != tagbarwinnr
+            call s:goto_win(tagbarwinnr)
+            let in_tagbar = 0
+        endif
+    endif
+
+    let s:last_autofocus = 0
+
+    call s:Init(0)
+
+    call s:InitWindow(g:tagbar_autoclose)
+
+    call s:AutoUpdate(curfile, 0)
+
+    if !in_tagbar
+        call s:goto_win('p')
+    endif
+endfunction
+
+" s:MapKeys() {{{2
+function! s:MapKeys() abort
+    call s:debug('Mapping keys')
+
+    nnoremap <script> <silent> <buffer> <2-LeftMouse>
+                                              \ :call <SID>JumpToTag(0)<CR>
+    nnoremap <script> <silent> <buffer> <LeftRelease>
+                                 \ <LeftRelease>:call <SID>CheckMouseClick()<CR>
+
+    inoremap <script> <silent> <buffer> <2-LeftMouse>
+                                              \ <C-o>:call <SID>JumpToTag(0)<CR>
+    inoremap <script> <silent> <buffer> <LeftRelease>
+                            \ <LeftRelease><C-o>:call <SID>CheckMouseClick()<CR>
+
+    let maps = [
+        \ ['jump',          'JumpToTag(0)'],
+        \ ['preview',       'JumpToTag(1)'],
+        \ ['previewwin',    'ShowInPreviewWin()'],
+        \ ['nexttag',       'GotoNextToplevelTag(1)'],
+        \ ['prevtag',       'GotoNextToplevelTag(-1)'],
+        \ ['showproto',     'ShowPrototype(0)'],
+        \ ['hidenonpublic', 'ToggleHideNonPublicTags()'],
+        \
+        \ ['openfold',      'OpenFold()'],
+        \ ['closefold',     'CloseFold()'],
+        \ ['togglefold',    'ToggleFold()'],
+        \ ['openallfolds',  'SetFoldLevel(99, 1)'],
+        \ ['closeallfolds', 'SetFoldLevel(0, 1)'],
+        \ ['nextfold',      'GotoNextFold()'],
+        \ ['prevfold',      'GotoPrevFold()'],
+        \
+        \ ['togglesort',            'ToggleSort()'],
+        \ ['togglecaseinsensitive', 'ToggleCaseInsensitive()'],
+        \ ['toggleautoclose',       'ToggleAutoclose()'],
+        \ ['zoomwin',               'ZoomWindow()'],
+        \ ['close',                 'CloseWindow()'],
+        \ ['help',                  'ToggleHelp()'],
+    \ ]
+
+    for [map, func] in maps
+        let def = get(g:, 'tagbar_map_' . map)
+        if type(def) == type("")
+            let keys = [def]
+        else
+            let keys = def
+        endif
+        for key in keys
+            execute 'nnoremap <script> <silent> <buffer> ' . key .
+                        \ ' :call <SID>' . func . '<CR>'
+        endfor
+        unlet def
+    endfor
+
+    let b:tagbar_mapped_keys = 1
+endfunction
+
+" s:CreateAutocommands() {{{2
+function! s:CreateAutocommands() abort
+    call s:debug('Creating autocommands')
+
+    augroup TagbarAutoCmds
+        autocmd!
+        autocmd CursorHold __Tagbar__ call s:ShowPrototype(1)
+        autocmd WinEnter   __Tagbar__ call s:SetStatusLine()
+        autocmd WinLeave   __Tagbar__ call s:SetStatusLine()
+
+        if g:tagbar_autopreview
+            autocmd CursorMoved __Tagbar__ nested call s:ShowInPreviewWin()
+        endif
+
+        autocmd WinEnter * nested call s:QuitIfOnlyWindow()
+        autocmd WinEnter * if bufwinnr('__Tagbar__') == -1 |
+                         \     call s:ShrinkIfExpanded() |
+                         \ endif
+
+        autocmd BufWritePost * call
+                    \ s:AutoUpdate(fnamemodify(expand('<afile>'), ':p'), 1)
+        " BufReadPost is needed for reloading the current buffer if the file
+        " was changed by an external command; see commit 17d199f
+        autocmd BufReadPost,BufEnter,CursorHold,FileType * call
+                    \ s:AutoUpdate(fnamemodify(expand('<afile>'), ':p'), 0)
+        autocmd BufDelete,BufWipeout * call
+                    \ s:known_files.rm(fnamemodify(expand('<afile>'), ':p'))
+
+        autocmd QuickFixCmdPre  * let s:tagbar_qf_active = 1
+        autocmd QuickFixCmdPost * if exists('s:tagbar_qf_active') |
+                                \     unlet s:tagbar_qf_active |
+                                \ endif
+
+        autocmd VimEnter * call s:CorrectFocusOnStartup()
+    augroup END
+
+    let s:autocommands_done = 1
+endfunction
+
+" s:CheckForExCtags() {{{2
+" Test whether the ctags binary is actually Exuberant Ctags and not BSD ctags
+" (or something else)
+function! s:CheckForExCtags(silent) abort
+    call s:debug('Checking for Exuberant Ctags')
+
+    if !exists('g:tagbar_ctags_bin')
+        let ctagsbins  = []
+        let ctagsbins += ['ctags-exuberant'] " Debian
+        let ctagsbins += ['exuberant-ctags']
+        let ctagsbins += ['exctags'] " FreeBSD, NetBSD
+        let ctagsbins += ['/usr/local/bin/ctags'] " Homebrew
+        let ctagsbins += ['/opt/local/bin/ctags'] " Macports
+        let ctagsbins += ['ectags'] " OpenBSD
+        let ctagsbins += ['ctags']
+        let ctagsbins += ['ctags.exe']
+        let ctagsbins += ['tags']
+        for ctags in ctagsbins
+            if executable(ctags)
+                let g:tagbar_ctags_bin = ctags
+                break
+            endif
+        endfor
+        if !exists('g:tagbar_ctags_bin')
+            let errmsg = 'Tagbar: Exuberant ctags not found!'
+            let infomsg = 'Please download Exuberant Ctags from' .
+                        \ ' ctags.sourceforge.net and install it in a' .
+                        \ ' directory in your $PATH or set g:tagbar_ctags_bin.'
+            call s:CtagsErrMsg(errmsg, infomsg, a:silent)
+            let s:checked_ctags = 2
+            return 0
+        endif
+    else
+        " reset 'wildignore' temporarily in case *.exe is included in it
+        let wildignore_save = &wildignore
+        set wildignore&
+
+        let g:tagbar_ctags_bin = expand(g:tagbar_ctags_bin)
+
+        let &wildignore = wildignore_save
+
+        if !executable(g:tagbar_ctags_bin)
+            let errmsg = "Tagbar: Exuberant ctags not found at " .
+                       \ "'" . g:tagbar_ctags_bin . "'!"
+            let infomsg = 'Please check your g:tagbar_ctags_bin setting.'
+            call s:CtagsErrMsg(errmsg, infomsg, a:silent)
+            let s:checked_ctags = 2
+            return 0
+        endif
+    endif
+
+    let ctags_cmd = s:EscapeCtagsCmd(g:tagbar_ctags_bin, '--version')
+    if ctags_cmd == ''
+        let s:checked_ctags = 2
+        return 0
+    endif
+
+    let ctags_output = s:ExecuteCtags(ctags_cmd)
+
+    if v:shell_error || ctags_output !~# '\(Exuberant\|Universal\) Ctags'
+        let errmsg = 'Tagbar: Ctags doesn''t seem to be Exuberant Ctags!'
+        let infomsg = 'BSD ctags will NOT WORK.' .
+            \ ' Please download Exuberant Ctags from ctags.sourceforge.net' .
+            \ ' and install it in a directory in your $PATH' .
+            \ ' or set g:tagbar_ctags_bin.'
+        call s:CtagsErrMsg(errmsg, infomsg, a:silent, ctags_cmd, ctags_output)
+        let s:checked_ctags = 2
+        return 0
+    elseif !s:CheckExCtagsVersion(ctags_output)
+        let errmsg = 'Tagbar: Exuberant Ctags is too old!'
+        let infomsg = 'You need at least version 5.5 for Tagbar to work.' .
+            \ ' Please download a newer version from ctags.sourceforge.net.'
+        call s:CtagsErrMsg(errmsg, infomsg, a:silent, ctags_cmd, ctags_output)
+        let s:checked_ctags = 2
+        return 0
+    else
+        let s:checked_ctags = 1
+        return 1
+    endif
+endfunction
+
+" s:CtagsErrMsg() {{{2
+function! s:CtagsErrMsg(errmsg, infomsg, silent, ...) abort
+    call s:debug(a:errmsg)
+    let ctags_cmd    = a:0 > 0 ? a:1 : ''
+    let ctags_output = a:0 > 0 ? a:2 : ''
+
+    if ctags_output != ''
+        call s:debug("Command output:\n" . ctags_output)
+    endif
+
+    if !a:silent
+        call s:warning(a:errmsg)
+        echomsg a:infomsg
+
+        if ctags_cmd == ''
+            return
+        endif
+
+        echomsg 'Executed command: "' . ctags_cmd . '"'
+        if ctags_output != ''
+            echomsg 'Command output:'
+            for line in split(ctags_output, '\n')
+                echomsg line
+            endfor
+        else
+            echomsg 'Command output is empty.'
+        endif
+    endif
+endfunction
+
+
+" s:CheckExCtagsVersion() {{{2
+function! s:CheckExCtagsVersion(output) abort
+    call s:debug('Checking Exuberant Ctags version')
+
+    if a:output =~ 'Universal Ctags'
+        call s:debug("Found Universal Ctags, assuming compatibility")
+        let s:ctags_is_uctags = 1
+        return 1
+    endif
+
+    if a:output =~ 'Exuberant Ctags Development'
+        call s:debug("Found development version, assuming compatibility")
+        return 1
+    endif
+
+    let matchlist = matchlist(a:output, '\vExuberant Ctags (\d+)\.(\d+)')
+    let major     = matchlist[1]
+    let minor     = matchlist[2]
+
+    call s:debug("Ctags version: major='" . major . "', minor='" . minor . "'")
+
+    return major >= 6 || (major == 5 && minor >= 5)
+endfunction
+
+" s:CheckFTCtags() {{{2
+function! s:CheckFTCtags(bin, ftype) abort
+    if executable(a:bin)
+        return a:bin
+    endif
+
+    if exists('g:tagbar_type_' . a:ftype)
+        let userdef = g:tagbar_type_{a:ftype}
+        if has_key(userdef, 'ctagsbin')
+            return userdef.ctagsbin
+        else
+            return ''
+        endif
+    endif
+
+    return ''
+endfunction
+
+" s:GetSupportedFiletypes() {{{2
+function! s:GetSupportedFiletypes() abort
+    call s:debug('Getting filetypes sypported by Exuberant Ctags')
+
+    let ctags_cmd = s:EscapeCtagsCmd(g:tagbar_ctags_bin, '--list-languages')
+    if ctags_cmd == ''
+        return
+    endif
+
+    let ctags_output = s:ExecuteCtags(ctags_cmd)
+
+    if v:shell_error
+        " this shouldn't happen as potential problems would have already been
+        " caught by the previous ctags checking
+        return
+    endif
+
+    let types = split(ctags_output, '\n\+')
+
+    for type in types
+        let s:ctags_types[tolower(type)] = 1
+    endfor
+
+    let s:checked_ctags_types = 1
+endfunction
+
+" Prototypes {{{1
+" Base tag {{{2
+let s:BaseTag = {}
+
+" s:BaseTag.New() {{{3
+function! s:BaseTag.New(name) abort dict
+    let newobj = copy(self)
+
+    call newobj._init(a:name)
+
+    return newobj
+endfunction
+
+" s:BaseTag._init() {{{3
+function! s:BaseTag._init(name) abort dict
+    let self.name          = a:name
+    let self.fields        = {}
+    let self.fields.line   = 0
+    let self.fields.column = 0
+    let self.prototype     = ''
+    let self.path          = ''
+    let self.fullpath      = a:name
+    let self.depth         = 0
+    let self.parent        = {}
+    let self.tline         = -1
+    let self.fileinfo      = {}
+    let self.typeinfo      = {}
+endfunction
+
+" s:BaseTag.isNormalTag() {{{3
+function! s:BaseTag.isNormalTag() abort dict
+    return 0
+endfunction
+
+" s:BaseTag.isPseudoTag() {{{3
+function! s:BaseTag.isPseudoTag() abort dict
+    return 0
+endfunction
+
+" s:BaseTag.isKindheader() {{{3
+function! s:BaseTag.isKindheader() abort dict
+    return 0
+endfunction
+
+" s:BaseTag.getPrototype() {{{3
+function! s:BaseTag.getPrototype(short) abort dict
+    return self.prototype
+endfunction
+
+" s:BaseTag._getPrefix() {{{3
+function! s:BaseTag._getPrefix() abort dict
+    let fileinfo = self.fileinfo
+
+    if has_key(self, 'children') && !empty(self.children)
+        if fileinfo.tagfolds[self.fields.kind][self.fullpath]
+            let prefix = s:icon_closed
+        else
+            let prefix = s:icon_open
+        endif
+    else
+        let prefix = ' '
+    endif
+    " Visibility is called 'access' in the ctags output
+    if g:tagbar_show_visibility
+        if has_key(self.fields, 'access')
+            let prefix .= get(s:visibility_symbols, self.fields.access, ' ')
+        elseif has_key(self.fields, 'file')
+            let prefix .= s:visibility_symbols.private
+        else
+            let prefix .= ' '
+        endif
+    endif
+
+    return prefix
+endfunction
+
+" s:BaseTag.initFoldState() {{{3
+function! s:BaseTag.initFoldState() abort dict
+    let fileinfo = self.fileinfo
+
+    if s:known_files.has(fileinfo.fpath) &&
+     \ has_key(fileinfo, '_tagfolds_old') &&
+     \ has_key(fileinfo._tagfolds_old[self.fields.kind], self.fullpath)
+        " The file has been updated and the tag was there before, so copy its
+        " old fold state
+        let fileinfo.tagfolds[self.fields.kind][self.fullpath] =
+                    \ fileinfo._tagfolds_old[self.fields.kind][self.fullpath]
+    elseif self.depth >= fileinfo.foldlevel
+        let fileinfo.tagfolds[self.fields.kind][self.fullpath] = 1
+    else
+        let fileinfo.tagfolds[self.fields.kind][self.fullpath] =
+                    \ fileinfo.kindfolds[self.fields.kind]
+    endif
+endfunction
+
+" s:BaseTag.getClosedParentTline() {{{3
+function! s:BaseTag.getClosedParentTline() abort dict
+    let tagline  = self.tline
+
+    " Find the first closed parent, starting from the top of the hierarchy.
+    let parents   = []
+    let curparent = self.parent
+    while !empty(curparent)
+        call add(parents, curparent)
+        let curparent = curparent.parent
+    endwhile
+    for parent in reverse(parents)
+        if parent.isFolded()
+            let tagline = parent.tline
+            break
+        endif
+    endfor
+
+    return tagline
+endfunction
+
+" s:BaseTag.isFoldable() {{{3
+function! s:BaseTag.isFoldable() abort dict
+    return has_key(self, 'children') && !empty(self.children)
+endfunction
+
+" s:BaseTag.isFolded() {{{3
+function! s:BaseTag.isFolded() abort dict
+    return self.fileinfo.tagfolds[self.fields.kind][self.fullpath]
+endfunction
+
+" s:BaseTag.openFold() {{{3
+function! s:BaseTag.openFold() abort dict
+    if self.isFoldable()
+        let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 0
+    endif
+endfunction
+
+" s:BaseTag.closeFold() {{{3
+function! s:BaseTag.closeFold() abort dict
+    let newline = line('.')
+
+    if !empty(self.parent) && self.parent.isKindheader()
+        " Tag is child of generic 'kind'
+        call self.parent.closeFold()
+        let newline = self.parent.tline
+    elseif self.isFoldable() && !self.isFolded()
+        " Tag is parent of a scope and is not folded
+        let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 1
+        let newline = self.tline
+    elseif !empty(self.parent)
+        " Tag is normal child, so close parent
+        let parent = self.parent
+        let self.fileinfo.tagfolds[parent.fields.kind][parent.fullpath] = 1
+        let newline = parent.tline
+    endif
+
+    return newline
+endfunction
+
+" s:BaseTag.setFolded() {{{3
+function! s:BaseTag.setFolded(folded) abort dict
+    let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = a:folded
+endfunction
+
+" s:BaseTag.openParents() {{{3
+function! s:BaseTag.openParents() abort dict
+    let parent = self.parent
+
+    while !empty(parent)
+        call parent.openFold()
+        let parent = parent.parent
+    endwhile
+endfunction
+
+" Normal tag {{{2
+let s:NormalTag = copy(s:BaseTag)
+
+" s:NormalTag.isNormalTag() {{{3
+function! s:NormalTag.isNormalTag() abort dict
+    return 1
+endfunction
+
+" s:NormalTag.strfmt() {{{3
+function! s:NormalTag.strfmt() abort dict
+    let typeinfo = self.typeinfo
+
+    let suffix = get(self.fields, 'signature', '')
+    if has_key(self.fields, 'type')
+        let suffix .= ' : ' . self.fields.type
+    elseif has_key(typeinfo, 'kind2scope') &&
+         \ has_key(typeinfo.kind2scope, self.fields.kind)
+        let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
+    endif
+
+    return self._getPrefix() . self.name . suffix . "\n"
+endfunction
+
+" s:NormalTag.str() {{{3
+function! s:NormalTag.str(longsig, full) abort dict
+    if a:full && self.path != ''
+        let str = self.path . self.typeinfo.sro . self.name
+    else
+        let str = self.name
+    endif
+
+    if has_key(self.fields, 'signature')
+        if a:longsig
+            let str .= self.fields.signature
+        else
+            let str .= '()'
+        endif
+    endif
+
+    return str
+endfunction
+
+" s:NormalTag.getPrototype() {{{3
+function! s:NormalTag.getPrototype(short) abort dict
+    if self.prototype != ''
+        let prototype = self.prototype
+    else
+        let bufnr = self.fileinfo.bufnr
+
+        if self.fields.line == 0 || !bufloaded(bufnr)
+            " No linenumber available or buffer not loaded (probably due to
+            " 'nohidden'), try the pattern instead
+            return substitute(self.pattern, '^\\V\\^\\C\s*\(.*\)\\$$', '\1', '')
+        endif
+
+        let line = getbufline(bufnr, self.fields.line)[0]
+        let list = split(line, '\zs')
+
+        let start = index(list, '(')
+        if start == -1
+            return substitute(line, '^\s\+', '', '')
+        endif
+
+        let opening = count(list, '(', 0, start)
+        let closing = count(list, ')', 0, start)
+        if closing >= opening
+            return substitute(line, '^\s\+', '', '')
+        endif
+
+        let balance = opening - closing
+
+        let prototype = line
+        let curlinenr = self.fields.line + 1
+        while balance > 0
+            let curline = getbufline(bufnr, curlinenr)[0]
+            let curlist = split(curline, '\zs')
+            let balance += count(curlist, '(')
+            let balance -= count(curlist, ')')
+            let prototype .= "\n" . curline
+            let curlinenr += 1
+        endwhile
+
+        let self.prototype = prototype
+    endif
+
+    if a:short
+        " join all lines and remove superfluous spaces
+        let prototype = substitute(prototype, '^\s\+', '', '')
+        let prototype = substitute(prototype, '\_s\+', ' ', 'g')
+        let prototype = substitute(prototype, '(\s\+', '(', 'g')
+        let prototype = substitute(prototype, '\s\+)', ')', 'g')
+        " Avoid hit-enter prompts
+        let maxlen = &columns - 12
+        if len(prototype) > maxlen
+            let prototype = prototype[:maxlen - 1 - 3]
+            let prototype .= '...'
+        endif
+    endif
+
+    return prototype
+endfunction
+
+" Pseudo tag {{{2
+let s:PseudoTag = copy(s:BaseTag)
+
+" s:PseudoTag.isPseudoTag() {{{3
+function! s:PseudoTag.isPseudoTag() abort dict
+    return 1
+endfunction
+
+" s:PseudoTag.strfmt() {{{3
+function! s:PseudoTag.strfmt() abort dict
+    let typeinfo = self.typeinfo
+
+    let suffix = get(self.fields, 'signature', '')
+    if has_key(typeinfo.kind2scope, self.fields.kind)
+        let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
+    endif
+
+    return self._getPrefix() . self.name . '*' . suffix
+endfunction
+
+" Kind header {{{2
+let s:KindheaderTag = copy(s:BaseTag)
+
+" s:KindheaderTag.isKindheader() {{{3
+function! s:KindheaderTag.isKindheader() abort dict
+    return 1
+endfunction
+
+" s:KindheaderTag.getPrototype() {{{3
+function! s:KindheaderTag.getPrototype(short) abort dict
+    return self.name . ': ' .
+         \ self.numtags . ' ' . (self.numtags > 1 ? 'tags' : 'tag')
+endfunction
+
+" s:KindheaderTag.isFoldable() {{{3
+function! s:KindheaderTag.isFoldable() abort dict
+    return 1
+endfunction
+
+" s:KindheaderTag.isFolded() {{{3
+function! s:KindheaderTag.isFolded() abort dict
+    return self.fileinfo.kindfolds[self.short]
+endfunction
+
+" s:KindheaderTag.openFold() {{{3
+function! s:KindheaderTag.openFold() abort dict
+    let self.fileinfo.kindfolds[self.short] = 0
+endfunction
+
+" s:KindheaderTag.closeFold() {{{3
+function! s:KindheaderTag.closeFold() abort dict
+    let self.fileinfo.kindfolds[self.short] = 1
+    return line('.')
+endfunction
+
+" s:KindheaderTag.toggleFold() {{{3
+function! s:KindheaderTag.toggleFold() abort dict
+    let fileinfo = s:known_files.getCurrent(0)
+
+    let fileinfo.kindfolds[self.short] = !fileinfo.kindfolds[self.short]
+endfunction
+
+" Type info {{{2
+let s:TypeInfo = {}
+
+" s:TypeInfo.New() {{{3
+function! s:TypeInfo.New(...) abort dict
+    let newobj = copy(self)
+
+    let newobj.kinddict = {}
+
+    if a:0 > 0
+        call extend(newobj, a:1)
+    endif
+
+    return newobj
+endfunction
+
+" s:TypeInfo.getKind() {{{3
+function! s:TypeInfo.getKind(kind) abort dict
+    let idx = self.kinddict[a:kind]
+    return self.kinds[idx]
+endfunction
+
+" s:TypeInfo.createKinddict() {{{3
+" Create a dictionary of the kind order for fast access in sorting functions
+function! s:TypeInfo.createKinddict() abort dict
+    let i = 0
+    for kind in self.kinds
+        let self.kinddict[kind.short] = i
+        let i += 1
+    endfor
+endfunction
+
+" File info {{{2
+let s:FileInfo = {}
+
+" s:FileInfo.New() {{{3
+function! s:FileInfo.New(fname, ftype, typeinfo) abort dict
+    let newobj = copy(self)
+
+    " The complete file path
+    let newobj.fpath = a:fname
+
+    let newobj.bufnr = bufnr(a:fname)
+
+    " File modification time
+    let newobj.mtime = getftime(a:fname)
+
+    " The vim file type
+    let newobj.ftype = a:ftype
+
+    " List of the tags that are present in the file, sorted according to the
+    " value of 'g:tagbar_sort'
+    let newobj.tags = []
+
+    " Dictionary of the tags, indexed by line number in the file
+    let newobj.fline = {}
+
+    " Dictionary of the tags, indexed by line number in the tagbar
+    let newobj.tline = {}
+
+    " Dictionary of the folding state of 'kind's, indexed by short name
+    let newobj.kindfolds = {}
+    let newobj.typeinfo = a:typeinfo
+    " copy the default fold state from the type info
+    for kind in a:typeinfo.kinds
+        let newobj.kindfolds[kind.short] =
+                    \ g:tagbar_foldlevel == 0 ? 1 : kind.fold
+    endfor
+
+    " Dictionary of dictionaries of the folding state of individual tags,
+    " indexed by kind and full path
+    let newobj.tagfolds = {}
+    for kind in a:typeinfo.kinds
+        let newobj.tagfolds[kind.short] = {}
+    endfor
+
+    " The current foldlevel of the file
+    let newobj.foldlevel = g:tagbar_foldlevel
+
+    return newobj
+endfunction
+
+" s:FileInfo.reset() {{{3
+" Reset stuff that gets regenerated while processing a file and save the old
+" tag folds
+function! s:FileInfo.reset() abort dict
+    let self.mtime = getftime(self.fpath)
+    let self.tags  = []
+    let self.fline = {}
+    let self.tline = {}
+
+    let self._tagfolds_old = self.tagfolds
+    let self.tagfolds = {}
+
+    for kind in self.typeinfo.kinds
+        let self.tagfolds[kind.short] = {}
+    endfor
+endfunction
+
+" s:FileInfo.clearOldFolds() {{{3
+function! s:FileInfo.clearOldFolds() abort dict
+    if exists('self._tagfolds_old')
+        unlet self._tagfolds_old
+    endif
+endfunction
+
+" s:FileInfo.sortTags() {{{3
+function! s:FileInfo.sortTags() abort dict
+    if get(s:compare_typeinfo, 'sort', g:tagbar_sort)
+        call s:SortTags(self.tags, 's:CompareByKind')
+    else
+        call s:SortTags(self.tags, 's:CompareByLine')
+    endif
+endfunction
+
+" s:FileInfo.openKindFold() {{{3
+function! s:FileInfo.openKindFold(kind) abort dict
+    let self.kindfolds[a:kind.short] = 0
+endfunction
+
+" s:FileInfo.closeKindFold() {{{3
+function! s:FileInfo.closeKindFold(kind) abort dict
+    let self.kindfolds[a:kind.short] = 1
+endfunction
+
+" Known files {{{2
+let s:known_files = {
+    \ '_current' : {},
+    \ '_paused'  : {},
+    \ '_files'   : {}
+\ }
+
+" s:known_files.getCurrent() {{{3
+function! s:known_files.getCurrent(forcecurrent) abort dict
+    if !s:paused || a:forcecurrent
+        return self._current
+    else
+        return self._paused
+    endif
+endfunction
+
+" s:known_files.setCurrent() {{{3
+function! s:known_files.setCurrent(fileinfo) abort dict
+    let self._current = a:fileinfo
+endfunction
+
+" s:known_files.setPaused() {{{3
+function! s:known_files.setPaused() abort dict
+    let self._paused = self._current
+endfunction
+
+" s:known_files.get() {{{3
+function! s:known_files.get(fname) abort dict
+    return get(self._files, a:fname, {})
+endfunction
+
+" s:known_files.put() {{{3
+" Optional second argument is the filename
+function! s:known_files.put(fileinfo, ...) abort dict
+    if a:0 == 1
+        let self._files[a:1] = a:fileinfo
+    else
+        let fname = a:fileinfo.fpath
+        let self._files[fname] = a:fileinfo
+    endif
+endfunction
+
+" s:known_files.has() {{{3
+function! s:known_files.has(fname) abort dict
+    return has_key(self._files, a:fname)
+endfunction
+
+" s:known_files.rm() {{{3
+function! s:known_files.rm(fname) abort dict
+    if s:known_files.has(a:fname)
+        call s:debug('Removing fileinfo for [' . a:fname . ']')
+        call remove(self._files, a:fname)
+    endif
+endfunction
+
+" Window management {{{1
+" s:ToggleWindow() {{{2
+function! s:ToggleWindow() abort
+    call s:debug('ToggleWindow called')
+
+    let tagbarwinnr = bufwinnr("__Tagbar__")
+    if tagbarwinnr != -1
+        call s:CloseWindow()
+        return
+    endif
+
+    call s:OpenWindow('')
+
+    call s:debug('ToggleWindow finished')
+endfunction
+
+" s:OpenWindow() {{{2
+function! s:OpenWindow(flags) abort
+    call s:debug("OpenWindow called with flags: '" . a:flags . "'")
+
+    let autofocus = a:flags =~# 'f'
+    let jump      = a:flags =~# 'j'
+    let autoclose = a:flags =~# 'c'
+
+    let curfile = fnamemodify(bufname('%'), ':p')
+    let curline = line('.')
+
+    " If the tagbar window is already open check jump flag
+    " Also set the autoclose flag if requested
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr != -1
+        if winnr() != tagbarwinnr && jump
+            call s:goto_win(tagbarwinnr)
+            call s:HighlightTag(g:tagbar_autoshowtag != 2, 1, curline)
+        endif
+        call s:debug("OpenWindow finished, Tagbar already open")
+        return
+    endif
+
+    " This is only needed for the CorrectFocusOnStartup() function
+    let s:last_autofocus = autofocus
+
+    if !s:Init(0)
+        return 0
+    endif
+
+    " Expand the Vim window to accomodate for the Tagbar window if requested
+    " and save the window positions to be able to restore them later.
+    if g:tagbar_expand >= 1 && !s:window_expanded &&
+     \ (has('gui_running') || g:tagbar_expand == 2)
+        let s:window_pos.pre.x = getwinposx()
+        let s:window_pos.pre.y = getwinposy()
+        let &columns += g:tagbar_width + 1
+        let s:window_pos.post.x = getwinposx()
+        let s:window_pos.post.y = getwinposy()
+        let s:window_expanded = 1
+    endif
+
+    let s:window_opening = 1
+    if g:tagbar_vertical == 0
+        let openpos = g:tagbar_left ? 'topleft vertical ' : 'botright vertical '
+        let width = g:tagbar_width
+    else
+        let openpos = g:tagbar_left ? 'leftabove ' : 'rightbelow '
+        let width = g:tagbar_vertical
+    endif
+    exe 'silent keepalt ' . openpos . width . 'split ' . '__Tagbar__'
+    unlet s:window_opening
+
+    call s:InitWindow(autoclose)
+
+    " If the current file exists, but is empty, it means that it had a
+    " processing error before opening the window, most likely due to a call to
+    " currenttag() in the statusline. Remove the entry so an error message
+    " will be shown if the processing still fails.
+    if empty(s:known_files.get(curfile))
+        call s:known_files.rm(curfile)
+    endif
+
+    call s:AutoUpdate(curfile, 0)
+    call s:HighlightTag(g:tagbar_autoshowtag != 2, 1, curline)
+
+    if !(g:tagbar_autoclose || autofocus || g:tagbar_autofocus)
+        call s:goto_win('p')
+    endif
+
+    call s:debug('OpenWindow finished')
+endfunction
+
+" s:InitWindow() {{{2
+function! s:InitWindow(autoclose) abort
+    call s:debug('InitWindow called with autoclose: ' . a:autoclose)
+
+    setlocal filetype=tagbar
+
+    setlocal noreadonly " in case the "view" mode is used
+    setlocal buftype=nofile
+    setlocal bufhidden=hide
+    setlocal noswapfile
+    setlocal nobuflisted
+    setlocal nomodifiable
+    setlocal nolist
+    setlocal nowrap
+    setlocal winfixwidth
+    setlocal textwidth=0
+    setlocal nospell
+
+    if g:tagbar_show_linenumbers == 0
+        setlocal nonumber
+        if exists('+relativenumber')
+            setlocal norelativenumber
+        endif
+    elseif g:tagbar_show_linenumbers == 1
+        setlocal number
+    elseif g:tagbar_show_linenumbers == 2
+        setlocal relativenumber
+    else
+        set number<
+        if exists('+relativenumber')
+            set relativenumber<
+        endif
+    endif
+
+    setlocal nofoldenable
+    setlocal foldcolumn=0
+    " Reset fold settings in case a plugin set them globally to something
+    " expensive. Apparently 'foldexpr' gets executed even if 'foldenable' is
+    " off, and then for every appended line (like with :put).
+    setlocal foldmethod&
+    setlocal foldexpr&
+
+    let w:autoclose = a:autoclose
+
+    call s:SetStatusLine()
+
+    let s:new_window = 1
+
+    if has('balloon_eval')
+        setlocal balloonexpr=TagbarBalloonExpr()
+        set ballooneval
+    endif
+
+    let cpoptions_save = &cpoptions
+    set cpoptions&vim
+
+    if !exists('b:tagbar_mapped_keys')
+        call s:MapKeys()
+    endif
+
+    let &cpoptions = cpoptions_save
+
+    if g:tagbar_expand
+        let s:expand_bufnr = bufnr('%')
+    endif
+
+    call s:debug('InitWindow finished')
+endfunction
+
+" s:CloseWindow() {{{2
+function! s:CloseWindow() abort
+    call s:debug('CloseWindow called')
+
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr == -1
+        return
+    endif
+
+    " Close the preview window if it was opened by us
+    if s:pwin_by_tagbar
+        pclose
+        let tagbarwinnr = bufwinnr('__Tagbar__')
+    endif
+
+    if winnr() == tagbarwinnr
+        if winbufnr(2) != -1
+            " Other windows are open, only close the tagbar one
+
+            let curfile = s:known_files.getCurrent(0)
+
+            close
+
+            " Try to jump to the correct window after closing
+            call s:goto_win('p')
+
+            if !empty(curfile)
+                let filebufnr = bufnr(curfile.fpath)
+
+                if bufnr('%') != filebufnr
+                    let filewinnr = bufwinnr(filebufnr)
+                    if filewinnr != -1
+                        call s:goto_win(filewinnr)
+                    endif
+                endif
+            endif
+        endif
+    else
+        " Go to the tagbar window, close it and then come back to the original
+        " window. Save a win-local variable in the original window so we can
+        " jump back to it even if the window number changed.
+        call s:mark_window()
+        call s:goto_win(tagbarwinnr)
+        close
+
+        call s:goto_markedwin()
+    endif
+
+    call s:ShrinkIfExpanded()
+
+    " The window sizes may have changed due to the shrinking happening after
+    " the window closing, so equalize them again.
+    if &equalalways
+        wincmd =
+    endif
+
+    if s:autocommands_done && !s:statusline_in_use
+        autocmd! TagbarAutoCmds
+        let s:autocommands_done = 0
+    endif
+
+    call s:debug('CloseWindow finished')
+endfunction
+
+" s:ShrinkIfExpanded() {{{2
+" If the Vim window has been expanded, and Tagbar is not open in any other
+" tabpages, shrink the window again
+function! s:ShrinkIfExpanded() abort
+    if !s:window_expanded || &filetype == 'tagbar' || s:expand_bufnr == -1
+        return
+    endif
+
+    let tablist = []
+    for i in range(tabpagenr('$'))
+        call extend(tablist, tabpagebuflist(i + 1))
+    endfor
+
+    if index(tablist, s:expand_bufnr) == -1
+        let &columns -= g:tagbar_width + 1
+        let s:window_expanded = 0
+        let s:expand_bufnr = -1
+        " Only restore window position if it is available and if the
+        " window hasn't been moved manually after the expanding
+        if getwinposx() != -1 &&
+         \ getwinposx() == s:window_pos.post.x &&
+         \ getwinposy() == s:window_pos.post.y
+           execute 'winpos ' . s:window_pos.pre.x .
+                       \ ' ' . s:window_pos.pre.y
+        endif
+    endif
+endfunction
+
+" s:ZoomWindow() {{{2
+function! s:ZoomWindow() abort
+    if s:is_maximized
+        execute 'vertical resize ' . g:tagbar_width
+        execute s:winrestcmd
+        let s:is_maximized = 0
+    else
+        let s:winrestcmd = winrestcmd()
+        if g:tagbar_zoomwidth == 1
+            vertical resize
+        elseif g:tagbar_zoomwidth == 0
+            let func = exists('*strdisplaywidth') ? 'strdisplaywidth' : 'strlen'
+            let maxline = max(map(getline(line('w0'), line('w$')),
+                                \ func . '(v:val)'))
+            execute 'vertical resize ' . maxline
+        elseif g:tagbar_zoomwidth > 1
+            execute 'vertical resize ' . g:tagbar_zoomwidth
+        endif
+        let s:is_maximized = 1
+    endif
+endfunction
+
+" s:CorrectFocusOnStartup() {{{2
+" For whatever reason the focus will be on the Tagbar window if
+" tagbar#autoopen is used with a FileType autocommand on startup and
+" g:tagbar_left is set. This should work around it by jumping to the window of
+" the current file after startup.
+function! s:CorrectFocusOnStartup() abort
+    if bufwinnr('__Tagbar__') != -1 && !g:tagbar_autofocus && !s:last_autofocus
+        let curfile = s:known_files.getCurrent(1)
+        if !empty(curfile) && curfile.fpath != fnamemodify(bufname('%'), ':p')
+            let winnr = bufwinnr(curfile.fpath)
+            if winnr != -1
+                call s:goto_win(winnr)
+            endif
+        endif
+    endif
+endfunction
+
+" Tag processing {{{1
+" s:ProcessFile() {{{2
+" Execute ctags and put the information into a 'FileInfo' object
+function! s:ProcessFile(fname, ftype) abort
+    call s:debug('ProcessFile called [' . a:fname . ']')
+
+    if !s:IsValidFile(a:fname, a:ftype)
+        call s:debug('Not a valid file, returning')
+        return
+    endif
+
+    let typeinfo = s:known_types[a:ftype]
+
+    " If the file has only been updated preserve the fold states, otherwise
+    " create a new entry
+    if s:known_files.has(a:fname) && !empty(s:known_files.get(a:fname)) &&
+     \ s:known_files.get(a:fname).ftype == a:ftype
+        let fileinfo = s:known_files.get(a:fname)
+        let typeinfo = fileinfo.typeinfo
+        call fileinfo.reset()
+    else
+        if exists('#TagbarProjects#User')
+            execute 'doautocmd <nomodeline> TagbarProjects User ' . a:fname
+            if exists('b:tagbar_type')
+                let typeinfo = extend(copy(typeinfo),
+                                    \ s:TransformUserTypeDef(b:tagbar_type))
+                call typeinfo.createKinddict()
+            endif
+        endif
+        let fileinfo = s:FileInfo.New(a:fname, a:ftype, typeinfo)
+    endif
+
+    call s:debug('typeinfo for file to process: ' . string(typeinfo))
+
+    " Use a temporary files for ctags processing instead of the original one.
+    " This allows using Tagbar for files accessed with netrw, and also doesn't
+    " slow down Tagbar for files that sit on slow network drives.
+    let tempfile = tempname()
+    let ext = fnamemodify(fileinfo.fpath, ':e')
+    if ext != ''
+        let tempfile .= '.' . ext
+    endif
+
+    call writefile(getbufline(fileinfo.bufnr, 1, '$'), tempfile)
+    let fileinfo.mtime = getftime(tempfile)
+
+    let ctags_output = s:ExecuteCtagsOnFile(tempfile, a:fname, typeinfo)
+
+    call delete(tempfile)
+
+    if ctags_output == -1
+        call s:debug('Ctags error when processing file')
+        " Put an empty entry into known_files so the error message is only
+        " shown once
+        call s:known_files.put({}, a:fname)
+        return
+    elseif ctags_output == ''
+        call s:debug('Ctags output empty')
+        " No need to go through the tag processing if there are no tags, and
+        " preserving the old fold state isn't necessary either
+        call s:known_files.put(s:FileInfo.New(a:fname, a:ftype,
+                                            \ s:known_types[a:ftype]), a:fname)
+        return
+    endif
+
+    call s:debug('Filetype tag kinds: ' . string(keys(typeinfo.kinddict)))
+
+    " Parse the ctags output lines
+    call s:debug('Parsing ctags output')
+    let rawtaglist = split(ctags_output, '\n\+')
+    for line in rawtaglist
+        " skip comments
+        if line =~# '^!_TAG_'
+            continue
+        endif
+
+        let parts = split(line, ';"')
+        if len(parts) == 2 " Is a valid tag line
+            let taginfo = s:ParseTagline(parts[0], parts[1], typeinfo, fileinfo)
+            if !empty(taginfo)
+                let fileinfo.fline[taginfo.fields.line] = taginfo
+                call add(fileinfo.tags, taginfo)
+            endif
+        endif
+    endfor
+
+    " Process scoped tags
+    let processedtags = []
+    if has_key(typeinfo, 'kind2scope')
+        call s:debug('Processing scoped tags')
+
+        let scopedtags = []
+        let is_scoped = 'has_key(typeinfo.kind2scope, v:val.fields.kind) ||
+                       \ has_key(v:val, "scope")'
+        let scopedtags += filter(copy(fileinfo.tags), is_scoped)
+        call filter(fileinfo.tags, '!(' . is_scoped . ')')
+
+        call s:AddScopedTags(scopedtags, processedtags, {}, 0,
+                           \ typeinfo, fileinfo, line('$'))
+
+        if !empty(scopedtags)
+            echoerr 'Tagbar: ''scopedtags'' not empty after processing,'
+                  \ 'this should never happen!'
+                  \ 'Please contact the script maintainer with an example.'
+        endif
+    endif
+    call s:debug('Number of top-level tags: ' . len(processedtags))
+
+    " Create a placeholder tag for the 'kind' header for folding purposes
+    for kind in typeinfo.kinds
+
+        let curtags = filter(copy(fileinfo.tags),
+                           \ 'v:val.fields.kind ==# kind.short')
+        call s:debug('Processing kind: ' . kind.short .
+                   \ ', number of tags: ' . len(curtags))
+
+        if empty(curtags)
+            continue
+        endif
+
+        let kindtag          = s:KindheaderTag.New(kind.long)
+        let kindtag.short    = kind.short
+        let kindtag.numtags  = len(curtags)
+        let kindtag.fileinfo = fileinfo
+
+        for tag in curtags
+            let tag.parent = kindtag
+        endfor
+    endfor
+
+    if !empty(processedtags)
+        call extend(fileinfo.tags, processedtags)
+    endif
+
+    " Clear old folding information from previous file version to prevent leaks
+    call fileinfo.clearOldFolds()
+
+    " Sort the tags
+    let s:compare_typeinfo = typeinfo
+    call fileinfo.sortTags()
+
+    call s:known_files.put(fileinfo)
+endfunction
+
+" s:ExecuteCtagsOnFile() {{{2
+function! s:ExecuteCtagsOnFile(fname, realfname, typeinfo) abort
+    call s:debug('ExecuteCtagsOnFile called [' . a:fname . ']')
+
+    if has_key(a:typeinfo, 'ctagsargs') && type(a:typeinfo.ctagsargs) == type('')
+        " if ctagsargs is a string, prepend and append space separators
+        let ctags_args = ' ' . a:typeinfo.ctagsargs . ' '
+    elseif has_key(a:typeinfo, 'ctagsargs') && type(a:typeinfo.ctagsargs) == type([])
+        let ctags_args = a:typeinfo.ctagsargs
+    " otherwise ctagsargs is not defined or not defined as a valid type
+    else
+        "Prefer constructing ctags_args as a list rather than a string
+        "See s:EscapeCtagsCmd() - It's a best practice to shellescape()
+        "each arg separately because in special cases where space is
+        "intended to be in an argument, spaces in a single ctag_args
+        "string would be ambiguous. Is the space an argument separator
+        "or to be included in the argument
+        let ctags_args  = [ '-f',
+                          \ '-',
+                          \ '--format=2',
+                          \ '--excmd=pattern',
+                          \ '--fields=nksSaf',
+                          \ '--extra=',
+                          \ '--file-scope=yes',
+                          \ '--sort=no',
+                          \ '--append=no'
+                          \ ]
+
+        " Include extra type definitions
+        if has_key(a:typeinfo, 'deffile')
+            let ctags_args += ['--options=' . expand(a:typeinfo.deffile)]
+        endif
+
+        " Third-party programs may not necessarily make use of this
+        if has_key(a:typeinfo, 'ctagstype')
+            let ctags_type = a:typeinfo.ctagstype
+
+            let ctags_kinds = ''
+            for kind in a:typeinfo.kinds
+                let ctags_kinds .= kind.short
+            endfor
+
+            let ctags_args += ['--language-force=' . ctags_type]
+            let ctags_args += ['--' . ctags_type . '-kinds=' . ctags_kinds]
+        endif
+    endif
+
+    if has_key(a:typeinfo, 'ctagsbin')
+        " reset 'wildignore' temporarily in case *.exe is included in it
+        let wildignore_save = &wildignore
+        set wildignore&
+        let ctags_bin = expand(a:typeinfo.ctagsbin)
+        let &wildignore = wildignore_save
+    else
+        let ctags_bin = g:tagbar_ctags_bin
+    endif
+
+    let ctags_cmd = s:EscapeCtagsCmd(ctags_bin, ctags_args, a:fname)
+    if ctags_cmd == ''
+        return ''
+    endif
+
+    let ctags_output = s:ExecuteCtags(ctags_cmd)
+
+    if v:shell_error || ctags_output =~ 'Warning: cannot open source file'
+        call s:debug('Command output:')
+        call s:debug(ctags_output)
+        " Only display an error message if the Tagbar window is open and we
+        " haven't seen the error before.
+        if bufwinnr("__Tagbar__") != -1 &&
+         \ (!s:known_files.has(a:realfname) ||
+         \ !empty(s:known_files.get(a:realfname)))
+            call s:warning('Tagbar: Could not execute ctags for ' . a:realfname . '!')
+            echomsg 'Executed command: "' . ctags_cmd . '"'
+            if !empty(ctags_output)
+                echomsg 'Command output:'
+                for line in split(ctags_output, '\n')
+                    echomsg line
+                endfor
+            endif
+        endif
+        return -1
+    endif
+
+    call s:debug('Ctags executed successfully')
+    return ctags_output
+endfunction
+
+" s:ParseTagline() {{{2
+" Structure of a tag line:
+" tagname<TAB>filename<TAB>expattern;"fields
+" fields: <TAB>name:value
+" fields that are always present: kind, line
+function! s:ParseTagline(part1, part2, typeinfo, fileinfo) abort
+    let basic_info  = split(a:part1, '\t')
+
+    let taginfo      = s:NormalTag.New(basic_info[0])
+    let taginfo.file = basic_info[1]
+
+    " the pattern can contain tabs and thus may have been split up, so join
+    " the rest of the items together again
+    let pattern = join(basic_info[2:], "\t")
+    let start   = 2 " skip the slash and the ^
+    let end     = strlen(pattern) - 1
+    if pattern[end - 1] ==# '$'
+        let end -= 1
+        let dollar = '\$'
+    else
+        let dollar = ''
+    endif
+    let pattern         = strpart(pattern, start, end - start)
+    let taginfo.pattern = '\V\^\C' . pattern . dollar
+
+    " When splitting fields make sure not to create empty keys or values in
+    " case a value illegally contains tabs
+    let fields = split(a:part2, '^\t\|\t\ze\w\+:')
+    if fields[0] !~# ':'
+        let taginfo.fields.kind = remove(fields, 0)
+    endif
+    for field in fields
+        " can't use split() since the value can contain ':'
+        let delimit = stridx(field, ':')
+        let key = strpart(field, 0, delimit)
+        " Remove all tabs that may illegally be in the value
+        let val = substitute(strpart(field, delimit + 1), '\t', '', 'g')
+        " File-restricted scoping
+        if key == "file"
+            let taginfo.fields[key] = 'yes'
+        endif
+        if len(val) > 0
+            if key == 'line' || key == 'column'
+                let taginfo.fields[key] = str2nr(val)
+            else
+                let taginfo.fields[key] = val
+            endif
+        endif
+    endfor
+    " Needed for jsctags
+    if has_key(taginfo.fields, 'lineno')
+        let taginfo.fields.line = str2nr(taginfo.fields.lineno)
+    endif
+    " Do some sanity checking in case ctags reports invalid line numbers
+    if taginfo.fields.line < 0
+        let taginfo.fields.line = 0
+    endif
+
+    if !has_key(taginfo.fields, 'kind')
+        call s:debug("Warning: No 'kind' field found for tag " . basic_info[0] . "!")
+        if index(s:warnings.type, a:typeinfo.ftype) == -1
+            call s:warning("No 'kind' field found for tag " . basic_info[0] . "!" .
+                         \ " Please read the last section of ':help tagbar-extend'.")
+            call add(s:warnings.type, a:typeinfo.ftype)
+        endif
+        return {}
+    endif
+
+    " Make some information easier accessible
+    if has_key(a:typeinfo, 'scope2kind')
+        for scope in keys(a:typeinfo.scope2kind)
+            if has_key(taginfo.fields, scope)
+                let taginfo.scope = scope
+                let taginfo.path  = taginfo.fields[scope]
+
+                let taginfo.fullpath = taginfo.path . a:typeinfo.sro .
+                                     \ taginfo.name
+                break
+            endif
+        endfor
+        let taginfo.depth = len(split(taginfo.path, '\V' . a:typeinfo.sro))
+    endif
+
+    let taginfo.fileinfo = a:fileinfo
+    let taginfo.typeinfo = a:typeinfo
+
+    " Needed for folding
+    try
+        call taginfo.initFoldState()
+    catch /^Vim(\a\+):E716:/ " 'Key not present in Dictionary'
+        " The tag has a 'kind' that doesn't exist in the type definition
+        call s:debug('Warning: Unknown tag kind: ' . taginfo.fields.kind)
+        if index(s:warnings.type, a:typeinfo.ftype) == -1
+            call s:warning('Unknown tag kind encountered: ' .
+                \ '"' . taginfo.fields.kind . '".' .
+                \ ' Your ctags and Tagbar configurations are out of sync!' .
+                \ ' Please read '':help tagbar-extend''.')
+            call add(s:warnings.type, a:typeinfo.ftype)
+        endif
+        return {}
+    endtry
+
+    return taginfo
+endfunction
+
+" s:AddScopedTags() {{{2
+" Recursively process tags. Unfortunately there is a problem: not all tags in
+" a hierarchy are actually there. For example, in C++ a class can be defined
+" in a header file and implemented in a .cpp file (so the class itself doesn't
+" appear in the .cpp file and thus doesn't generate a tag). Another example
+" are anonymous structures like namespaces, structs, enums, and unions, that
+" also don't get a tag themselves. These tags are thus called 'pseudo-tags' in
+" Tagbar. Properly parsing them is quite tricky, so try not to think about it
+" too much.
+function! s:AddScopedTags(tags, processedtags, parent, depth,
+                        \ typeinfo, fileinfo, maxline) abort
+    if !empty(a:parent)
+        let curpath = a:parent.fullpath
+        let pscope  = a:typeinfo.kind2scope[a:parent.fields.kind]
+    else
+        let curpath = ''
+        let pscope  = ''
+    endif
+
+    let is_cur_tag = 'v:val.depth == a:depth'
+
+    if !empty(curpath)
+        " Check whether the tag is either a direct child at the current depth
+        " or at least a proper grandchild with pseudo-tags in between. If it
+        " is a direct child also check for matching scope.
+        let is_cur_tag .= ' &&
+        \ (v:val.path ==# curpath ||
+         \ match(v:val.path, ''\V\^\C'' . curpath . a:typeinfo.sro) == 0) &&
+        \ (v:val.path ==# curpath ? (v:val.scope ==# pscope) : 1) &&
+        \ v:val.fields.line >= a:parent.fields.line &&
+        \ v:val.fields.line <= a:maxline'
+    endif
+
+    let curtags = filter(copy(a:tags), is_cur_tag)
+
+    if !empty(curtags)
+        call filter(a:tags, '!(' . is_cur_tag . ')')
+
+        let realtags   = []
+        let pseudotags = []
+
+        while !empty(curtags)
+            let tag = remove(curtags, 0)
+
+            if tag.path != curpath
+                " tag is child of a pseudo-tag, so create a new pseudo-tag and
+                " add all its children to it
+                let pseudotag = s:ProcessPseudoTag(curtags, tag, a:parent,
+                                                 \ a:typeinfo, a:fileinfo)
+
+                call add(pseudotags, pseudotag)
+            else
+                call add(realtags, tag)
+            endif
+        endwhile
+
+        " Recursively add the children of the tags on the current level
+        for tag in realtags
+            let tag.parent = a:parent
+
+            if !has_key(a:typeinfo.kind2scope, tag.fields.kind)
+                continue
+            endif
+
+            if !has_key(tag, 'children')
+                let tag.children = []
+            endif
+
+            " Check for tags with the exact same name that may be created
+            " alternatively in a conditional (Issue #139). The only way to
+            " distinguish between them is by line number.
+            let twins = filter(copy(realtags),
+                             \ "v:val.fullpath ==# '" .
+                             \ substitute(tag.fullpath, "'", "''", 'g') . "'" .
+                             \ " && v:val.fields.line != " . tag.fields.line)
+            let maxline = line('$')
+            for twin in twins
+                if twin.fields.line <= maxline &&
+                 \ twin.fields.line > tag.fields.line
+                    let maxline = twin.fields.line - 1
+                endif
+            endfor
+
+            call s:AddScopedTags(a:tags, tag.children, tag, a:depth + 1,
+                               \ a:typeinfo, a:fileinfo, maxline)
+        endfor
+        call extend(a:processedtags, realtags)
+
+        " Recursively add the children of the tags that are children of the
+        " pseudo-tags on the current level
+        for tag in pseudotags
+            call s:ProcessPseudoChildren(a:tags, tag, a:depth, a:typeinfo,
+                                       \ a:fileinfo)
+        endfor
+        call extend(a:processedtags, pseudotags)
+    endif
+
+    " Now we have to check if there are any pseudo-tags at the current level
+    " so we have to check for real tags at a lower level, i.e. grandchildren
+    let is_grandchild = 'v:val.depth > a:depth'
+
+    if !empty(curpath)
+        let is_grandchild .=
+        \ ' && match(v:val.path, ''\V\^\C'' . curpath . a:typeinfo.sro) == 0'
+    endif
+
+    let grandchildren = filter(copy(a:tags), is_grandchild)
+
+    if !empty(grandchildren)
+        call s:AddScopedTags(a:tags, a:processedtags, a:parent, a:depth + 1,
+                           \ a:typeinfo, a:fileinfo, a:maxline)
+    endif
+endfunction
+
+" s:ProcessPseudoTag() {{{2
+function! s:ProcessPseudoTag(curtags, tag, parent, typeinfo, fileinfo) abort
+    let curpath = !empty(a:parent) ? a:parent.fullpath : ''
+
+    let pseudoname = substitute(a:tag.path, curpath, '', '')
+    let pseudoname = substitute(pseudoname, '\V\^' . a:typeinfo.sro, '', '')
+    let pseudotag  = s:CreatePseudoTag(pseudoname, a:parent, a:tag.scope,
+                                     \ a:typeinfo, a:fileinfo)
+    let pseudotag.children = [a:tag]
+
+    " get all the other (direct) children of the current pseudo-tag
+    let ispseudochild = 'v:val.path ==# a:tag.path && v:val.scope ==# a:tag.scope'
+    let pseudochildren = filter(copy(a:curtags), ispseudochild)
+    if !empty(pseudochildren)
+        call filter(a:curtags, '!(' . ispseudochild . ')')
+        call extend(pseudotag.children, pseudochildren)
+    endif
+
+    return pseudotag
+endfunction
+
+" s:ProcessPseudoChildren() {{{2
+function! s:ProcessPseudoChildren(tags, tag, depth, typeinfo, fileinfo) abort
+    for childtag in a:tag.children
+        let childtag.parent = a:tag
+
+        if !has_key(a:typeinfo.kind2scope, childtag.fields.kind)
+            continue
+        endif
+
+        if !has_key(childtag, 'children')
+            let childtag.children = []
+        endif
+
+        call s:AddScopedTags(a:tags, childtag.children, childtag, a:depth + 1,
+                           \ a:typeinfo, a:fileinfo, line('$'))
+    endfor
+
+    let is_grandchild = 'v:val.depth > a:depth && ' .
+            \ 'match(v:val.path,' .
+            \ '''^\C'' . substitute(a:tag.fullpath, "''", "''''", "g")) == 0'
+    let grandchildren = filter(copy(a:tags), is_grandchild)
+    if !empty(grandchildren)
+        call s:AddScopedTags(a:tags, a:tag.children, a:tag, a:depth + 1,
+                           \ a:typeinfo, a:fileinfo, line('$'))
+    endif
+endfunction
+
+" s:CreatePseudoTag() {{{2
+function! s:CreatePseudoTag(name, parent, scope, typeinfo, fileinfo) abort
+    if !empty(a:parent)
+        let curpath = a:parent.fullpath
+        let pscope  = a:typeinfo.kind2scope[a:parent.fields.kind]
+    else
+        let curpath = ''
+        let pscope  = ''
+    endif
+
+    let pseudotag             = s:PseudoTag.New(a:name)
+    let pseudotag.fields.kind = a:typeinfo.scope2kind[a:scope]
+
+    let parentscope = substitute(curpath, a:name . '$', '', '')
+    let parentscope = substitute(parentscope,
+                               \ '\V\^' . a:typeinfo.sro . '\$', '', '')
+
+    if pscope != ''
+        let pseudotag.fields[pscope] = parentscope
+        let pseudotag.scope    = pscope
+        let pseudotag.path     = parentscope
+        let pseudotag.fullpath =
+                    \ pseudotag.path . a:typeinfo.sro . pseudotag.name
+    endif
+    let pseudotag.depth = len(split(pseudotag.path, '\V' . a:typeinfo.sro))
+
+    let pseudotag.parent = a:parent
+
+    let pseudotag.fileinfo = a:fileinfo
+    let pseudotag.typeinfo = a:typeinfo
+
+    call pseudotag.initFoldState()
+
+    return pseudotag
+endfunction
+
+" Sorting {{{1
+" s:SortTags() {{{2
+function! s:SortTags(tags, comparemethod) abort
+    call sort(a:tags, a:comparemethod)
+
+    for tag in a:tags
+        if has_key(tag, 'children')
+            call s:SortTags(tag.children, a:comparemethod)
+        endif
+    endfor
+endfunction
+
+" s:CompareByKind() {{{2
+function! s:CompareByKind(tag1, tag2) abort
+    let typeinfo = s:compare_typeinfo
+
+    if typeinfo.kinddict[a:tag1.fields.kind] <#
+     \ typeinfo.kinddict[a:tag2.fields.kind]
+        return -1
+    elseif typeinfo.kinddict[a:tag1.fields.kind] >#
+         \ typeinfo.kinddict[a:tag2.fields.kind]
+        return 1
+    else
+        " Ignore '~' prefix for C++ destructors to sort them directly under
+        " the constructors
+        if a:tag1.name[0] ==# '~'
+            let name1 = a:tag1.name[1:]
+        else
+            let name1 = a:tag1.name
+        endif
+        if a:tag2.name[0] ==# '~'
+            let name2 = a:tag2.name[1:]
+        else
+            let name2 = a:tag2.name
+        endif
+
+        let ci = g:tagbar_case_insensitive
+        if (((!ci) && (name1 <=# name2)) || (ci && (name1 <=? name2)))
+            return -1
+        else
+            return 1
+        endif
+    endif
+endfunction
+
+" s:CompareByLine() {{{2
+function! s:CompareByLine(tag1, tag2) abort
+    return a:tag1.fields.line - a:tag2.fields.line
+endfunction
+
+" s:ToggleSort() {{{2
+function! s:ToggleSort() abort
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    " Save the tag the cursor is currently on
+    let curline = line('.')
+    let taginfo = s:GetTagInfo(curline, 0)
+
+    match none
+
+    let s:compare_typeinfo = s:known_types[fileinfo.ftype]
+
+    if has_key(s:compare_typeinfo, 'sort')
+        let s:compare_typeinfo.sort = !s:compare_typeinfo.sort
+    else
+        let g:tagbar_sort = !g:tagbar_sort
+    endif
+
+    call fileinfo.sortTags()
+
+    call s:RenderContent()
+    call s:SetStatusLine()
+
+    " If we were on a tag before sorting then jump to it, otherwise restore
+    " the cursor to the current line
+    if !empty(taginfo)
+        execute taginfo.tline
+    else
+        execute curline
+    endif
+endfunction
+
+" Display {{{1
+" s:RenderContent() {{{2
+function! s:RenderContent(...) abort
+    call s:debug('RenderContent called')
+    let s:new_window = 0
+
+    if a:0 == 1
+        let fileinfo = a:1
+    else
+        let fileinfo = s:known_files.getCurrent(0)
+    endif
+
+    if empty(fileinfo)
+        call s:debug('Empty fileinfo, returning')
+        return
+    endif
+
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+
+    if &filetype == 'tagbar'
+        let in_tagbar = 1
+    else
+        let in_tagbar = 0
+        let prevwinnr = winnr()
+
+        " Get the previous window number, so that we can reproduce
+        " the window entering history later. Do not run autocmd on
+        " this command, make sure nothing is interfering.
+        " let pprevwinnr = winnr('#') " Messes up windows for some reason
+        call s:goto_win('p', 1)
+        let pprevwinnr = winnr()
+        call s:goto_win(tagbarwinnr, 1)
+    endif
+
+    if !empty(s:known_files.getCurrent(0)) &&
+     \ fileinfo.fpath ==# s:known_files.getCurrent(0).fpath
+        " We're redisplaying the same file, so save the view
+        call s:debug('Redisplaying file [' . fileinfo.fpath . ']')
+        let saveline = line('.')
+        let savecol  = col('.')
+        let topline  = line('w0')
+    endif
+
+    let lazyredraw_save = &lazyredraw
+    set lazyredraw
+    let eventignore_save = &eventignore
+    set eventignore=all
+
+    setlocal modifiable
+
+    silent %delete _
+
+    call s:PrintHelp()
+
+    let typeinfo = fileinfo.typeinfo
+
+    if !empty(fileinfo.tags)
+        " Print tags
+        call s:PrintKinds(typeinfo, fileinfo)
+    else
+        call s:debug('No tags found, skipping printing.')
+        if g:tagbar_compact && s:short_help
+            silent 0put ='\" No tags found.'
+        else
+            silent  put ='\" No tags found.'
+        endif
+    endif
+
+    " Delete empty lines at the end of the buffer
+    for linenr in range(line('$'), 1, -1)
+        if getline(linenr) =~ '^$'
+            execute 'silent ' . linenr . 'delete _'
+        else
+            break
+        endif
+    endfor
+
+    setlocal nomodifiable
+
+    if !empty(s:known_files.getCurrent(0)) &&
+     \ fileinfo.fpath ==# s:known_files.getCurrent(0).fpath
+        let scrolloff_save = &scrolloff
+        set scrolloff=0
+
+        call cursor(topline, 1)
+        normal! zt
+        call cursor(saveline, savecol)
+
+        let &scrolloff = scrolloff_save
+    else
+        " Make sure as much of the Tagbar content as possible is shown in the
+        " window by jumping to the top after drawing
+        execute 1
+        call winline()
+
+        " Invalidate highlight cache from old file
+        let s:last_highlight_tline = 0
+    endif
+
+    let &lazyredraw  = lazyredraw_save
+    let &eventignore = eventignore_save
+
+    if !in_tagbar
+        call s:goto_win(pprevwinnr, 1)
+        call s:goto_win(prevwinnr, 1)
+    endif
+endfunction
+
+" s:PrintKinds() {{{2
+function! s:PrintKinds(typeinfo, fileinfo) abort
+    call s:debug('PrintKinds called')
+
+    let is_first_tag = 1
+
+    for kind in a:typeinfo.kinds
+        let curtags = filter(copy(a:fileinfo.tags),
+                           \ 'v:val.fields.kind ==# kind.short')
+        call s:debug('Printing kind: ' . kind.short .
+                   \ ', number of (top-level) tags: ' . len(curtags))
+
+        if empty(curtags)
+            continue
+        endif
+
+        if has_key(a:typeinfo, 'kind2scope') &&
+         \ has_key(a:typeinfo.kind2scope, kind.short)
+            " Scoped tags
+            for tag in curtags
+                call s:PrintTag(tag, 0, is_first_tag, a:fileinfo, a:typeinfo)
+
+                if !g:tagbar_compact
+                    silent put _
+                endif
+
+                let is_first_tag = 0
+            endfor
+        else
+            " Non-scoped tags
+            let kindtag = curtags[0].parent
+
+            if kindtag.isFolded()
+                let foldmarker = s:icon_closed
+            else
+                let foldmarker = s:icon_open
+            endif
+
+            let padding = g:tagbar_show_visibility ? ' ' : ''
+            if g:tagbar_compact && is_first_tag && s:short_help
+                silent 0put =foldmarker . padding . kind.long
+            else
+                silent  put =foldmarker . padding . kind.long
+            endif
+
+            let curline                   = line('.')
+            let kindtag.tline             = curline
+            let a:fileinfo.tline[curline] = kindtag
+
+            if !kindtag.isFolded()
+                for tag in curtags
+                    let str = tag.strfmt()
+                    silent put =repeat(' ', g:tagbar_indent) . str
+
+                    " Save the current tagbar line in the tag for easy
+                    " highlighting access
+                    let curline                   = line('.')
+                    let tag.tline                 = curline
+                    let a:fileinfo.tline[curline] = tag
+                    let tag.depth                 = 1
+                endfor
+            endif
+
+            if !g:tagbar_compact
+                silent put _
+            endif
+
+            let is_first_tag = 0
+        endif
+    endfor
+endfunction
+
+" s:PrintTag() {{{2
+function! s:PrintTag(tag, depth, is_first, fileinfo, typeinfo) abort
+    if g:tagbar_hide_nonpublic &&
+     \ get(a:tag.fields, 'access', 'public') !=# 'public'
+        let a:tag.tline = -1
+        return
+    endif
+
+    " Print tag indented according to depth
+    let tagstr = repeat(' ', a:depth * g:tagbar_indent) . a:tag.strfmt()
+    if a:is_first && g:tagbar_compact && s:short_help
+        silent 0put =tagstr
+    else
+        silent  put =tagstr
+    endif
+
+    " Save the current tagbar line in the tag for easy highlighting access
+    let curline                   = line('.')
+    let a:tag.tline               = curline
+    let a:fileinfo.tline[curline] = a:tag
+
+    " Recursively print children
+    if a:tag.isFoldable() && !a:tag.isFolded()
+        for ckind in a:typeinfo.kinds
+            let childfilter = 'v:val.fields.kind ==# ckind.short'
+            if g:tagbar_hide_nonpublic
+                let childfilter .=
+                      \ ' && get(v:val.fields, "access", "public") ==# "public"'
+            endif
+            let childtags = filter(copy(a:tag.children), childfilter)
+            if len(childtags) > 0
+                " Print 'kind' header of following children, but only if they
+                " are not scope-defining tags (since those already have an
+                " identifier)
+                if !has_key(a:typeinfo.kind2scope, ckind.short)
+                    let indent  = (a:depth + 1) * g:tagbar_indent
+                    let indent += g:tagbar_show_visibility
+                    let indent += 1 " fold symbol
+                    silent put =repeat(' ', indent) . '[' . ckind.long . ']'
+                    " Add basic tag to allow folding when on the header line
+                    let headertag = s:BaseTag.New(ckind.long)
+                    let headertag.parent = a:tag
+                    let headertag.fileinfo = a:tag.fileinfo
+                    let a:fileinfo.tline[line('.')] = headertag
+                endif
+                for childtag in childtags
+                    call s:PrintTag(childtag, a:depth + 1, 0,
+                                  \ a:fileinfo, a:typeinfo)
+                endfor
+            endif
+        endfor
+    endif
+endfunction
+
+" s:PrintHelp() {{{2
+function! s:PrintHelp() abort
+    if !g:tagbar_compact && s:short_help
+        silent 0put ='\" Press ' . s:get_map_str('help') . ' for help'
+        silent  put _
+    elseif !s:short_help
+        silent 0put ='\" Tagbar keybindings'
+        silent  put ='\"'
+        silent  put ='\" --------- General ---------'
+        silent  put ='\" ' . s:get_map_str('jump') . ': Jump to tag definition'
+        silent  put ='\" ' . s:get_map_str('preview') . ': As above, but stay in'
+        silent  put ='\"    Tagbar window'
+        silent  put ='\" ' . s:get_map_str('previewwin') . ': Show tag in preview window'
+        silent  put ='\" ' . s:get_map_str('nexttag') . ': Go to next top-level tag'
+        silent  put ='\" ' . s:get_map_str('prevtag') . ': Go to previous top-level tag'
+        silent  put ='\" ' . s:get_map_str('showproto') . ': Display tag prototype'
+        silent  put ='\" ' . s:get_map_str('hidenonpublic') . ': Hide non-public tags'
+        silent  put ='\"'
+        silent  put ='\" ---------- Folds ----------'
+        silent  put ='\" ' . s:get_map_str('openfold') . ': Open fold'
+        silent  put ='\" ' . s:get_map_str('closefold') . ': Close fold'
+        silent  put ='\" ' . s:get_map_str('togglefold') . ': Toggle fold'
+        silent  put ='\" ' . s:get_map_str('openallfolds') . ': Open all folds'
+        silent  put ='\" ' . s:get_map_str('closeallfolds') . ': Close all folds'
+        silent  put ='\" ' . s:get_map_str('nextfold') . ': Go to next fold'
+        silent  put ='\" ' . s:get_map_str('prevfold') . ': Go to previous fold'
+        silent  put ='\"'
+        silent  put ='\" ---------- Misc -----------'
+        silent  put ='\" ' . s:get_map_str('togglesort') . ': Toggle sort'
+        silent  put ='\" ' . s:get_map_str('togglecaseinsensitive') . ': Toggle case insensitive sort option'
+        silent  put ='\" ' . s:get_map_str('toggleautoclose') . ': Toggle autoclose option'
+        silent  put ='\" ' . s:get_map_str('zoomwin') . ': Zoom window in/out'
+        silent  put ='\" ' . s:get_map_str('close') . ': Close window'
+        silent  put ='\" ' . s:get_map_str('help') . ': Toggle help'
+        silent  put _
+    endif
+endfunction
+function! s:get_map_str(map) abort
+    let def = get(g:, 'tagbar_map_' . a:map)
+    if type(def) == type("")
+        return def
+    else
+        return join(def, ', ')
+    endif
+endfunction
+
+" s:RenderKeepView() {{{2
+" The gist of this function was taken from NERDTree by Martin Grenfell.
+function! s:RenderKeepView(...) abort
+    if a:0 == 1
+        let line = a:1
+    else
+        let line = line('.')
+    endif
+
+    let curcol  = col('.')
+    let topline = line('w0')
+
+    call s:RenderContent()
+
+    let scrolloff_save = &scrolloff
+    set scrolloff=0
+
+    call cursor(topline, 1)
+    normal! zt
+    call cursor(line, curcol)
+
+    let &scrolloff = scrolloff_save
+
+    redraw
+endfunction
+
+" User actions {{{1
+" s:HighlightTag() {{{2
+function! s:HighlightTag(openfolds, ...) abort
+    let tagline = 0
+
+    let force = a:0 > 0 ? a:1 : 0
+
+    if a:0 > 1
+        let tag = s:GetNearbyTag(1, 0, a:2)
+    else
+        let tag = s:GetNearbyTag(1, 0)
+    endif
+    if !empty(tag)
+        let tagline = tag.tline
+    endif
+
+    " Don't highlight the tag again if it's the same one as last time.
+    " This prevents the Tagbar window from jumping back after scrolling with
+    " the mouse.
+    if !force && tagline == s:last_highlight_tline
+        return
+    else
+        let s:last_highlight_tline = tagline
+    endif
+
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr == -1
+        return
+    endif
+    let prevwinnr = winnr()
+    call s:goto_win(tagbarwinnr)
+
+    match none
+
+    " No tag above cursor position so don't do anything
+    if tagline == 0
+        call s:goto_win(prevwinnr)
+        redraw
+        return
+    endif
+
+    if g:tagbar_autoshowtag == 1 || a:openfolds
+        call s:OpenParents(tag)
+    endif
+
+    " Check whether the tag is inside a closed fold and highlight the parent
+    " instead in that case
+    let tagline = tag.getClosedParentTline()
+
+    " Parent tag line number is invalid, better don't do anything
+    if tagline <= 0
+        call s:goto_win(prevwinnr)
+        redraw
+        return
+    endif
+
+    " Go to the line containing the tag
+    execute tagline
+
+    " Make sure the tag is visible in the window
+    call winline()
+
+    let foldpat = '[' . s:icon_open . s:icon_closed . ' ]'
+    let pattern = '/^\%' . tagline . 'l\s*' . foldpat . '[-+# ]\zs[^( ]\+\ze/'
+    call s:debug("Highlight pattern: '" . pattern . "'")
+    if hlexists('TagbarHighlight') " Safeguard in case syntax highlighting is disabled
+        execute 'match TagbarHighlight ' . pattern
+    else
+        execute 'match Search ' . pattern
+    endif
+
+
+    if a:0 <= 1 " no line explicitly given, so assume we were in the file window
+        call s:goto_win(prevwinnr)
+    endif
+
+    redraw
+endfunction
+
+" s:JumpToTag() {{{2
+function! s:JumpToTag(stay_in_tagbar) abort
+    let taginfo = s:GetTagInfo(line('.'), 1)
+
+    let autoclose = w:autoclose
+
+    if empty(taginfo) || !taginfo.isNormalTag()
+        return
+    endif
+
+    let tagbarwinnr = winnr()
+
+    call s:GotoFileWindow(taginfo.fileinfo)
+
+    " Mark current position so it can be jumped back to
+    mark '
+
+    " Jump to the line where the tag is defined. Don't use the search pattern
+    " since it doesn't take the scope into account and thus can fail if tags
+    " with the same name are defined in different scopes (e.g. classes)
+    execute taginfo.fields.line
+
+    " If the file has been changed but not saved, the tag may not be on the
+    " saved line anymore, so search for it in the vicinity of the saved line
+    if match(getline('.'), taginfo.pattern) == -1
+        let interval = 1
+        let forward  = 1
+        while search(taginfo.pattern, 'W' . forward ? '' : 'b') == 0
+            if !forward
+                if interval > line('$')
+                    break
+                else
+                    let interval = interval * 2
+                endif
+            endif
+            let forward = !forward
+        endwhile
+    endif
+
+    " If the tag is on a different line after unsaved changes update the tag
+    " and file infos/objects
+    let curline = line('.')
+    if taginfo.fields.line != curline
+        let taginfo.fields.line = curline
+        let taginfo.fileinfo.fline[curline] = taginfo
+    endif
+
+    " Center the tag in the window and jump to the correct column if
+    " available, otherwise try to find it in the line
+    normal! z.
+    if taginfo.fields.column > 0
+        call cursor(taginfo.fields.line, taginfo.fields.column)
+    else
+        call cursor(taginfo.fields.line, 1)
+        call search(taginfo.name, 'c', line('.'))
+    endif
+
+    normal! zv
+
+    if a:stay_in_tagbar
+        call s:HighlightTag(0)
+        call s:goto_win(tagbarwinnr)
+        redraw
+    elseif g:tagbar_autoclose || autoclose
+        " Also closes preview window
+        call s:CloseWindow()
+    else
+        " Close the preview window if it was opened by us
+        if s:pwin_by_tagbar
+            pclose
+        endif
+        call s:HighlightTag(0)
+    endif
+endfunction
+
+" s:ShowInPreviewWin() {{{2
+function! s:ShowInPreviewWin() abort
+    let pos = getpos('.')
+    let taginfo = s:GetTagInfo(pos[1], 1)
+
+    if empty(taginfo) || !taginfo.isNormalTag()
+        return
+    endif
+
+    let pwin_open = 0
+    for win in range(1, winnr('$'))
+        if getwinvar(win, '&previewwindow')
+            let pwin_open = 1
+            break
+        endif
+    endfor
+
+    " We want the preview window to be relative to the file window in normal
+    " (horizontal) mode, and relative to the Tagbar window in vertical mode,
+    " to make the best use of space.
+    if g:tagbar_vertical == 0
+        call s:GotoFileWindow(taginfo.fileinfo, 1)
+        call s:mark_window()
+    endif
+
+    " Open the preview window if it is not already open. This has to be done
+    " explicitly before the :psearch below to better control its positioning.
+    if !pwin_open
+        silent execute
+            \ g:tagbar_previewwin_pos . ' pedit ' . taginfo.fileinfo.fpath
+        if g:tagbar_vertical != 0
+            silent execute 'vertical resize ' . g:tagbar_width
+        endif
+        " Remember that the preview window was opened by Tagbar so we can
+        " safely close it by ourselves
+        let s:pwin_by_tagbar = 1
+    endif
+
+    if g:tagbar_vertical != 0
+        call s:GotoFileWindow(taginfo.fileinfo, 1)
+        call s:mark_window()
+    endif
+
+    " Use psearch instead of pedit since pedit essentially reloads the file
+    " and creates an empty undo entry. psearch has to be called from the file
+    " window, and since we only want matches in the current file we disable
+    " the 'include' option. Also start searching at the correct line number to
+    " find the correct tag in case of tags with the same name and to speed up
+    " the searching. Unfortunately the /\%l pattern doesn't seem to work with
+    " psearch.
+    let include_save = &include
+    set include=
+    silent! execute taginfo.fields.line . ',$psearch! /' . taginfo.pattern . '/'
+    let &include = include_save
+
+    call s:goto_win('P', 1)
+    normal! zv
+    normal! zz
+    call s:goto_markedwin(1)
+    call s:goto_tagbar(1)
+    call cursor(pos[1], pos[2])
+endfunction
+
+" s:ShowPrototype() {{{2
+function! s:ShowPrototype(short) abort
+    let taginfo = s:GetTagInfo(line('.'), 1)
+
+    if empty(taginfo)
+        return ''
+    endif
+
+    echo taginfo.getPrototype(a:short)
+endfunction
+
+" s:ToggleHelp() {{{2
+function! s:ToggleHelp() abort
+    let s:short_help = !s:short_help
+
+    " Prevent highlighting from being off after adding/removing the help text
+    match none
+
+    call s:RenderContent()
+
+    execute 1
+    redraw
+endfunction
+
+" s:GotoNextToplevelTag() {{{2
+function! s:GotoNextToplevelTag(direction) abort
+    let curlinenr = line('.')
+    let newlinenr = line('.')
+
+    if a:direction == 1
+        let range = range(line('.') + 1, line('$'))
+    else
+        let range = range(line('.') - 1, 1, -1)
+    endif
+
+    for tmplinenr in range
+        let taginfo = s:GetTagInfo(tmplinenr, 0)
+
+        if empty(taginfo)
+            continue
+        elseif empty(taginfo.parent)
+            let newlinenr = tmplinenr
+            break
+        endif
+    endfor
+
+    if curlinenr != newlinenr
+        execute newlinenr
+        call winline()
+    endif
+
+    redraw
+endfunction
+
+" Folding {{{1
+" s:OpenFold() {{{2
+function! s:OpenFold() abort
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    let curline = line('.')
+
+    let tag = s:GetTagInfo(curline, 0)
+    if empty(tag)
+        return
+    endif
+
+    call tag.openFold()
+
+    call s:RenderKeepView()
+endfunction
+
+" s:CloseFold() {{{2
+function! s:CloseFold() abort
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    match none
+
+    let curline = line('.')
+
+    let curtag = s:GetTagInfo(curline, 0)
+    if empty(curtag)
+        return
+    endif
+
+    let newline = curtag.closeFold()
+
+    call s:RenderKeepView(newline)
+endfunction
+
+" s:ToggleFold() {{{2
+function! s:ToggleFold() abort
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    match none
+
+    let curtag = s:GetTagInfo(line('.'), 0)
+    if empty(curtag)
+        return
+    endif
+
+    let newline = line('.')
+
+    if curtag.isKindheader()
+        call curtag.toggleFold()
+    elseif curtag.isFoldable()
+        if curtag.isFolded()
+            call curtag.openFold()
+        else
+            let newline = curtag.closeFold()
+        endif
+    else
+        let newline = curtag.closeFold()
+    endif
+
+    call s:RenderKeepView(newline)
+endfunction
+
+" s:SetFoldLevel() {{{2
+function! s:SetFoldLevel(level, force) abort
+    if a:level < 0
+        call s:warning('Foldlevel can''t be negative')
+        return
+    endif
+
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    call s:SetFoldLevelRecursive(fileinfo, fileinfo.tags, a:level)
+
+    let typeinfo = fileinfo.typeinfo
+
+    " Apply foldlevel to 'kind's
+    if a:level == 0
+        for kind in typeinfo.kinds
+            call fileinfo.closeKindFold(kind)
+        endfor
+    else
+        for kind in typeinfo.kinds
+            if a:force || !kind.fold
+                call fileinfo.openKindFold(kind)
+            endif
+        endfor
+    endif
+
+    let fileinfo.foldlevel = a:level
+
+    call s:RenderContent()
+endfunction
+
+" s:SetFoldLevelRecursive() {{{2
+" Apply foldlevel to normal tags
+function! s:SetFoldLevelRecursive(fileinfo, tags, level) abort
+    for tag in a:tags
+        if tag.depth >= a:level
+            call tag.setFolded(1)
+        else
+            call tag.setFolded(0)
+        endif
+
+        if has_key(tag, 'children')
+            call s:SetFoldLevelRecursive(a:fileinfo, tag.children, a:level)
+        endif
+    endfor
+endfunction
+
+" s:OpenParents() {{{2
+function! s:OpenParents(...) abort
+    if a:0 == 1
+        let tag = a:1
+    else
+        let tag = s:GetNearbyTag(1, 0)
+    endif
+
+    if !empty(tag)
+        call tag.openParents()
+        call s:RenderKeepView()
+    endif
+endfunction
+
+" s:GotoNextFold() {{{2
+function! s:GotoNextFold() abort
+    let curlinenr = line('.')
+    let newlinenr = line('.')
+
+    let range = range(line('.') + 1, line('$'))
+
+    for linenr in range
+        let taginfo = s:GetTagInfo(linenr, 0)
+
+        if empty(taginfo)
+            continue
+        elseif !empty(get(taginfo, 'children', [])) || taginfo.isKindheader()
+            let newlinenr = linenr
+            break
+        endif
+    endfor
+
+    if curlinenr != newlinenr
+        execute linenr
+        call winline()
+    endif
+
+    redraw
+endfunction
+
+" s:GotoPrevFold() {{{2
+function! s:GotoPrevFold() abort
+    let curlinenr = line('.')
+    let newlinenr = line('.')
+    let curtag = s:GetTagInfo(curlinenr, 0)
+    let curparent = get(curtag, 'parent', {})
+
+    let range = range(line('.') - 1, 1, -1)
+
+    for linenr in range
+        let taginfo = s:GetTagInfo(linenr, 0)
+
+        if empty(taginfo)
+            continue
+        " Check for the first tag that is either:
+        " - the last tag in an open fold, that is skip all tags that have the
+        "   same parent as the current one, or
+        " - a closed parent fold.
+        elseif (!empty(taginfo.parent) && taginfo.parent != curparent &&
+              \ empty(get(taginfo, 'children', []))) ||
+             \ ((!empty(get(taginfo, 'children', [])) || taginfo.isKindheader()) &&
+              \ taginfo.isFolded())
+            let newlinenr = linenr
+            break
+        endif
+    endfor
+
+    if curlinenr != newlinenr
+        execute linenr
+        call winline()
+    endif
+
+    redraw
+endfunction
+
+" Helper functions {{{1
+" s:AutoUpdate() {{{2
+function! s:AutoUpdate(fname, force) abort
+    call s:debug('AutoUpdate called [' . a:fname . ']')
+
+    " This file is being loaded due to a quickfix command like vimgrep, so
+    " don't process it
+    if exists('s:tagbar_qf_active')
+        return
+    elseif exists('s:window_opening')
+        " This can happen if another plugin causes the active window to change
+        " with an autocmd during the initial Tagbar window creation. In that
+        " case InitWindow() hasn't had a chance to run yet and things can
+        " break. MiniBufExplorer does this, for example. Completely disabling
+        " autocmds at that point is also not ideal since for example
+        " statusline plugins won't be able to update.
+        call s:debug('Still opening window, stopping processing')
+        return
+    endif
+
+    " Get the filetype of the file we're about to process
+    let bufnr = bufnr(a:fname)
+    let ftype = getbufvar(bufnr, '&filetype')
+
+    " Don't do anything if we're in the tagbar window
+    if ftype == 'tagbar'
+        call s:debug('In Tagbar window, stopping processing')
+        return
+    endif
+
+    " Only consider the main filetype in cases like 'python.django'
+    let sftype = get(split(ftype, '\.'), 0, '')
+    call s:debug("Vim filetype: '" . ftype . "', " .
+               \ "sanitized filetype: '" . sftype . "'")
+
+    " Don't do anything if the file isn't supported
+    if !s:IsValidFile(a:fname, sftype)
+        call s:debug('Not a valid file, stopping processing')
+        let s:nearby_disabled = 1
+        return
+    endif
+
+    let updated = 0
+
+    " Process the file if it's unknown or the information is outdated.
+    " Testing the mtime of the file is necessary in case it got changed
+    " outside of Vim, for example by checking out a different version from a
+    " VCS.
+    if s:known_files.has(a:fname)
+        let curfile = s:known_files.get(a:fname)
+        " if a:force || getbufvar(curfile.bufnr, '&modified') ||
+        if a:force || empty(curfile) || curfile.ftype != sftype ||
+         \ (filereadable(a:fname) && getftime(a:fname) > curfile.mtime)
+            call s:debug('File data outdated, updating [' . a:fname . ']')
+            call s:ProcessFile(a:fname, sftype)
+            let updated = 1
+        else
+            call s:debug('File data seems up to date [' . a:fname . ']')
+        endif
+    elseif !s:known_files.has(a:fname)
+        call s:debug('New file, processing [' . a:fname . ']')
+        call s:ProcessFile(a:fname, sftype)
+        let updated = 1
+    endif
+
+    let fileinfo = s:known_files.get(a:fname)
+
+    " If we don't have an entry for the file by now something must have gone
+    " wrong, so don't change the tagbar content
+    if empty(fileinfo)
+        call s:debug('fileinfo empty after processing [' . a:fname . ']')
+        return
+    endif
+
+    " Display the tagbar content if the tags have been updated or a different
+    " file is being displayed
+    if bufwinnr('__Tagbar__') != -1 && !s:paused &&
+     \ (s:new_window || updated ||
+      \ (!empty(s:known_files.getCurrent(0)) &&
+       \ a:fname != s:known_files.getCurrent(0).fpath))
+        call s:RenderContent(fileinfo)
+    endif
+
+    " Call setCurrent after rendering so RenderContent can check whether the
+    " same file is being redisplayed
+    if !empty(fileinfo)
+        call s:debug('Setting current file [' . a:fname . ']')
+        call s:known_files.setCurrent(fileinfo)
+        let s:nearby_disabled = 0
+    endif
+
+    call s:HighlightTag(0)
+    call s:SetStatusLine()
+    call s:debug('AutoUpdate finished successfully')
+endfunction
+
+" s:CheckMouseClick() {{{2
+function! s:CheckMouseClick() abort
+    let line   = getline('.')
+    let curcol = col('.')
+
+    if (match(line, s:icon_open . '[-+ ]') + 1) == curcol
+        call s:CloseFold()
+    elseif (match(line, s:icon_closed . '[-+ ]') + 1) == curcol
+        call s:OpenFold()
+    elseif g:tagbar_singleclick
+        call s:JumpToTag(0)
+    endif
+endfunction
+
+" s:DetectFiletype() {{{2
+function! s:DetectFiletype(bufnr) abort
+    " Filetype has already been detected for loaded buffers, but not
+    " necessarily for unloaded ones
+    let ftype = getbufvar(a:bufnr, '&filetype')
+
+    if bufloaded(a:bufnr)
+        return ftype
+    endif
+
+    if ftype != ''
+        return ftype
+    endif
+
+    " Unloaded buffer with non-detected filetype, need to detect filetype
+    " manually
+    let bufname = bufname(a:bufnr)
+
+    let eventignore_save = &eventignore
+    set eventignore=FileType
+    let filetype_save = &filetype
+
+    exe 'doautocmd filetypedetect BufRead ' . bufname
+    let ftype = &filetype
+
+    let &filetype = filetype_save
+    let &eventignore = eventignore_save
+
+    return ftype
+endfunction
+
+" s:EscapeCtagsCmd() {{{2
+" Assemble the ctags command line in a way that all problematic characters are
+" properly escaped and converted to the system's encoding
+" Optional third parameter is a file name to run ctags on
+" Note: The second parameter (a:args) can be a list of args or
+"       a single string of the args.
+"       When a:args is a list, each argument in the list will be escaped for the
+"       current &shell type.
+"       When a:args is a string, all arguments should be escaped appropriately
+"       (if required). In most use cases no escaping is required so a string
+"       is acceptable. But in cases where arguments may need to be escaped
+"       differently for each &shell type, then pass a list of arguments.
+function! s:EscapeCtagsCmd(ctags_bin, args, ...) abort
+    call s:debug('EscapeCtagsCmd called')
+    call s:debug('ctags_bin: ' . a:ctags_bin)
+    if type(a:args)==type('')
+        call s:debug('ctags_args (is a string): ' . a:args)
+    elseif type(a:args)==type([])
+        call s:debug('ctags_args (is a list): ' . string(a:args))
+    endif
+
+    if exists('+shellslash')
+        let shellslash_save = &shellslash
+        set noshellslash
+    endif
+
+    "Set up 0th argument of ctags_cmd
+    "a:ctags_bin may have special characters that require escaping.
+    if &shell =~ 'cmd\.exe$' && a:ctags_bin !~ '\s'
+        "For windows cmd.exe, escaping the 0th argument can cause
+        "problems if it references a batch file and the batch file uses %~dp0.
+        "So for windows cmd.exe, only escape the 0th argument iff necessary.
+        "Only known necessary case is when ctags_bin executable filename has
+        "whitespace character(s).
+
+        "  Example: If 0th argument is wrapped in double quotes AND it is not
+        "  an absolute path to ctags_bin, but rather an executable in %PATH%,
+        "  then %~dp0 resolves to the current working directory rather than
+        "  the batch file's directory. Batch files like this generally exepect
+        "  and depend on %~dp0 to resolve the batch file's directory.
+        "  Note: Documentation such as `help cmd.exe` and
+        "  http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/cmd.mspx?mfr=true
+        "  suggest other special characters that require escaping for command
+        "  line completion.  But tagbar.vim does not use the command line
+        "  completion feature of cmd.exe and testing shows that the only special
+        "  character that needs to be escaped for tagbar.vim is <space> for
+        "  windows cmd.exe.
+        let ctags_cmd = a:ctags_bin
+    else
+        let ctags_cmd = shellescape(a:ctags_bin)
+    endif
+
+    "Add additional arguments to ctags_cmd
+    if type(a:args)==type('')
+        "When a:args is a string, append the arguments
+        "Note: In this case, do not attempt to shell escape a:args string.
+        "This function expects the string to already be escaped properly for
+        "the shell type. Why not escape? Because it could be ambiguous about
+        "whether a space is an argument separator or included in the argument.
+        "Since escaping rules vary from shell to shell, it is better to pass a
+        "list of arguments to a:args. With a list, each argument is clearly
+        "separated, so shellescape() can calculate the appropriate escaping
+        "for each argument for the current &shell.
+        let ctags_cmd .= ' ' . a:args
+    elseif type(a:args)==type([])
+        "When a:args is a list, shellescape() each argument and append ctags_cmd
+        "Note: It's a better practice to shellescape() each argument separately so that
+        "spaces used as a separator between arguments can be distinguished with
+        "spaces used inside a single argument.
+        for arg in a:args
+            let ctags_cmd .= ' ' . shellescape(arg)
+        endfor
+    endif
+
+    "if a filename was specified, add filename as final argument to ctags_cmd.
+    if a:0 == 1
+        let ctags_cmd .= ' ' . shellescape(a:1)
+    endif
+
+    if exists('+shellslash')
+        let &shellslash = shellslash_save
+    endif
+
+    " Needed for cases where 'encoding' is different from the system's
+    " encoding
+    if has('multi_byte')
+        if g:tagbar_systemenc != &encoding
+            let ctags_cmd = iconv(ctags_cmd, &encoding, g:tagbar_systemenc)
+        elseif $LANG != ''
+            let ctags_cmd = iconv(ctags_cmd, &encoding, $LANG)
+        endif
+    endif
+
+    call s:debug('Escaped ctags command: ' . ctags_cmd)
+
+    if ctags_cmd == ''
+        if !s:warnings.encoding
+            call s:warning('Tagbar: Ctags command encoding conversion failed!' .
+                \ ' Please read ":h g:tagbar_systemenc".')
+            let s:warnings.encoding = 1
+        endif
+    endif
+
+    return ctags_cmd
+endfunction
+
+" s:ExecuteCtags() {{{2
+" Execute ctags with necessary shell settings
+" Partially based on the discussion at
+" http://vim.1045645.n5.nabble.com/bad-default-shellxquote-in-Widows-td1208284.html
+function! s:ExecuteCtags(ctags_cmd) abort
+    call s:debug('Executing ctags command: ' . a:ctags_cmd)
+
+    if &shell =~# 'fish$'
+        " Reset shell since fish isn't really compatible
+        let shell_save = &shell
+        set shell=sh
+    endif
+
+    if exists('+shellslash')
+        let shellslash_save = &shellslash
+        set noshellslash
+    endif
+
+    if &shell =~ 'cmd\.exe'
+        let shellxquote_save = &shellxquote
+        set shellxquote=\"
+        let shellcmdflag_save = &shellcmdflag
+        set shellcmdflag=/s\ /c
+    endif
+
+    if s:debug
+        silent 5verbose let ctags_output = system(a:ctags_cmd)
+        call s:debug(v:statusmsg)
+        redraw!
+    else
+        silent let ctags_output = system(a:ctags_cmd)
+    endif
+
+    if &shell =~ 'cmd\.exe'
+        let &shellxquote  = shellxquote_save
+        let &shellcmdflag = shellcmdflag_save
+    endif
+
+    if exists('+shellslash')
+        let &shellslash = shellslash_save
+    endif
+
+    if exists('shell_save')
+        let &shell = shell_save
+    endif
+
+    return ctags_output
+endfunction
+
+" s:GetNearbyTag() {{{2
+" Get the tag info for a file near the cursor in the current file
+function! s:GetNearbyTag(all, forcecurrent, ...) abort
+    if s:nearby_disabled
+        return {}
+    endif
+
+    let fileinfo = s:known_files.getCurrent(a:forcecurrent)
+    if empty(fileinfo)
+        return {}
+    endif
+
+    let typeinfo = fileinfo.typeinfo
+    if a:0 > 0
+        let curline = a:1
+    else
+        let curline = line('.')
+    endif
+    let tag = {}
+
+    " If a tag appears in a file more than once (for example namespaces in
+    " C++) only one of them has a 'tline' entry and can thus be highlighted.
+    " The only way to solve this would be to go over the whole tag list again,
+    " making everything slower. Since this should be a rare occurence and
+    " highlighting isn't /that/ important ignore it for now.
+    for line in range(curline, 1, -1)
+        if has_key(fileinfo.fline, line)
+            let curtag = fileinfo.fline[line]
+            if a:all || typeinfo.getKind(curtag.fields.kind).stl
+                let tag = curtag
+                break
+            endif
+        endif
+    endfor
+
+    return tag
+endfunction
+
+" s:GetTagInfo() {{{2
+" Return the info dictionary of the tag on the specified line. If the line
+" does not contain a valid tag (for example because it is empty or only
+" contains a pseudo-tag) return an empty dictionary.
+function! s:GetTagInfo(linenr, ignorepseudo) abort
+    let fileinfo = s:known_files.getCurrent(0)
+
+    if empty(fileinfo)
+        return {}
+    endif
+
+    " Don't do anything in empty and comment lines
+    let curline = getbufline(bufnr('__Tagbar__'), a:linenr)[0]
+    if curline =~ '^\s*$' || curline[0] == '"'
+        return {}
+    endif
+
+    " Check if there is a tag on the current line
+    if !has_key(fileinfo.tline, a:linenr)
+        return {}
+    endif
+
+    let taginfo = fileinfo.tline[a:linenr]
+
+    " Check if the current tag is not a pseudo-tag
+    if a:ignorepseudo && taginfo.isPseudoTag()
+        return {}
+    endif
+
+    return taginfo
+endfunction
+
+" s:GetFileWinnr() {{{2
+" Get the number of the window that has Tagbar's current file loaded into it,
+" or 0 if no window has loaded it. It tries the previous window first, if that
+" does not have the correct buffer loaded it will look for the first one with
+" the correct buffer in it.
+function! s:GetFileWinnr(fileinfo) abort
+    let filewinnr = 0
+    let prevwinnr = winnr("#")
+
+    if winbufnr(prevwinnr) == a:fileinfo.bufnr &&
+     \ !getwinvar(prevwinnr, '&previewwindow')
+        let filewinnr = prevwinnr
+    else
+        " Search for the first real window that has the correct buffer loaded
+        " in it. Similar to bufwinnr() but skips the previewwindow.
+        for i in range(1, winnr('$'))
+            call s:goto_win(i, 1)
+            if bufnr('%') == a:fileinfo.bufnr && !&previewwindow
+                let filewinnr = winnr()
+                break
+            endif
+        endfor
+
+        call s:goto_tagbar(1)
+    endif
+
+    return filewinnr
+endfunction
+
+" s:GotoFileWindow() {{{2
+" Try to switch to the window that has Tagbar's current file loaded in it, or
+" open the file in an existing window otherwise.
+function! s:GotoFileWindow(fileinfo, ...) abort
+    let noauto = a:0 > 0 ? a:1 : 0
+
+    let filewinnr = s:GetFileWinnr(a:fileinfo)
+
+    " If there is no window with the correct buffer loaded then load it
+    " into the first window that has a non-special buffer in it.
+    if filewinnr == 0
+        for i in range(1, winnr('$'))
+            call s:goto_win(i, 1)
+            if &buftype == '' && !&previewwindow
+                execute 'buffer ' . a:fileinfo.bufnr
+                break
+            endif
+        endfor
+    else
+        call s:goto_win(filewinnr, 1)
+    endif
+
+    " To make ctrl-w_p work we switch between the Tagbar window and the
+    " correct window once
+    call s:goto_tagbar(noauto)
+    call s:goto_win('p', noauto)
+endfunction
+
+" s:ToggleHideNonPublicTags() {{{2
+function! s:ToggleHideNonPublicTags() abort
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    " Save the tag the cursor is currently on
+    let curline = line('.')
+    let taginfo = s:GetTagInfo(curline, 0)
+
+    match none
+
+    let g:tagbar_hide_nonpublic = !g:tagbar_hide_nonpublic
+    call s:RenderKeepView()
+    call s:SetStatusLine()
+
+    " If we were on a tag before sorting then jump to it, otherwise restore
+    " the cursor to the current line
+    if !empty(taginfo)
+        execute taginfo.tline
+    else
+        execute curline
+    endif
+endfunction
+
+" s:ToggleCaseInsensitive() {{{2
+function! s:ToggleCaseInsensitive() abort
+    let fileinfo = s:known_files.getCurrent(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    " Save the tag the cursor is currently on
+    let curline = line('.')
+    let taginfo = s:GetTagInfo(curline, 0)
+
+    match none
+
+    let g:tagbar_case_insensitive = !g:tagbar_case_insensitive
+
+    call fileinfo.sortTags()
+
+    call s:RenderKeepView()
+    call s:SetStatusLine()
+
+    " If we were on a tag before sorting then jump to it, otherwise restore
+    " the cursor to the current line
+    if !empty(taginfo)
+        execute taginfo.tline
+    else
+        execute curline
+    endif
+endfunction
+
+" s:ToggleAutoclose() {{{2
+function! s:ToggleAutoclose() abort
+    let g:tagbar_autoclose = !g:tagbar_autoclose
+    call s:SetStatusLine()
+endfunction
+
+" s:IsValidFile() {{{2
+function! s:IsValidFile(fname, ftype) abort
+    call s:debug('Checking if file is valid [' . a:fname . ']')
+
+    if a:fname == '' || a:ftype == ''
+        call s:debug('Empty filename or type')
+        return 0
+    endif
+
+    if !filereadable(a:fname) && getbufvar(a:fname, 'netrw_tmpfile') == ''
+        call s:debug('File not readable')
+        return 0
+    endif
+
+    if getbufvar(a:fname, 'tagbar_ignore') == 1
+        call s:debug('File is marked as ignored')
+        return 0
+    endif
+
+    if &previewwindow
+        call s:debug('In preview window')
+        return 0
+    endif
+
+    if !has_key(s:known_types, a:ftype)
+        if exists('g:tagbar_type_' . a:ftype)
+            " Filetype definition must have been specified in an 'ftplugin'
+            " file, so load it now
+            call s:LoadUserTypeDefs(a:ftype)
+        else
+            call s:debug('Unsupported filetype: ' . a:ftype)
+            return 0
+        endif
+    endif
+
+    return 1
+endfunction
+
+" s:SetStatusLine() {{{2
+function! s:SetStatusLine()
+    " Make sure we're actually in the Tagbar window
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr == -1
+        return
+    endif
+    if tagbarwinnr != winnr()
+        let in_tagbar = 0
+        call s:goto_win(tagbarwinnr)
+    else
+        let in_tagbar = 1
+    endif
+
+    let sort = g:tagbar_sort ? 'Name' : 'Order'
+
+    if !empty(s:known_files.getCurrent(0))
+        let fname = fnamemodify(s:known_files.getCurrent(0).fpath, ':t')
+    else
+        let fname = ''
+    endif
+
+    let flags = []
+    let flags += exists('w:autoclose') && w:autoclose ? ['c'] : []
+    let flags += g:tagbar_autoclose ? ['C'] : []
+    let flags += (g:tagbar_sort && g:tagbar_case_insensitive) ? ['i'] : []
+    let flags += g:tagbar_hide_nonpublic ? ['v'] : []
+
+    if exists('g:tagbar_status_func')
+        let args = [in_tagbar, sort, fname, flags]
+        let &l:statusline = call(g:tagbar_status_func, args)
+    else
+        let colour = in_tagbar ? '%#StatusLine#' : '%#StatusLineNC#'
+        let flagstr = join(flags, '')
+        if flagstr != ''
+            let flagstr = '[' . flagstr . '] '
+        endif
+        let text = colour . '[' . sort . '] ' . flagstr . fname
+        let &l:statusline = text
+    endif
+
+    if !in_tagbar
+        call s:goto_win('p')
+    endif
+endfunction
+
+" s:QuitIfOnlyWindow() {{{2
+function! s:QuitIfOnlyWindow() abort
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr == -1
+        return
+    endif
+
+    let curwinnr = winnr()
+    let prevwinnr = winnr('#') == 0 ? curwinnr : winnr('#')
+    call s:goto_win(tagbarwinnr, 1)
+
+    " Check if there is more than one window
+    if s:NextNormalWindow() == -1
+        " Check if there is more than one tab page
+        if tabpagenr('$') == 1
+            " Before quitting Vim, delete the tagbar buffer so that
+            " the '0 mark is correctly set to the previous buffer.
+            " Also disable autocmd on this command to avoid unnecessary
+            " autocmd nesting.
+            if winnr('$') == 1
+                noautocmd bdelete
+            endif
+            quit
+        else
+            close
+        endif
+    endif
+
+    " Check that prevwinnr is still a valid window number
+    if prevwinnr != tagbarwinnr && prevwinnr <= winnr('$')
+        call s:goto_win(prevwinnr, 1)
+    endif
+
+    " Check that curwinnr is still a valid window number
+    if curwinnr <= winnr('$')
+        call s:goto_win(curwinnr, 1)
+    endif
+endfunction
+
+" s:NextNormalWindow() {{{2
+function! s:NextNormalWindow() abort
+    for i in range(1, winnr('$'))
+        let buf = winbufnr(i)
+
+        " skip unlisted buffers, except for netrw
+        if !buflisted(buf) && getbufvar(buf, '&filetype') != 'netrw'
+            continue
+        endif
+
+        " skip temporary buffers with buftype set
+        if getbufvar(buf, '&buftype') != ''
+            continue
+        endif
+
+        " skip the preview window
+        if getwinvar(i, '&previewwindow')
+            continue
+        endif
+
+        " skip current window
+        if i == winnr()
+            continue
+        endif
+
+        return i
+    endfor
+
+    return -1
+endfunction
+
+" s:goto_win() {{{2
+function! s:goto_win(winnr, ...) abort
+    let cmd = type(a:winnr) == type(0) ? a:winnr . 'wincmd w'
+                                     \ : 'wincmd ' . a:winnr
+    let noauto = a:0 > 0 ? a:1 : 0
+
+    call s:debug("goto_win(): " . cmd . ", " . noauto)
+
+    if noauto
+        noautocmd execute cmd
+    else
+        execute cmd
+    endif
+endfunction
+
+" s:goto_tagbar() {{{2
+function! s:goto_tagbar(...) abort
+    let noauto = a:0 > 0 ? a:1 : 0
+    call s:goto_win(bufwinnr('__Tagbar__'), noauto)
+endfunction
+
+" s:mark_window() {{{2
+" Mark window with a window-local variable so we can jump back to it even if
+" the window numbers have changed.
+function! s:mark_window() abort
+    let w:tagbar_mark = 1
+endfunction
+
+" s:goto_markedwin() {{{2
+" Go to a previously marked window and delete the mark.
+function! s:goto_markedwin(...) abort
+    let noauto = a:0 > 0 ? a:1 : 0
+    for window in range(1, winnr('$'))
+        call s:goto_win(window, noauto)
+        if exists('w:tagbar_mark')
+            unlet w:tagbar_mark
+            break
+        endif
+    endfor
+endfunction
+
+" s:warning() {{{2
+function! s:warning(msg) abort
+    echohl WarningMsg
+    echomsg a:msg
+    echohl None
+endfunction
+
+" TagbarBalloonExpr() {{{2
+function! TagbarBalloonExpr() abort
+    let taginfo = s:GetTagInfo(v:beval_lnum, 1)
+
+    if empty(taginfo)
+        return ''
+    endif
+
+    return taginfo.getPrototype(0)
+endfunction
+
+" Debugging {{{1
+" s:StartDebug() {{{2
+function! s:StartDebug(filename) abort
+    if empty(a:filename)
+        let s:debug_file = 'tagbardebug.log'
+    else
+        let s:debug_file = a:filename
+    endif
+
+    " Empty log file
+    exe 'redir! > ' . s:debug_file
+    redir END
+
+    " Check whether the log file could be created
+    if !filewritable(s:debug_file)
+        echomsg 'Tagbar: Unable to create log file ' . s:debug_file
+        let s:debug_file = ''
+        return
+    endif
+
+    let s:debug = 1
+endfunction
+
+" s:StopDebug() {{{2
+function! s:StopDebug() abort
+    let s:debug = 0
+    let s:debug_file = ''
+endfunction
+
+" s:debug() {{{2
+if has('reltime')
+    function! s:gettime() abort
+        let time = split(reltimestr(reltime()), '\.')
+        return strftime('%Y-%m-%d %H:%M:%S.', time[0]) . time[1]
+    endfunction
+else
+    function! s:gettime() abort
+        return strftime('%Y-%m-%d %H:%M:%S')
+    endfunction
+endif
+function! s:debug(msg) abort
+    if s:debug
+        execute 'redir >> ' . s:debug_file
+        silent echon s:gettime() . ': ' . a:msg . "\n"
+        redir END
+    endif
+endfunction
+
+" Autoload functions {{{1
+
+" Wrappers {{{2
+function! tagbar#ToggleWindow() abort
+    call s:ToggleWindow()
+endfunction
+
+function! tagbar#OpenWindow(...) abort
+    let flags = a:0 > 0 ? a:1 : ''
+    call s:OpenWindow(flags)
+endfunction
+
+function! tagbar#CloseWindow() abort
+    call s:CloseWindow()
+endfunction
+
+function! tagbar#SetFoldLevel(level, force) abort
+    call s:SetFoldLevel(a:level, a:force)
+endfunction
+
+function! tagbar#highlighttag(openfolds, force) abort
+    let tagbarwinnr = bufwinnr('__Tagbar__')
+    if tagbarwinnr == -1
+        echohl WarningMsg
+        echomsg "Warning: Can't highlight tag, Tagbar window not open"
+        echohl None
+        return
+    endif
+    call s:HighlightTag(a:openfolds, a:force)
+endfunction
+
+function! tagbar#StartDebug(...) abort
+    let filename = a:0 > 0 ? a:1 : ''
+    call s:StartDebug(filename)
+endfunction
+
+function! tagbar#StopDebug() abort
+    call s:StopDebug()
+endfunction
+
+function! tagbar#RestoreSession() abort
+    call s:RestoreSession()
+endfunction
+
+" }}}2
+
+" tagbar#toggle_pause() {{{2
+function! tagbar#toggle_pause() abort
+    let s:paused = !s:paused
+
+    if s:paused
+        call s:known_files.setPaused()
+    else
+        call s:AutoUpdate(fnamemodify(expand('%'), ':p'), 1)
+    endif
+endfunction
+
+" tagbar#getusertypes() {{{2
+function! tagbar#getusertypes() abort
+    let userdefs = filter(copy(g:), 'v:key =~ "^tagbar_type_"')
+
+    let typedict = {}
+    for [key, val] in items(userdefs)
+        let type = substitute(key, '^tagbar_type_', '', '')
+        let typedict[type] = val
+    endfor
+
+    return typedict
+endfunction
+
+" tagbar#autoopen() {{{2
+" Automatically open Tagbar if one of the open buffers contains a supported
+" file
+function! tagbar#autoopen(...) abort
+    call s:debug('tagbar#autoopen called [' . bufname('%') . ']')
+    let always = a:0 > 0 ? a:1 : 1
+
+    call s:Init(0)
+
+    for bufnr in range(1, bufnr('$'))
+        if buflisted(bufnr) && (always || bufwinnr(bufnr) != -1)
+            let ftype = s:DetectFiletype(bufnr)
+            if s:IsValidFile(bufname(bufnr), ftype)
+                call s:OpenWindow('')
+                call s:debug('tagbar#autoopen finished after finding valid ' .
+                           \ 'file [' . bufname(bufnr) . ']')
+                return
+            endif
+        endif
+    endfor
+
+    call s:debug('tagbar#autoopen finished without finding valid file')
+endfunction
+
+" tagbar#currenttag() {{{2
+function! tagbar#currenttag(fmt, default, ...) abort
+    " Indicate that the statusline functionality is being used. This prevents
+    " the CloseWindow() function from removing the autocommands.
+    let s:statusline_in_use = 1
+
+    if a:0 > 0
+        " also test for non-zero value for backwards compatibility
+        let longsig   = a:1 =~# 's' || (type(a:1) == type(0) && a:1 != 0)
+        let fullpath  = a:1 =~# 'f'
+        let prototype = a:1 =~# 'p'
+    else
+        let longsig   = 0
+        let fullpath  = 0
+        let prototype = 0
+    endif
+
+    if !s:Init(1)
+        return a:default
+    endif
+
+    let tag = s:GetNearbyTag(0, 1)
+
+    if !empty(tag)
+        if prototype
+            return tag.getPrototype(1)
+        else
+            return printf(a:fmt, tag.str(longsig, fullpath))
+        endif
+    else
+        return a:default
+    endif
+endfunction
+
+" tagbar#currentfile() {{{2
+function! tagbar#currentfile() abort
+    let filename = ''
+
+    if !empty(s:known_files.getCurrent(1))
+        let filename = fnamemodify(s:known_files.getCurrent(1).fpath, ':t')
+    endif
+
+    return filename
+endfunction
+
+" tagbar#gettypeconfig() {{{2
+function! tagbar#gettypeconfig(type) abort
+    if !s:Init(1)
+        return ''
+    endif
+
+    let typeinfo = get(s:known_types, a:type, {})
+
+    if empty(typeinfo)
+        call s:warning('Unknown type ' . a:type . '!')
+        return
+    endif
+
+    let output = "let g:tagbar_type_" . a:type . " = {\n"
+
+    let output .= "    \\ 'kinds' : [\n"
+    for kind in typeinfo.kinds
+        let output .= "        \\ '" . kind.short . ":" . kind.long
+        if kind.fold || !kind.stl
+            if kind.fold
+                let output .= ":1"
+            else
+                let output .= ":0"
+            endif
+        endif
+        if !kind.stl
+            let output .= ":0"
+        endif
+        let output .= "',\n"
+    endfor
+    let output .= "    \\ ],\n"
+
+    let output .= "\\ }"
+
+    silent put =output
+endfunction
+
+" tagbar#inspect() {{{2
+function! tagbar#inspect(var) abort
+    return get(s:, a:var)
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
diff --git a/vim/.vim/bundle/tagbar/doc/tagbar.txt b/vim/.vim/bundle/tagbar/doc/tagbar.txt
new file mode 100644
index 0000000..b9a11d6
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/doc/tagbar.txt
@@ -0,0 +1,1520 @@
+*tagbar.txt*    Display tags of a file ordered by scope
+
+Author:         Jan Larres <jan@majutsushi.net>
+Licence:        Vim licence, see |license|
+Homepage:       http://majutsushi.github.com/tagbar/
+Version:        2.6.1
+
+==============================================================================
+Contents                                            *tagbar* *tagbar-contents*
+
+         1. Intro ........................... |tagbar-intro|
+              Pseudo-tags ................... |tagbar-pseudotags|
+              Supported features ............ |tagbar-features|
+              Other ctags-compatible programs |tagbar-other|
+         2. Requirements .................... |tagbar-requirements|
+         3. Installation .................... |tagbar-installation|
+         4. Usage ........................... |tagbar-usage|
+              Commands ...................... |tagbar-commands|
+              Key mappings .................. |tagbar-keys|
+         5. Configuration ................... |tagbar-configuration|
+              Highlight colours ............. |tagbar-highlight|
+              Automatically opening Tagbar .. |tagbar-autoopen|
+              Show current tag in statusline  |tagbar-statusline|
+              Ignoring specific files ....... |tagbar-ignore|
+         6. Extending Tagbar ................ |tagbar-extend|
+         7. Troubleshooting & Known issues .. |tagbar-issues|
+         8. History ......................... |tagbar-history|
+         9. Todo ............................ |tagbar-todo|
+        10. Credits ......................... |tagbar-credits|
+
+==============================================================================
+1. Intro                                                        *tagbar-intro*
+
+Tagbar is a plugin for browsing the tags of source code files. It provides a
+sidebar that displays the ctags-generated tags of the current file, ordered by
+their scope. This means that for example methods in C++ are displayed under
+the class they are defined in.
+
+Let's say we have the following code inside of a C++ file:
+>
+        namespace {
+            char a;
+
+            class Foo
+            {
+            public:
+                Foo();
+                ~Foo();
+            private:
+                int var;
+            };
+        };
+<
+Then Tagbar would display the tag information like so:
+>
+        __anon1* : namespace
+          Foo : class
+           +Foo()
+           +~Foo()
+           -var
+          a
+<
+This example shows several important points. First, the tags are listed
+indented below the scope they are defined in. Second, the type of a scope is
+listed after its name and a colon. Third, tags for which the visibility
+information is known are prefixed with a symbol indicating that.
+
+------------------------------------------------------------------------------
+PSEUDO-TAGS                                                *tagbar-pseudotags*
+
+The example also introduces the concept of "pseudo-tags". Pseudo-tags are tags
+that are not explicitly defined in the file but have children in it. In this
+example the namespace doesn't have a name and thus ctags doesn't generate a
+tag for it, but since it has children it still needs to be displayed using an
+auto-generated name.
+
+Another case where pseudo-tags appear is in C++ implementation files. Since
+classes are usually defined in a header file but the member methods and
+variables in the implementation file the class itself won't generate a tag
+in that file.
+
+Since pseudo-tags don't really exist they cannot be jumped to from the Tagbar
+window.
+
+Pseudo-tags are denoted with an asterisk ('*') at the end of their name.
+
+------------------------------------------------------------------------------
+SUPPORTED FEATURES                                           *tagbar-features*
+
+The following features are supported by Tagbar:
+
+  - Display tags under their correct scope.
+  - Automatically update the tags when switching between buffers and editing
+    files.
+  - Display visibility information of tags if available.
+  - Highlight the tag near the cursor while editing files.
+  - Jump to a tag from the Tagbar window.
+  - Display the complete prototype of a tag.
+  - Tags can be sorted either by name or order of appearance in the file.
+  - Scopes can be folded to hide uninteresting information.
+  - Supports all of the languages that ctags does, i.e. Ant, Assembler, ASP,
+    Awk, Basic, BETA, C, C++, C#, COBOL, DosBatch, Eiffel, Erlang, Flex,
+    Fortran, HTML, Java, JavaScript, Lisp, Lua, Make, MatLab, OCaml, Pascal,
+    Perl, PHP, Python, REXX, Ruby, Scheme, Shell script, SLang, SML, SQL, Tcl,
+    Tex, Vera, Verilog, VHDL, Vim and YACC.
+  - Can be extended to support arbitrary new types.
+
+------------------------------------------------------------------------------
+OTHER CTAGS-COMPATIBLE PROGRAMS                                 *tagbar-other*
+
+Tagbar also supports filetype-specific programs that can produce
+ctags-compatible output, as long as these programs can write to the standard
+output. Tagbar has been tested with doctorjs/jsctags and will use that if
+present, other programs require some configuration (see |tagbar-extend|). If a
+program does not work even with correct configuration please contact me.
+
+Note: Please check |tagbar-issues| for some potential issues with jsctags.
+
+==============================================================================
+2. Requirements                                          *tagbar-requirements*
+
+The following requirements have to be met in order to be able to use tagbar:
+
+  - Vim 7.0 or higher. Older versions will not work since Tagbar uses data
+    structures that were only introduced in Vim 7.
+  - Exuberant ctags 5.5 or higher. Ctags is the program that generates the
+    tag information that Tagbar uses. It is shipped with most Linux
+    distributions, otherwise it can be downloaded from the following
+    website:
+
+        http://ctags.sourceforge.net/
+
+    Tagbar will work on any platform that ctags runs on -- this includes
+    UNIX derivatives, Mac OS X and Windows. Note that other versions like
+    BSD ctags will not work.
+    Tagbar generates the tag information by itself and doesn't need (or use)
+    already existing tag files.
+  - File type detection must be turned on in vim. This can be done with the
+    following command in your vimrc:
+>
+        filetype on
+<
+    See |filetype| for more information.
+  - Tagbar will not work in |restricted-mode| or with 'compatible' set.
+
+==============================================================================
+3. Installation                                          *tagbar-installation*
+
+Use the normal Vimball install method for installing tagbar.vba:
+>
+        vim tagbar.vba
+        :so %
+        :q
+<
+Alternatively you can clone the git repository and then add the path to
+'runtimepath' or use the pathogen plugin. Don't forget to run |:helptags|.
+
+If the ctags executable is not installed in one of the directories in your
+$PATH environment variable you have to set the g:tagbar_ctags_bin variable,
+see |g:tagbar_ctags_bin|.
+
+==============================================================================
+4. Usage                                                        *tagbar-usage*
+
+There are essentially two ways to use Tagbar:
+
+  1. Have it running all the time in a window on the side of the screen. In
+     this case Tagbar will update its contents whenever the source file is
+     changed and highlight the tag the cursor is currently on in the file. If
+     a tag is selected in Tagbar the file window will jump to the tag and the
+     Tagbar window will stay open. |g:tagbar_autoclose| has to be unset for
+     this mode.
+  2. Only open Tagbar when you want to jump to a specific tag and have it
+     close automatically once you have selected one. This can be useful for
+     example for small screens where a permanent window would take up too much
+     space. You have to set the option |g:tagbar_autoclose| in this case. The
+     cursor will also automatically jump to the Tagbar window when opening it.
+
+Opening and closing the Tagbar window~
+Use |:TagbarOpen| or |:TagbarToggle| to open the Tagbar window if it is
+closed. By default the window is opened on the right side, set the option
+|g:tagbar_left| to open it on the left instead. If the window is already open,
+|:TagbarOpen| will jump to it and |:TagbarToggle| will close it again.
+|:TagbarClose| will simply close the window if it is open.
+
+It is probably a good idea to assign a key to these commands. For example, put
+this into your |vimrc|:
+>
+        nnoremap <silent> <F9> :TagbarToggle<CR>
+<
+You can then open and close Tagbar by simply pressing the <F9> key.
+
+You can also use |:TagbarOpenAutoClose| to open the Tagbar window, jump to it
+and have it close automatically on tag selection regardless of the
+|g:tagbar_autoclose| setting.
+
+Pausing the Tagbar window~
+Use |:TagbarTogglePause| to toggle freezing/locking the Tagbar window on its
+currently displayed file. Freezing the window stops the Tagbar contents from
+changing when switching to a different source file. All Tagbar functionality
+continues to work as expected. Unfreezing the window will cause it to load the
+current source file.
+
+Jumping to tags~
+When you're inside the Tagbar window you can jump to the definition of a tag
+by moving the cursor to a tag and pressing <Enter> or double-clicking on it
+with the mouse. The source file will then move to the definition and put the
+cursor in the corresponding line. This won't work for pseudo-tags.
+
+Sorting~
+You can sort the tags in the Tagbar window in two ways: by name or by file
+order. Sorting them by name simply displays the tags in their alphabetical
+order under their corresponding scope. Sorting by file order means that the
+tags keep the order they have in the source file, but are still associated
+with the correct scope. You can change the sort order by pressing the "s" key
+in the Tagbar window. The current sort order is displayed in the statusline of
+the Tagbar window.
+
+Folding~
+The displayed scopes (and unscoped types) can be folded to hide uninteresting
+information. Mappings similar to Vim's built-in ones are provided. Folds can
+also be opened and closed by clicking on the fold icon with the mouse.
+
+Highlighting the current tag~
+When the Tagbar window is open the current tag will automatically be
+highlighted in it after a short pause if the cursor is not moving. The length
+of this pause is determined by the 'updatetime' option. If you want to make
+that pause shorter you can change the option, but don't set it too low or
+strange things will happen. This is unfortunately unavoidable.
+
+Displaying the prototype of a tag~
+Tagbar can display the prototype of a tag. More precisely it can display the
+line(s) in which the tag is defined. This can be done by either pressing
+<Space> when on a tag or hovering over a tag with the mouse. In the former
+case the prototype will be displayed in the |Command-line|, in the latter case
+it will be displayed in a pop-up window. The prototype will also be displayed
+if the cursor stays on a tag for 'updatetime' milliseconds. In that case the
+prototype may be abbreviated in order to avoid |hit-enter| prompts.
+
+------------------------------------------------------------------------------
+COMMANDS                                                     *tagbar-commands*
+
+:TagbarOpen [{flags}]                                            *:TagbarOpen*
+    Open the Tagbar window if it is closed.
+
+    Additional behaviour can be specified with the optional {flags} argument.
+    It is a string which can contain these character flags:
+    'f'   Jump to Tagbar window when opening (just as if |g:tagbar_autofocus|
+          were set to 1)
+    'j'   Jump to Tagbar window if already open
+    'c'   Close Tagbar on tag selection (just as if |g:tagbar_autoclose| were
+          set to 1, but doesn't imply 'f'), but only if the Tagbar window was
+          opened using this command. If this is used the "c" flag will be
+          shown in the statusline of the Tagbar window.
+
+    For example, the following command would always jump to the Tagbar window,
+    opening it first if necessary, but keep it open after selecting a tag
+    (unless |g:tagbar_autoclose| is set): >
+        :TagbarOpen fj
+<
+:TagbarClose                                                    *:TagbarClose*
+    Close the Tagbar window if it is open.
+
+:TagbarToggle                                                  *:TagbarToggle*
+:Tagbar
+    Open the Tagbar window if it is closed, or close it if it is open.
+
+:TagbarOpenAutoClose                                    *:TagbarOpenAutoClose*
+    Open the Tagbar window, jump to it and close it on tag selection. This is
+    an alias for ":TagbarOpen fjc".
+
+:TagbarTogglePause                                        *:TagbarTogglePause*
+    Freezes/Unfreezes the Tagbar window.  Stops the contents of the window
+    from changing when a different source file is selected.
+
+:TagbarSetFoldlevel[!] {number}                          *:TagbarSetFoldlevel*
+    Set the foldlevel of the tags of the current file to {number}. The
+    foldlevel of tags in other files remains unaffected. Works in the same way
+    as 'foldlevel'. Folds that are specified to be closed by default in the
+    type configuration will not be opened, use a "!" to force applying the new
+    foldlevel to those folds as well.
+
+:TagbarShowTag                                                *:TagbarShowTag*
+    Open the parent folds of the current tag in the file window as much as
+    needed for the tag to be visible in the Tagbar window.
+
+:TagbarCurrentTag [{flags}]                                *:TagbarCurrentTag*
+    Echo the current tag in the command line. For {flags} see
+    |tagbar-statusline|.
+
+:TagbarGetTypeConfig {filetype}                         *:TagbarGetTypeConfig*
+    Paste the Tagbar configuration of the vim filetype {filetype} at the
+    current cursor position (provided that filetype is supported by Tagbar)
+    for easy customization. The configuration will be ready to use as is but
+    will only contain the "kinds" entry as that is the only one that really
+    makes sense to customize. See |tagbar-extend| for more information about
+    type configurations.
+
+:TagbarDebug [logfile]                                          *:TagbarDebug*
+    Start debug mode. This will write debug messages to file [logfile] while
+    using Tagbar. If no argument is given "tagbardebug.log" in the current
+    directory is used. Note: an existing file will be overwritten!
+    Note also that it is usually necessary to call this command before loading
+    a file that creates problems in order to get all of the needed data.
+
+:TagbarDebugEnd                                              *:TagbarDebugEnd*
+    End debug mode, debug messages will no longer be written to the logfile.
+
+------------------------------------------------------------------------------
+KEY MAPPINGS                                                     *tagbar-keys*
+
+The following mappings are valid in the Tagbar window:
+
+<F1>/?        Display key mapping help.
+                Map option: tagbar_map_help
+<CR>/<Enter>  Jump to the tag under the cursor. Doesn't work for pseudo-tags
+              or generic headers.
+                Map option: tagbar_map_jump
+p             Jump to the tag under the cursor, but stay in the Tagbar window.
+                Map option: tagbar_map_preview
+P             Open the tag in a |preview-window|.
+                Map option: tagbar_map_previewwin
+<LeftMouse>   When on a fold icon, open or close the fold depending on the
+              current state.
+<2-LeftMouse> Same as <CR>. See |g:tagbar_singleclick| if you want to use a
+              single- instead of a double-click.
+<C-N>         Go to the next top-level tag.
+                Map option: tagbar_map_nexttag
+<C-P>         Go to the previous top-level tag.
+                Map option: tagbar_map_prevtag
+<Space>       Display the prototype of the current tag (i.e. the line defining
+              it) in the command line.
+                Map option: tagbar_map_showproto
+v             Hide tags that are declared non-public. Tags without any
+              visibility information will still be shown.
+                Map option: tagbar_map_hidenonpublic
++/zo          Open the fold under the cursor.
+                Map option: tagbar_map_openfold
+-/zc          Close the fold under the cursor or the current one if there is
+              no fold under the cursor.
+                Map option: tagbar_map_closefold
+o/za          Toggle the fold under the cursor or the current one if there is
+              no fold under the cursor.
+                Map option: tagbar_map_togglefold
+*/zR          Open all folds by setting foldlevel to 99.
+                Map option: tagbar_map_openallfolds
+=/zM          Close all folds by setting foldlevel to 0.
+                Map option: tagbar_map_closeallfolds
+zj            Go to the start of the next fold, like the standard Vim |zj|.
+                Map option: tagbar_map_nextfold
+zk            Go to the end of the previous fold, like the standard Vim |zk|.
+                Map option: tagbar_map_prevfold
+s             Toggle sort order between name and file order.
+                Map option: tagbar_map_togglesort
+c             Toggle the |g:tagbar_autoclose| option.
+                Map option: tagbar_map_toggleautoclose
+x             Toggle zooming the window.
+                Map option: tagbar_map_zoomwin
+q             Close the Tagbar window.
+                Map option: tagbar_map_close
+
+These mappings can be redefined with the given map options. The argument can
+be either a string or a |List| of strings. In the latter case the
+functionality will be assigned to all of the keys in the list. For example, if
+you want to remap the sort toggling functionality to "r":
+>
+        let g:tagbar_map_togglesort = "r"
+<
+See |key-notation| for how to write special keys like <Space> or the keypad
+keys.
+
+==============================================================================
+5. Configuration                                        *tagbar-configuration*
+
+                                                          *g:tagbar_ctags_bin*
+g:tagbar_ctags_bin~
+Default: empty
+
+Use this option to specify the location of your ctags executable. Only needed
+if it is not in one of the directories in your $PATH environment variable.
+
+Example:
+>
+        let g:tagbar_ctags_bin = 'C:\Ctags5.8\ctags.exe'
+<
+
+                                                               *g:tagbar_left*
+g:tagbar_left~
+Default: 0
+
+By default the Tagbar window will be opened on the right-hand side of vim. Set
+this option to open it on the left instead.
+
+If |g:tagbar_vertical| is used then setting this variable will open the Tagbar
+window at the top, otherwise it will open at the bottom.
+
+Example:
+>
+        let g:tagbar_left = 1
+<
+
+                                                           *g:tagbar_vertical*
+g:tagbar_vertical~
+Default: 0
+
+If this is set to a positive value then the Tagbar window will be opened at
+the top or bottom of the Vim window instead of at the side. This can be useful
+for monitors that have been rotated into a vertical position. The value of
+this variable will determine the number of lines to use for the Tagbar window.
+See |g:tagbar_left| for configuring the position of the window.
+
+Example:
+>
+        let g:tagbar_vertical = 30
+<
+
+                                                              *g:tagbar_width*
+g:tagbar_width~
+Default: 40
+
+Width of the Tagbar window in characters.
+
+Example:
+>
+        let g:tagbar_width = 30
+<
+
+                                                          *g:tagbar_zoomwidth*
+g:tagbar_zoomwidth~
+Default: 1
+
+Width of the Tagbar window when zoomed.
+
+Possible values are:
+  1: Use the maximum width available.
+  0: Use the width of the longest currently visible tag.
+  >1: Use this width in characters.
+
+Example:
+>
+        let g:tagbar_zoomwidth = 0
+<
+
+                                                          *g:tagbar_autoclose*
+g:tagbar_autoclose~
+Default: 0
+
+If you set this option the Tagbar window will automatically close when you
+jump to a tag. This implies |g:tagbar_autofocus|. If enabled the "C" flag will
+be shown in the statusline of the Tagbar window. This can also be toggled with
+a key, see |tagbar-keys|.
+
+Example:
+>
+        let g:tagbar_autoclose = 1
+<
+
+                                                          *g:tagbar_autofocus*
+g:tagbar_autofocus~
+Default: 0
+
+If you set this option the cursor will move to the Tagbar window when it is
+opened.
+
+Example:
+>
+        let g:tagbar_autofocus = 1
+<
+
+                                                               *g:tagbar_sort*
+g:tagbar_sort~
+Default: 1
+
+If this option is set the tags are sorted according to their name. If it is
+unset they are sorted according to their order in the source file. Note that
+in the second case Pseudo-tags are always sorted before normal tags of the
+same kind since they don't have a real position in the file.
+
+Example:
+>
+        let g:tagbar_sort = 0
+<
+
+                                                   *g:tagbar_case_insensitive*
+g:tagbar_case_insensitive~
+Default: 0
+
+If this option is set a case-insensitive comparison is used when the tags
+are sorted according to their name. If it is unset a case-sensitive
+comparison is used.
+
+Example:
+>
+        let g:tagbar_case_insensitive = 1
+<
+                                                            *g:tagbar_compact*
+g:tagbar_compact~
+Default: 0
+
+Setting this option will result in Tagbar omitting the short help at the
+top of the window and the blank lines in between top-level scopes in order to
+save screen real estate.
+
+Example:
+>
+        let g:tagbar_compact = 1
+<
+
+                                                             *g:tagbar_indent*
+g:tagbar_indent~
+Default: 2
+
+The number of spaces by which each level is indented. This allows making the
+display more compact or more spacious.
+
+Example:
+>
+        let g:tagbar_indent = 1
+<
+
+                                                    *g:tagbar_show_visibility*
+g:tagbar_show_visibility~
+Default: 1
+
+Show the visibility symbols (public/protected/private) to the left of the tag
+name.
+
+Example:
+>
+        let g:tagbar_show_visibility = 0
+<
+
+                                                   *g:tagbar_show_linenumbers*
+g:tagbar_show_linenumbers~
+Default: 0
+
+Whether line numbers should be shown in the Tagbar window.
+
+Possible values are:
+  0: Don't show any line numbers.
+  1: Show absolute line numbers.
+  2: Show relative line numbers.
+  -1: Use the global line number settings.
+
+Example:
+>
+        let g:tagbar_show_linenumbers = 2
+<
+
+                                                     *g:tagbar_hide_nonpublic*
+g:tagbar_hide_nonpublic~
+Default: 0
+
+Hide tags that are declared non-public. Tags without any visibility
+information will still be shown. If enabled the "v" flag will be shown in the
+statusline of the Tagbar window. This can also be toggled with a key, see
+|tagbar-keys|.
+
+Example:
+>
+        let g:tagbar_hide_nonpublic = 1
+<
+
+                                                             *g:tagbar_expand*
+g:tagbar_expand~
+Default: 0
+
+If this option is set to 1 the Vim window will be expanded by the width of the
+Tagbar window if using a GUI version of Vim. Setting it to 2 will also try
+expanding a terminal, but note that this is not supported by all terminals.
+See also |xterm-resize|.
+
+Example:
+>
+        let g:tagbar_expand = 1
+<
+
+                                                        *g:tagbar_singleclick*
+g:tagbar_singleclick~
+Default: 0
+
+If this option is set then a single- instead of a double-click is used to jump
+to the tag definition.
+
+Example:
+>
+        let g:tagbar_singleclick = 1
+<
+
+                                                          *g:tagbar_foldlevel*
+g:tagbar_foldlevel~
+Default: 99
+
+The initial foldlevel for folds in the Tagbar window. Folds with a level
+higher than this number will be closed.
+
+Example:
+>
+        let g:tagbar_foldlevel = 2
+<
+
+                                                          *g:tagbar_iconchars*
+g:tagbar_iconchars~
+
+Since the display of the icons used to indicate open or closed folds depends
+on the actual font used, different characters may be optimal for different
+fonts. With this variable you can set the icons to characters of your liking.
+The first character in the list specifies the icon to use for a closed fold,
+and the second one for an open fold.
+
+Examples (don't worry if some of the characters aren't displayed correctly,
+just choose other characters in that case):
+>
+        let g:tagbar_iconchars = ['▶', '▼']  (default on Linux and Mac OS X)
+        let g:tagbar_iconchars = ['▸', '▾']
+        let g:tagbar_iconchars = ['▷', '◢']
+        let g:tagbar_iconchars = ['+', '-']  (default on Windows)
+<
+
+                                                        *g:tagbar_autoshowtag*
+g:tagbar_autoshowtag~
+Default: 0
+
+If this variable is set to 1 and the current tag is inside of a closed fold
+then the folds will be opened as much as needed for the tag to be visible so
+it can be highlighted. If it is set to 0 then the folds will only be opened
+when opening the Tagbar window and the current tag is inside a closed fold,
+otherwise the folds won't be opened and the parent tag will be highlighted
+instead. If it is set to 2 then the folds will never be opened automatically.
+
+You can use the |:TagbarShowTag| command to open the folds manually.
+
+Example:
+>
+        let g:tagbar_autoshowtag = 1
+<
+
+                                                     *g:tagbar_previewwin_pos*
+g:tagbar_previewwin_pos~
+Default: "topleft", or "rightbelow vertical" if |g:tagbar_vertical| is set
+
+The position of the preview window. Valid values are the window splitting
+commands that are described starting from |:vertical|. Set it to an empty
+string to use the options 'splitbelow' and 'splitright'.
+
+Example:
+>
+        let g:tagbar_previewwin_pos = "aboveleft"
+<
+If you want to disable line numbers in the preview window put something like
+this into your vimrc:
+>
+        autocmd BufWinEnter * if &previewwindow | setlocal nonumber | endif
+<
+
+                                                        *g:tagbar_autopreview*
+g:tagbar_autopreview~
+Default: 0
+
+If this variable is set to 1 then moving the cursor in the Tagbar window will
+automatically show the current tag in the preview window.
+
+Example:
+>
+        let g:tagbar_autopreview = 1
+<
+
+                                              *g:tagbar_updateonsave_maxlines*
+g:tagbar_updateonsave_maxlines~
+
+Deprecated. Tagbar will now always get updated when the file is being saved.
+
+
+                                                          *g:tagbar_systemenc*
+g:tagbar_systemenc~
+Default: value of 'encoding'
+
+This variable is for cases where the character encoding of your operating
+system is different from the one set in Vim, i.e. the 'encoding' option. For
+example, if you use a Simplified Chinese Windows version that has a system
+encoding of "cp936", and you have set 'encoding' to "utf-8", then you would
+have to set this variable to "cp936".
+Note that this requires Vim to be compiled with the |+multi_byte| and |+iconv|
+features to work.
+
+Example:
+>
+        let g:tagbar_systemenc = 'cp936'
+<
+
+                                                        *g:tagbar_status_func*
+g:tagbar_status_func~
+Default: undefined
+
+This is the name of a function whose return value will be used to draw the
+statusline of the Tagbar window.
+
+The function has to take four arguments:
+  1. current: Whether Tagbar is the current window; 0 or 1.
+  2. sort: The sort order of the tags; 'Name' if they are sorted by name and
+     'Order' if they are sorted by their order of appearance in the file.
+  3. fname: The name of the file that the tags belong to.
+  4. flags: A list of characters that represent various state in the Tagbar
+     window.
+
+In order to avoid possible future additions to the arguments resulting in an
+error it is recommended to add an additional vararg to the signature (see
+|a:0|).
+
+Here is an example that, when put into your vimrc, will emulate Tagbar's
+default statusline:
+>
+        function! TagbarStatusFunc(current, sort, fname, flags, ...) abort
+            let colour = a:current ? '%#StatusLine#' : '%#StatusLineNC#'
+            let flagstr = join(flags, '')
+            if flagstr != ''
+                let flagstr = '[' . flagstr . '] '
+            endif
+            return colour . '[' . sort . '] ' . flagstr . fname
+        endfunction
+        let g:tagbar_status_func = 'TagbarStatusFunc'
+<
+
+------------------------------------------------------------------------------
+HIGHLIGHT COLOURS                                           *tagbar-highlight*
+
+All of the colours used by Tagbar can be customized. Here is a list of the
+highlight groups that are defined by Tagbar:
+
+TagbarComment
+    The help at the top of the buffer.
+
+TagbarKind
+    The header of generic "kinds" like "functions" and "variables".
+
+TagbarNestedKind
+    The "kind" headers in square brackets inside of scopes.
+
+TagbarScope
+    Tags that define a scope like classes, structs etc.
+
+TagbarType
+    The type of a tag or scope if available.
+
+TagbarSignature
+    Function signatures.
+
+TagbarPseudoID
+    The asterisk (*) that signifies a pseudo-tag.
+
+TagbarFoldIcon
+    The fold icon on the left of foldable tags.
+
+TagbarHighlight
+    The colour that is used for automatically highlighting the current tag.
+
+TagbarVisibilityPublic
+    The "public" visibility symbol.
+
+TagbarVisibilityProtected
+    The "protected" visibility symbol.
+
+TagbarVisibilityPrivate
+    The "private" visibility symbol.
+
+If you want to change any of those colours put a line like the following in
+your vimrc:
+>
+        highlight TagbarScope guifg=Green ctermfg=Green
+<
+See |:highlight| for more information.
+
+------------------------------------------------------------------------------
+AUTOMATICALLY OPENING TAGBAR                                 *tagbar-autoopen*
+
+Since there are several different situations in which you might want to open
+Tagbar automatically there is no single option to enable automatic opening.
+Instead, autocommands can be used together with a convenience function that
+opens Tagbar only if a supported file is open(ed). It has a boolean parameter
+that specifies whether Tagbar should be opened if any loaded buffer is
+supported (in case the parameter is set to true) or only if a supported
+file/buffer is currently being shown in a window. This can be useful if you
+use multiple tabs and don't edit supported files in all of them.
+
+If you want to open Tagbar automatically on Vim startup no matter what put
+this into your vimrc:
+>
+        autocmd VimEnter * nested :TagbarOpen
+<
+If you want to open it only if you're opening Vim with a supported file/files
+use this instead:
+>
+        autocmd VimEnter * nested :call tagbar#autoopen(1)
+<
+The above is exactly what the Taglist plugin does if you set the
+Tlist_Auto_Open option, in case you want to emulate this behaviour.
+
+For opening Tagbar also if you open a supported file in an already running
+Vim:
+>
+        autocmd FileType * nested :call tagbar#autoopen(0)
+<
+If you use multiple tabs and want Tagbar to also open in the current tab when
+you switch to an already loaded, supported buffer:
+>
+        autocmd BufEnter * nested :call tagbar#autoopen(0)
+<
+And if you want to open Tagbar only for specific filetypes, not for all of the
+supported ones:
+>
+        autocmd FileType c,cpp nested :TagbarOpen
+<
+Check out |autocmd.txt| if you want it to open automatically in more
+complicated cases.
+
+------------------------------------------------------------------------------
+SHOWING THE CURRENT TAG IN THE STATUSLINE                  *tagbar-statusline*
+
+You can show the current tag in the 'statusline', or in any other place that
+you want to, by calling the tagbar#currenttag() function. The current tag is
+exactly the same as would be highlighted in the Tagbar window if it is open.
+It is defined as the nearest tag upwards in the file starting from the cursor
+position. This means that for example in a function it should usually be the
+name of the function. You can define which tags will be shown in this manner,
+read |tagbar-extend| (especially the "kinds" entry) on how to do that.
+
+The function has the following signature:
+
+tagbar#currenttag({format}, {default} [, {flags}])
+    {format} is a |printf()|-compatible format string where "%s" will be
+    replaced by the name of the tag. {default} will be displayed instead of
+    the format string if no tag can be found.
+
+    The optional {flags} argument specifies some additional properties of the
+    displayed tags. It is a string which can contain these character flags:
+    'f'   Display the full hierarchy of the tag, not just the tag itself.
+    's'   If the tag is a function, the complete signature will be shown,
+          otherwise just "()" will be appended to distinguish functions from
+          other tags.
+    'p'   Display the raw prototype instead of the parsed tag. This can be
+          useful in cases where ctags doesn't report some information, like
+          the signature. Note that this can get quite long.
+
+    For example, if you put the following into your statusline: >
+        %{tagbar#currenttag('[%s] ','')}
+<   then the function "myfunc" will be shown as "[myfunc()] ".
+
+Note that if there is an error when processing the current file no error
+message will be shown in order to not disrupt the statusline. If the function
+doesn't seem to work right open the Tagbar window to see any error messages.
+
+------------------------------------------------------------------------------
+IGNORING SPECIFIC FILES                                        *tagbar-ignore*
+
+You can ignore specific files by setting the |buffer-variable|
+"b:tagbar_ignore" to 1. This is best done with an |autocommand|:
+>
+    autocmd BufNewFile,BufReadPost foo.cpp let b:tagbar_ignore = 1
+<
+Note that autocommands are order-sensitive, so make sure that this autocommand
+gets defined before the ones that Tagbar defines so the variable will get
+found at the right time.
+
+==============================================================================
+6. Extending Tagbar                                            *tagbar-extend*
+
+Tagbar has a flexible mechanism for extending the existing file type (i.e.
+language) definitions. This can be used both to change the settings of the
+existing types and to add completely new types. For Tagbar to support a
+filetype two things are needed: a program that generates the tag information,
+usually Exuberant Ctags, and a Tagbar type definition in your |vimrc| or an
+|ftplugin| that tells Tagbar how to interpret the generated tags.
+
+Note: if you only want to customize an existing definition (like changing the
+order in which tag kinds are displayed) see "Changing an existing definition"
+below.
+
+There are two ways to generate the tag information for new filetypes: add a
+definition to Exuberant Ctags or create a specialized program for your
+language that generates ctags-compatible tag information (see
+|tags-file-format| for information about how a "tags" file is structured). The
+former allows simple regular expression-based parsing that is easy to get
+started with, but doesn't support scopes unless you instead want to write a
+C-based parser module for Exuberant Ctags. The regex approach is described in
+more detail below.
+Writing your own program is the approach used by for example jsctags and can
+be useful if your language can best be parsed by a program written in the
+language itself, or if you want to provide the program as part of a complete
+support package for the language. Some tips on how to write such a program are
+given at the end of this section.
+
+Before writing your own extension have a look at the wiki
+(https://github.com/majutsushi/tagbar/wiki) or try googling for existing ones.
+If you do end up creating your own extension please consider adding it to the
+wiki so that others can benefit from it, too.
+
+Every type definition in Tagbar is a dictionary with the following keys:
+
+ctagstype:  The name of the language as recognized by ctags. Use the command >
+                ctags --list-languages
+<           to get a list of the languages ctags supports. The case doesn't
+            matter.
+kinds:      A list of the "language kinds" that should be listed in Tagbar,
+            ordered by the order they should appear in in the Tagbar window.
+            Use the command >
+                ctags --list-kinds={language name}
+<           to get a list of the kinds ctags supports for a given language. An
+            entry in this list is a colon-separated string with the following
+            syntax: >
+                {short}:{long}[:{fold}[:{stl}]]
+<           {short} is the one-character abbreviation that ctags uses, and
+            {long} is an arbitrary string that will be used in Tagbar as the
+            header for the the tags of this kind that are not listed under a
+            specific scope. {fold} determines whether tags of this kind should
+            be folded by default, with 1 meaning they should be folded and 0
+            they should not. If this part is omitted the tags will not be
+            folded by default. {stl} is used by the tagbar#currenttag()
+            function (see |tagbar-statusline|) to decide whether tags of this
+            kind should be shown in the statusline or not, with 1 meaning they
+            will be shown and 0 meaning they will be ignored. Omitting this
+            part means that the tags will be shown. Note that you have to
+            specify {fold} too if you want to specify {stl}.
+            For example, the string >
+                "f:functions:1"
+<           would list all the function definitions in a file under the header
+            "functions", fold them, and implicitly show them in the statusline
+            if tagbar#currenttag() is used.
+sro:        The scope resolution operator. For example, in C++ it is "::" and
+            in Java it is ".". If in doubt run ctags as shown below and check
+            the output.
+kind2scope: A dictionary describing the mapping of tag kinds (in their
+            one-character representation) to the scopes their children will
+            appear in, for example classes, structs etc.
+            Unfortunately there is no ctags option to list the scopes, you
+            have to look at the tags ctags generates manually. For example,
+            let's say we have a C++ file "test.cpp" with the following
+            contents: >
+                class Foo
+                {
+                public:
+                    Foo();
+                    ~Foo();
+                private:
+                    int var;
+                };
+<           We then run ctags in the following way: >
+                ctags -f - --format=2 --excmd=pattern --extra= --fields=nksaSmt test.cpp
+<           Then the output for the variable "var" would look like this: >
+                var	tmp.cpp /^    int var;$/;"	kind:m	line:11	class:Foo	access:private
+<           This shows that the scope name for an entry in a C++ class is
+            simply "class". So this would be the word that the "kind"
+            character of a class has to be mapped to.
+scope2kind: The opposite of the above, mapping scopes to the kinds of their
+            parents. Most of the time it is the exact inverse of the above,
+            but in some cases it can be different, for example when more than
+            one kind maps to the same scope. If it is the exact inverse for
+            your language you only need to specify one of the two keys.
+replace:    If you set this entry to 1 your definition will completely replace
+{optional}  an existing default definition. This is useful if you want to
+            disable scopes for a file type for some reason. Note that in this
+            case you have to provide all the needed entries yourself!
+sort:       This entry can be used to override the global sort setting for
+{optional}  this specific file type. The meaning of the value is the same as
+            with the global setting, that is if you want to sort tags by name
+            set it to 1 and if you want to sort them according to their order
+            in the file set it to 0.
+deffile:    The path to a file with additional ctags definitions (see the
+{optional}  section below on adding a new definition for what exactly that
+            means). This is especially useful for ftplugins since they can
+            provide a complete type definition with ctags and Tagbar
+            configurations without requiring user intervention.
+            Let's say you have an ftplugin that adds support for the language
+            "mylang", and your directory structure looks like this: >
+                ctags/mylang.cnf
+                ftplugin/mylang.vim
+<           Then the "deffile" entry would look like this to allow for the
+            plugin to be installed in an arbitray location (for example
+            with pathogen): >
+
+                'deffile' : expand('<sfile>:p:h:h') . '/ctags/mylang.cnf'
+<
+ctagsbin:  The path to a filetype-specific ctags-compatible program like
+{optional} jsctags. Set it in the same way as |g:tagbar_ctags_bin|. jsctags is
+           used automatically if found in your $PATH and does not have to be
+           set in that case. If it is not in your path you have to set this
+           key, the rest of the configuration should not be necessary (unless
+           you want to change something, of course). Note: if you use this
+           then the "ctagstype" key is not needed.
+ctagsargs: The arguments to be passed to the filetype-specific ctags program
+{optional} (without the filename). Make sure you set an option that makes the
+           program output its data on stdout. Not used for the normal ctags
+           program.
+
+           The value of ctagsargs may be a |List| of strings (a string for
+           each argument), or a single string (|expr-string|) of all the
+           arguments.
+
+           When the value of ctagsargs is a list, tagbar.vim takes care of
+           escaping each argument in the list as required for the current
+           'shell' type.
+
+           When the value of ctagsargs is a string, it must be properly
+           escaped (if required by the current shell type). The reason
+           tagbar.vim does not attempt to escape the string in this case is
+           because if there is a space, it is ambiguous as to whether the
+           space is delimiting an argument or included in the argument. To
+           avoid this amiguity, tagbar.vim expects the string to be already
+           escaped as required.
+
+           If special escaping is required for different OS shell types or if
+           in doubt, then it is recommended to define ctagsargs with a List.
+
+
+You then have to assign this dictionary to a variable in your vimrc with the
+name
+>
+        g:tagbar_type_{vim filetype}
+<
+For example, for C++ the name would be "g:tagbar_type_cpp". If you don't know
+the vim file type then run the following command:
+>
+        :set filetype?
+<
+and vim will display the file type of the current buffer.
+
+Example: C++~
+Here is a complete example that shows the default configuration for C++ as
+used in Tagbar. This is just for illustration purposes since user
+configurations will usually be less complicated.
+>
+        let g:tagbar_type_cpp = {
+            \ 'ctagstype' : 'c++',
+            \ 'kinds'     : [
+                \ 'd:macros:1:0',
+                \ 'p:prototypes:1:0',
+                \ 'g:enums',
+                \ 'e:enumerators:0:0',
+                \ 't:typedefs:0:0',
+                \ 'n:namespaces',
+                \ 'c:classes',
+                \ 's:structs',
+                \ 'u:unions',
+                \ 'f:functions',
+                \ 'm:members:0:0',
+                \ 'v:variables:0:0'
+            \ ],
+            \ 'sro'        : '::',
+            \ 'kind2scope' : {
+                \ 'g' : 'enum',
+                \ 'n' : 'namespace',
+                \ 'c' : 'class',
+                \ 's' : 'struct',
+                \ 'u' : 'union'
+            \ },
+            \ 'scope2kind' : {
+                \ 'enum'      : 'g',
+                \ 'namespace' : 'n',
+                \ 'class'     : 'c',
+                \ 'struct'    : 's',
+                \ 'union'     : 'u'
+            \ }
+        \ }
+<
+
+Which of the keys you have to specify depends on what you want to do.
+
+Changing an existing definition~
+If you want to change an existing definition you only need to specify the
+parts that you want to change. It probably only makes sense to change "kinds",
+which would be the case if you wanted to for example change the order of
+certain kinds, change their default fold state or exclude them from appearing
+in Tagbar. The easiest way to do that is to use the |:TagbarGetTypeConfig|
+command, which will paste a ready-to-use configuration with the "kinds" entry
+for the specified type at the current cursor position.
+
+As an example, if you didn't want Tagbar to show prototypes for C++ files,
+switch the order of enums and typedefs, and show macros in the statusline, you
+would first run ":TagbarGetTypeConfig cpp" in your vimrc and then change the
+definition like this:
+>
+        let g:tagbar_type_cpp = {
+            \ 'kinds' : [
+                \ 'd:macros:1',
+                \ 'g:enums',
+                \ 't:typedefs:0:0',
+                \ 'e:enumerators:0:0',
+                \ 'n:namespaces',
+                \ 'c:classes',
+                \ 's:structs',
+                \ 'u:unions',
+                \ 'f:functions',
+                \ 'm:members:0:0',
+                \ 'v:variables:0:0'
+            \ ]
+        \ }
+<
+Compare with the complete example above to see the difference.
+
+Adding a definition for a new language/file type~
+In order to be able to add a new language to Tagbar you first have to create a
+configuration for ctags that it can use to parse the files. This can be done
+in two ways:
+
+  1. Use the --regex argument for specifying regular expressions that are used
+     to parse the files. An example of this is given below. A disadvantage of
+     this approach is that you can't specify scopes.
+  2. Write a parser plugin in C for ctags. This approach is much more powerful
+     than the regex approach since you can make use of all of ctags'
+     functionality but it also requires much more work. Read the ctags
+     documentation for more information about how to do this.
+
+For the first approach the only keys that are needed in the Tagbar definition
+are "ctagstype" and "kinds". A definition that supports scopes has to define
+those two and in addition "scopes", "sro" and at least one of "kind2scope" and
+"scope2kind".
+
+Let's assume we want to add support for LaTeX to Tagbar using the regex
+approach. First we put the following text into ~/.ctags or a file pointed to
+by the "deffile" definition entry:
+>
+        --langdef=latex
+        --langmap=latex:.tex
+        --regex-latex=/^\\tableofcontents/TABLE OF CONTENTS/s,toc/
+        --regex-latex=/^\\frontmatter/FRONTMATTER/s,frontmatter/
+        --regex-latex=/^\\mainmatter/MAINMATTER/s,mainmatter/
+        --regex-latex=/^\\backmatter/BACKMATTER/s,backmatter/
+        --regex-latex=/^\\bibliography\{/BIBLIOGRAPHY/s,bibliography/
+        --regex-latex=/^\\part[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/PART \2/s,part/
+        --regex-latex=/^\\part[[:space:]]*\*[[:space:]]*\{([^}]+)\}/PART \1/s,part/
+        --regex-latex=/^\\chapter[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/CHAP \2/s,chapter/
+        --regex-latex=/^\\chapter[[:space:]]*\*[[:space:]]*\{([^}]+)\}/CHAP \1/s,chapter/
+        --regex-latex=/^\\section[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/\. \2/s,section/
+        --regex-latex=/^\\section[[:space:]]*\*[[:space:]]*\{([^}]+)\}/\. \1/s,section/
+        --regex-latex=/^\\subsection[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/\.\. \2/s,subsection/
+        --regex-latex=/^\\subsection[[:space:]]*\*[[:space:]]*\{([^}]+)\}/\.\. \1/s,subsection/
+        --regex-latex=/^\\subsubsection[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/\.\.\. \2/s,subsubsection/
+        --regex-latex=/^\\subsubsection[[:space:]]*\*[[:space:]]*\{([^}]+)\}/\.\.\. \1/s,subsubsection/
+        --regex-latex=/^\\includegraphics[[:space:]]*(\[[^]]*\])?[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/\3/g,graphic+listing/
+        --regex-latex=/^\\lstinputlisting[[:space:]]*(\[[^]]*\])?[[:space:]]*(\[[^]]*\])?[[:space:]]*\{([^}]+)\}/\3/g,graphic+listing/
+        --regex-latex=/\\label[[:space:]]*\{([^}]+)\}/\1/l,label/
+        --regex-latex=/\\ref[[:space:]]*\{([^}]+)\}/\1/r,ref/
+        --regex-latex=/\\pageref[[:space:]]*\{([^}]+)\}/\1/p,pageref/
+<
+This will create a new language definition with the name "latex" and associate
+it with files with the extension ".tex". It will also define the kinds "s" for
+sections, chapters and the like, "g" for included graphics, "l" for labels,
+"r" for references and "p" for page references. See the ctags documentation
+for more information about the exact syntax.
+
+Now we have to create the Tagbar language definition in our vimrc:
+>
+        let g:tagbar_type_tex = {
+            \ 'ctagstype' : 'latex',
+            \ 'kinds'     : [
+                \ 's:sections',
+                \ 'g:graphics:0:0',
+                \ 'l:labels',
+                \ 'r:refs:1:0',
+                \ 'p:pagerefs:1:0'
+            \ ],
+            \ 'sort'    : 0,
+            \ 'deffile' : expand('<sfile>:p:h:h') . '/ctags/latex.cnf'
+        \ }
+<
+The "deffile" field is of course only needed if the ctags definition actually
+is in that file and not in ~/.ctags.
+
+Sort has been disabled for LaTeX so that the sections appear in their correct
+order. They unfortunately can't be shown nested with their correct scopes
+since as already mentioned the regular expression approach doesn't support
+that.
+
+Tagbar should now be able to show the sections and other tags from LaTeX
+files.
+
+Note: As of 2012-05-05 the ctags development version contains an improved
+LaTeX parser that works better than the example configuration presented here.
+So if you are using a development build newer than that or a stable version
+newer than 5.8 you should use the built-in support instead of this example.
+
+Project-specific configuration~
+
+In addition to the normal global configuration it is also possible to have
+project-specific settings. This is mostly useful for additional ctags options,
+like for example macros to ignore. Or maybe you want to do things like folding
+certain tag kinds in some projects.
+
+In order to use this feature you need to create User |autocommand|s in an
+augroup called "TagbarProjects" and have it create a buffer-local variable
+called "b:tagbar_type". This variable has to hold a type definition just like
+the normal ones described in this chapter. This definition will then be
+applied only to the files matched by the autocommand.
+
+Note that there can be multiple definitions of the augroup with their own
+autocommands (for example in separate project directories); they will get
+merged automatically by Vim.
+
+Example:
+>
+    augroup TagbarProjects
+        autocmd User ~/myproject/*.c let b:tagbar_type = {'deffile' : '~/myproject/ctags.cnf'}
+    augroup END
+<
+
+Writing your own tag-generating program~
+If you want to write your own program for generating tags then here are some
+imporant tips to get it to integrate well with Tagbar:
+
+  - Tagbar supports the same tag format as Vim itself. The format is described
+    in |tags-file-format|, the third format mentioned there is the relevant
+    one. Note that the {tagaddress} part should be a search pattern since the
+    line number can be specified in a field (see below).
+  - Tagbar reads the tag information from a program's standard output
+    (stdout), it doesn't generate files and reads them in after that. So make
+    sure that your program has an option to output the tags on stdout.
+  - Some fields are supported for providing additional information about a
+    tag. One field is required: the "kind" field as a single letter, either
+    with or without a "kind:" fieldname. If it is used without the fieldname
+    then it has to be the first field in the list. All other fields need to
+    have a fieldname in order to determine what they are. The following fields
+    are supported for all filetypes:
+
+        * line:      The line number of the tag.
+        * column:    The column number of the tag.
+        * signature: The signature of a function.
+        * access:    Visibility information of a tag; the values "public",
+                     "protected" and "private" will be denoted with a special
+                     symbol in Tagbar.
+
+    In addition fields that describe the surrounding scope of the tag are
+    supported if they are specified in the type configuration as explained at
+    the beginning of this section. For example, for a tag in class "Foo" this
+    could look like "class:Foo".
+    Important: the value of such a scope-specifying field should be the entire
+    hierarchy of scopes that the tag is in, so if for example in C++ you have
+    a member in class "Foo" which is in namespace "Bar" then the scope field
+    should be "class:Bar::Foo".
+
+==============================================================================
+7. Troubleshooting & Known issues                              *tagbar-issues*
+
+As a general rule, if the tag information displayed by Tagbar is wrong (for
+example, a method doesn't show up or is in the wrong place) you should first
+try running ctags manually to see whether ctags reports the wrong information
+or whether that information is correct and Tagbar does something wrong. To run
+ctags manually execute the following command in a terminal:
+>
+        ctags -f - --format=2 --excmd=pattern --extra= --fields=nksaSmt myfile
+<
+If you set the |g:tagbar_ctags_bin| variable you probably have to use the same
+value here instead of simply "ctags".
+
+If something more fundamental isn't working right then try running the
+|:messages| command to see if Tagbar printed any error messages that might
+have been missed.
+
+If the bug does seem to be in Tagbar then you can use Tagbar's debug mode to
+try to find the source of the problem. Usually you would use it like this:
+
+  1. Open Vim without loading any files.
+  2. Run :TagbarDebug.
+  3. Open the file you are having problems with.
+  4. Open Tagbar. If the problem is with the statusline functionality this
+     step may not be necessary.
+  5. Exit Vim.
+
+This should leave a file called "tagbardebug.log" in the current directory.
+See |tagbar-commands| for more information on the debug commands. When you
+look at the file you should especially pay attention to the reported file type
+and the ctags command line in the log file.
+
+
+Known issues~
+
+  - jsctags has to be newer than 2011-01-06 since it needs the "-f" option to
+    work. Also, the output of jsctags seems to be a bit unreliable at the
+    moment (especially regarding line numbers), so if you notice some strange
+    behaviour with it please run it manually in a terminal to check whether
+    the bug is in jsctags or Tagbar.
+
+  - Nested pseudo-tags cannot be properly parsed since only the direct parent
+    scope of a tag gets assigned a type, the type of the grandparents is not
+    reported by ctags (assuming the grandparents don't have direct, real
+    children).
+
+    For example, if we have a C++ file with the following content:
+>
+        foo::Bar::init()
+        {
+            // ...
+        }
+        foo::Baz::method()
+        {
+            // ...
+        }
+<
+    In this case the type of "foo" is not known. Is it a namespace? A class?
+    For this reason the methods are displayed in Tagbar like this:
+>
+        foo::Bar* : class
+          init()
+        foo::Baz* : class
+          method()
+<
+  - Scope-defining tags at the top level that have the same name but a
+    different kind/scope type can lead to an incorrect display. For example,
+    the following Python code will incorrectly insert a pseudo-tag "Inner2"
+    into the "test" class:
+>
+        class test:
+            class Inner:
+                def foo(self):
+                    pass
+
+        def test():
+            class Inner2:
+                def bar(self):
+                    pass
+<
+    I haven't found a proper way around this yet, but it shouldn't be much of
+    a problem in practice anyway. Tags with the same name at any other level
+    are no problem, though.
+
+==============================================================================
+8. History                                                    *tagbar-history*
+
+2.6.1 (2014-01-23)
+    - Automatically close the preview window when jumping to a tag
+    - Don't forget the previous window in certain situations, which was
+      causing problems with for example fugitive
+    - Fixed toggling kind-specific folds
+    - Fixed ctags error that can happen with Cygwin
+
+2.6 (2013-12-06)
+    - Added possibility to show tags in the preview window, either manually or
+      automatically.
+    - Allow customizing the statusline, see :help g:tagbar_status_func.
+    - Type configuration can now be project-specific.
+    - The keybindings in the Tagbar window are now configurable.
+    - Improvements to Ctags execution on Windows, thanks to Darcy Parker.
+    - Added function tagbar#currentfile() that returns the path to the file
+      currently being displayed in Tagbar, thanks to Zhao Cai.
+    - Added a :Tagbar command as an alias for :TagbarToggle.
+    - Added an way to ignore specific files in case they create problems.
+    - Optionally show line numbers in the Tagbar window.
+    - The usual bunch of small improvements and bugfixes.
+
+2.5 (2013-03-25)
+    - New command :TagbarTogglePause to freeze Tagbar in its current state so
+      you can switch to other files while keeping the old information
+      displayed for reference. (Kian Ryan)
+    - New command :TagbarCurrentTag which reports the same information as
+      currenttag().
+    - New option tagbar_indent to configure the indentation depth of the tags.
+    - New option tagbar_show_visibility to allow disabling the visibility
+      symbols.
+    - Files are now cached locally to avoid additional slowdowns for slow
+      connections. This also makes it possible to use Tagbar with files
+      accessed through Netrw.
+    - Execute ctags again even if the previous run reported errors, in case it
+      was a parse error that has since been fixed. If the error persists,
+      don't display it again.
+    - Improved window switching and Vim exit behaviours. (Techlive Zheng)
+    - The currenttag() function now can show the prototype instead of the
+      actual tag, which can be useful in some cases where ctags doesn't report
+      all the interesting information.
+    - The prototype shown in the tooltip or command line should now always be
+      complete, even if it is spread out over more than one line in the source
+      file.
+    - The TagbarAccessPublic etc. highlight groups have been renamed to
+      TagbarVisibilityPublic etc. to keep them in line with standard
+      terminology. The old names are still supported.
+    - Various smaller improvements and bugfixes.
+
+2.4.1 (2012-07-16)
+    - Fixed some bugs related to the currenttag() function when it was called
+      before the rest of the plugin was loaded. Also fail silently in case
+      something goes wrong so the statusline doesn't get messed up.
+    - In certain cases highlighting tags in deeply nested folds could cause an
+      error message.
+    - Spellchecking is now correctly getting disabled in the Tagbar window.
+
+2.4 (2012-06-17)
+    - New function tagbar#currenttag() that reports the current tag, for
+      example for putting it into the statusline.
+    - New command TagbarGetTypeConfig for easy customization of an existing
+      type.
+    - Type definitions now can be loaded from ftplugins.
+    - The autoopen() function is now a bit more flexible.
+    - Vala is now supported if Anjuta is installed.
+    - Various other small improvements and bugfixes.
+
+2.3 (2011-12-24)
+    - Add a convenience function that allows more flexible ways to
+      automatically open Tagbar.
+    - Replace option tagbar_usearrows with tagbar_iconchars to allow custom
+      characters to be specified. This helps with fonts that don't display the
+      default characters properly.
+    - Remove the need to provide the complete jsctags configuration if jsctags
+      is not found in $PATH, now only the concrete path has to be specified.
+    - Add debugging functionality.
+
+2.2 (2011-11-26)
+    - Small incompatible change: TagbarOpen now doesn't jump to the Tagbar
+      window anymore if it is already open. Use "TagbarOpen j" instead or see
+      its documentation for more options.
+    - Tags inside of scopes now have a header displaying their "kind".
+    - The Tagbar contents are now immediately updated on save for files
+      smaller than a configurable size.
+    - Tagbar can now be configured to jump to a tag with only a single-click
+      instead of a double-click.
+    - Most of the script has been moved to the |autoload| directory, so Vim
+      startup should be faster (thanks to Kien N).
+    - Jumping to tags should work most of the time even if the file has been
+      modified and not saved.
+    - If Ctags has been installed into the default location using Homebrew or
+      MacPorts it should now be found automatically.
+    - Several bugfixes.
+
+2.1 (2011-05-29)
+    - Make Tagbar work in (hopefully) all cases under Windows
+    - Handle cases where 'encoding' is different from system encoding, for
+      example on a Chinese Windows with 'encoding' set to "utf-8" (see manual
+      for details in case it doesn't work out-of-the-box)
+    - Fixed a bug with the handling of subtypes like "python.django"
+    - If a session got saved with Tagbar open it now gets restored properly
+    - Locally reset foldmethod/foldexpr in case foldexpr got set to something
+      expensive globally
+    - Tagbar now tries hard to go to the correct window when jumping to a tag
+    - Explain some possible issues with the current jsctags version in the
+      manual
+    - Explicitly check for some possible configuration problems to be able to
+      give better feedback
+    - A few other small fixes
+
+2.0.1 (2011-04-26)
+    - Fix sorting bug when 'ignorecase' is set
+
+2.0 (2011-04-26)
+    - Folding now works correctly. Folds will be preserved when leaving the
+      Tagbar window and when switching between files. Also tag types can be
+      configured to be folded by default, which is useful for things like
+      includes and imports.
+    - DoctorJS/jsctags and other compatible programs are now supported.
+    - All of the highlight groups can now be overridden.
+    - Added keybinding to quickly jump to next/previous top-level tag.
+    - Added Taglist's "p" keybinding for jumping to a tag without leaving the
+      Tagbar window.
+    - Several bugfixes and other small improvements.
+
+1.5 (2011-03-06)
+    - Type definitions can now include a path to a file with the ctags
+      definition. This is especially useful for ftplugins that can now ship
+      with a complete ctags and Tagbar configuration without requiring user
+      intervention. Thanks to Jan Christoph Ebersbach for the suggestion.
+    - Added autofocus setting by Taybin Rutkin. This will put the cursor in
+      the Tagbar window when it is opened.
+    - The "scopes" field is no longer needed in type definitions, the
+      information is already there in "scope2kind". Existing definitions will
+      be ignored.
+    - Some fixes and improvements related to redrawing and window switching.
+
+1.2 (2011-02-28)
+    - Fix typo in Ruby definition
+
+1.1 (2011-02-26)
+    - Don't lose syntax highlighting when ':syntax enable' is called
+    - Allow expanding the Vim window when Tagbar is opened
+
+1.0 (2011-02-23)
+    - Initial release
+
+==============================================================================
+9. Todo                                                          *tagbar-todo*
+
+  - Allow filtering the Tagbar content by some criteria like tag name,
+    visibility, kind ...
+  - Integrate Tagbar with the FSwitch plugin to provide header file
+    information in C/C++.
+  - Allow jumping to a tag in the preview window, a split window or a new tab.
+
+==============================================================================
+10. Credits                                                   *tagbar-credits*
+
+Tagbar was written by Jan Larres and is released under the Vim licence, see
+|license|. It was heavily inspired by the Taglist plugin by Yegappan
+Lakshmanan and uses a small amount of code from it.
+
+Original taglist copyright notice:
+Permission is hereby granted to use and distribute this code, with or without
+modifications, provided that this copyright notice is copied with it. Like
+anything else that's free, taglist.vim is provided *as is* and comes with no
+warranty of any kind, either expressed or implied. In no event will the
+copyright holder be liable for any damamges resulting from the use of this
+software.
+
+The folding technique was inspired by NERDTree by Martin Grenfell.
+
+Thanks to the following people for code contributions, feature suggestions etc:
+Peter Butkovic
+Zhao Cai
+Jan Christoph Ebersbach
+Vadim Fint
+Leandro Freitas
+Ingo Karkat
+Audrius Kažukauskas
+Michael McClimon
+Seth Milliken
+Kien N
+Darcy Parker
+fritzophrenic
+pielgrzym
+Taybin Rutkin
+Kian Ryan
+John Szakmeister
+Ville Valkonen
+Techlive Zheng
+
+==============================================================================
+ vim: tw=78 ts=8 sw=4 sts=4 et ft=help
diff --git a/vim/.vim/bundle/tagbar/plugin/tagbar.vim b/vim/.vim/bundle/tagbar/plugin/tagbar.vim
new file mode 100644
index 0000000..d2cd175
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/plugin/tagbar.vim
@@ -0,0 +1,148 @@
+" ============================================================================
+" File:        tagbar.vim
+" Description: List the current file's tags in a sidebar, ordered by class etc
+" Author:      Jan Larres <jan@majutsushi.net>
+" Licence:     Vim licence
+" Website:     http://majutsushi.github.com/tagbar/
+" Version:     2.6.1
+" Note:        This plugin was heavily inspired by the 'Taglist' plugin by
+"              Yegappan Lakshmanan and uses a small amount of code from it.
+"
+" Original taglist copyright notice:
+"              Permission is hereby granted to use and distribute this code,
+"              with or without modifications, provided that this copyright
+"              notice is copied with it. Like anything else that's free,
+"              taglist.vim is provided *as is* and comes with no warranty of
+"              any kind, either expressed or implied. In no event will the
+"              copyright holder be liable for any damamges resulting from the
+"              use of this software.
+" ============================================================================
+
+scriptencoding utf-8
+
+if &cp || exists('g:loaded_tagbar')
+    finish
+endif
+
+" Basic init {{{1
+
+if v:version < 700
+    echohl WarningMsg
+    echomsg 'Tagbar: Vim version is too old, Tagbar requires at least 7.0'
+    echohl None
+    finish
+endif
+
+if v:version == 700 && !has('patch167')
+    echohl WarningMsg
+    echomsg 'Tagbar: Vim versions lower than 7.0.167 have a bug'
+          \ 'that prevents this version of Tagbar from working.'
+          \ 'Please use the alternate version posted on the website.'
+    echohl None
+    finish
+endif
+
+function! s:init_var(var, value) abort
+    if !exists('g:tagbar_' . a:var)
+        execute 'let g:tagbar_' . a:var . ' = ' . string(a:value)
+    endif
+endfunction
+
+function! s:setup_options() abort
+    if !exists('g:tagbar_vertical') || g:tagbar_vertical == 0
+        let previewwin_pos = 'topleft'
+    else
+        let previewwin_pos = 'rightbelow vertical'
+    endif
+    let options = [
+        \ ['autoclose', 0],
+        \ ['autofocus', 0],
+        \ ['autopreview', 0],
+        \ ['autoshowtag', 0],
+        \ ['case_insensitive', 0],
+        \ ['compact', 0],
+        \ ['expand', 0],
+        \ ['foldlevel', 99],
+        \ ['hide_nonpublic', 0],
+        \ ['indent', 2],
+        \ ['left', 0],
+        \ ['previewwin_pos', previewwin_pos],
+        \ ['show_visibility', 1],
+        \ ['show_linenumbers', 0],
+        \ ['singleclick', 0],
+        \ ['sort', 1],
+        \ ['systemenc', &encoding],
+        \ ['vertical', 0],
+        \ ['width', 40],
+        \ ['zoomwidth', 1],
+    \ ]
+
+    for [opt, val] in options
+        call s:init_var(opt, val)
+    endfor
+endfunction
+call s:setup_options()
+
+if !exists('g:tagbar_iconchars')
+    if has('multi_byte') && has('unix') && &encoding == 'utf-8' &&
+     \ (empty(&termencoding) || &termencoding == 'utf-8')
+        let g:tagbar_iconchars = ['▶', '▼']
+    else
+        let g:tagbar_iconchars = ['+', '-']
+    endif
+endif
+
+function! s:setup_keymaps() abort
+    let keymaps = [
+        \ ['jump',          '<CR>'],
+        \ ['preview',       'p'],
+        \ ['previewwin',    'P'],
+        \ ['nexttag',       '<C-N>'],
+        \ ['prevtag',       '<C-P>'],
+        \ ['showproto',     '<Space>'],
+        \ ['hidenonpublic', 'v'],
+        \
+        \ ['openfold',      ['+', '<kPlus>', 'zo']],
+        \ ['closefold',     ['-', '<kMinus>', 'zc']],
+        \ ['togglefold',    ['o', 'za']],
+        \ ['openallfolds',  ['*', '<kMultiply>', 'zR']],
+        \ ['closeallfolds', ['=', 'zM']],
+        \ ['nextfold',      'zj'],
+        \ ['prevfold',      'zk'],
+        \
+        \ ['togglesort',            's'],
+        \ ['togglecaseinsensitive', 'i'],
+        \ ['toggleautoclose',       'c'],
+        \ ['zoomwin',               'x'],
+        \ ['close',                 'q'],
+        \ ['help',                  ['<F1>', '?']],
+    \ ]
+
+    for [map, key] in keymaps
+        call s:init_var('map_' . map, key)
+        unlet key
+    endfor
+endfunction
+call s:setup_keymaps()
+
+augroup TagbarSession
+    autocmd!
+    autocmd SessionLoadPost * nested call tagbar#RestoreSession()
+augroup END
+
+" Commands {{{1
+command! -nargs=0 Tagbar              call tagbar#ToggleWindow()
+command! -nargs=0 TagbarToggle        call tagbar#ToggleWindow()
+command! -nargs=? TagbarOpen          call tagbar#OpenWindow(<f-args>)
+command! -nargs=0 TagbarOpenAutoClose call tagbar#OpenWindow('fcj')
+command! -nargs=0 TagbarClose         call tagbar#CloseWindow()
+command! -nargs=1 -bang TagbarSetFoldlevel  call tagbar#SetFoldLevel(<args>, <bang>0)
+command! -nargs=0 TagbarShowTag       call tagbar#highlighttag(1, 1)
+command! -nargs=? TagbarCurrentTag    echo tagbar#currenttag('%s', 'No current tag', <f-args>)
+command! -nargs=1 TagbarGetTypeConfig call tagbar#gettypeconfig(<f-args>)
+command! -nargs=? TagbarDebug         call tagbar#StartDebug(<f-args>)
+command! -nargs=0 TagbarDebugEnd      call tagbar#StopDebug()
+command! -nargs=0 TagbarTogglePause   call tagbar#toggle_pause()
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
diff --git a/vim/.vim/bundle/tagbar/syntax/tagbar.vim b/vim/.vim/bundle/tagbar/syntax/tagbar.vim
new file mode 100644
index 0000000..a1d450b
--- /dev/null
+++ b/vim/.vim/bundle/tagbar/syntax/tagbar.vim
@@ -0,0 +1,63 @@
+" File:        tagbar.vim
+" Description: Tagbar syntax settings
+" Author:      Jan Larres <jan@majutsushi.net>
+" Licence:     Vim licence
+" Website:     http://majutsushi.github.com/tagbar/
+" Version:     2.6.1
+
+scriptencoding utf-8
+
+if exists("b:current_syntax")
+    finish
+endif
+
+let s:ics = escape(join(g:tagbar_iconchars, ''), ']^\-')
+let s:pattern = '\(^[' . s:ics . '] \?\)\@<=[^-+: ]\+[^:]\+$'
+execute "syntax match TagbarKind '" . s:pattern . "'"
+
+let s:pattern = '\(\S\@<![' . s:ics . '][-+# ]\?\)\@<=[^*(]\+\(\*\?\(([^)]\+)\)\? :\)\@='
+execute "syntax match TagbarScope '" . s:pattern . "'"
+
+let s:pattern = '\S\@<![' . s:ics . ']\([-+# ]\?\)\@='
+execute "syntax match TagbarFoldIcon '" . s:pattern . "'"
+
+let s:pattern = '\(\S\@<![' . s:ics . ' ]\)\@<=+\([^-+# ]\)\@='
+execute "syntax match TagbarVisibilityPublic '" . s:pattern . "'"
+let s:pattern = '\(\S\@<![' . s:ics . ' ]\)\@<=#\([^-+# ]\)\@='
+execute "syntax match TagbarVisibilityProtected '" . s:pattern . "'"
+let s:pattern = '\(\S\@<![' . s:ics . ' ]\)\@<=-\([^-+# ]\)\@='
+execute "syntax match TagbarVisibilityPrivate '" . s:pattern . "'"
+
+unlet s:pattern
+
+syntax match TagbarHelp      '^".*' contains=TagbarHelpKey,TagbarHelpTitle
+syntax match TagbarHelpKey   '" \zs.*\ze:' contained
+syntax match TagbarHelpTitle '" \zs-\+ \w\+ -\+' contained
+
+syntax match TagbarNestedKind '^\s\+\[[^]]\+\]$'
+syntax match TagbarType       ' : \zs.*'
+syntax match TagbarSignature  '(.*)'
+syntax match TagbarPseudoID   '\*\ze :'
+
+highlight default link TagbarHelp       Comment
+highlight default link TagbarHelpKey    Identifier
+highlight default link TagbarHelpTitle  PreProc
+highlight default link TagbarKind       Identifier
+highlight default link TagbarNestedKind TagbarKind
+highlight default link TagbarScope      Title
+highlight default link TagbarType       Type
+highlight default link TagbarSignature  SpecialKey
+highlight default link TagbarPseudoID   NonText
+highlight default link TagbarFoldIcon   Statement
+highlight default link TagbarHighlight  Search
+
+highlight default TagbarAccessPublic    guifg=Green ctermfg=Green
+highlight default TagbarAccessProtected guifg=Blue  ctermfg=Blue
+highlight default TagbarAccessPrivate   guifg=Red   ctermfg=Red
+highlight default link TagbarVisibilityPublic    TagbarAccessPublic
+highlight default link TagbarVisibilityProtected TagbarAccessProtected
+highlight default link TagbarVisibilityPrivate   TagbarAccessPrivate
+
+let b:current_syntax = "tagbar"
+
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
diff --git a/vim/.vim/bundle/vinegar/CONTRIBUTING.markdown b/vim/.vim/bundle/vinegar/CONTRIBUTING.markdown
new file mode 100644
index 0000000..b3f0095
--- /dev/null
+++ b/vim/.vim/bundle/vinegar/CONTRIBUTING.markdown
@@ -0,0 +1 @@
+See the [contribution guidelines for pathogen.vim](https://github.com/tpope/vim-pathogen/blob/master/CONTRIBUTING.markdown).
diff --git a/vim/.vim/bundle/vinegar/README.markdown b/vim/.vim/bundle/vinegar/README.markdown
new file mode 100644
index 0000000..8b5b8ed
--- /dev/null
+++ b/vim/.vim/bundle/vinegar/README.markdown
@@ -0,0 +1,50 @@
+# vinegar.vim
+
+> Split windows and the project drawer go together like oil and vinegar. I
+> don't mean to say that you can combine them to create a delicious salad
+> dressing. I mean that they don't mix well!
+> - Drew Neil
+
+You know what netrw is, right?  The built in directory browser?  Well,
+vinegar.vim enhances netrw, partially in an attempt to mitigate the need for
+more disruptive ["project drawer"][Oil and vinegar] style plugins.
+
+[Oil and vinegar]: http://vimcasts.org/blog/2013/01/oil-and-vinegar-split-windows-and-project-drawer/
+
+Some of the behaviors added by vinegar.vim would make excellent upstream
+additions.  Many, the author would probably reject.  Others are a bit too wild
+to even consider.
+
+* Press `-` in any buffer to hop up to the directory listing and seek to the
+  file you just came from.  Keep bouncing to go up, up, up.  Having rapid
+  directory access available changes everything.
+* All that annoying crap at the top is turned off, leaving you with nothing
+  but a list of files.  This is surprisingly disorienting, but ultimately
+  very liberating.  Press `I` to toggle until you adapt.
+* The oddly C-biased default sort order is replaced with a sensible application
+  of `'suffixes'`.
+* File hiding: files are not listed that match with one of the patterns in
+  `'wildignore'`.  
+  If you put `let g:netrw_list_hide = '\(^\|\s\s\)\zs\.\S\+'`
+  in your vimrc, vinegar will initialize with dot files hidden.
+  Press `gh` to toggle dot file hiding.
+* Press `.` on a file to pre-populate it at the end of a `:` command line.
+  This is great, for example, to quickly initiate a `:grep` of the file or
+  directory under the cursor.  There's also `!`, which starts the line off
+  with a bang.  Type `!chmod +x` and get `:!chmod +x path/to/file`.
+* Press `cg` or `cl` to `:cd` or `:lcd` to the currently edited directory.
+* Press `~` to go home.
+
+## Installation
+
+If you don't have a preferred installation method, I recommend
+installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
+then simply copy and paste:
+
+    cd ~/.vim/bundle
+    git clone git://github.com/tpope/vim-vinegar.git
+
+## License
+
+Copyright © Tim Pope.  Distributed under the same terms as Vim itself.
+See `:help license`.
diff --git a/vim/.vim/bundle/vinegar/plugin/vinegar.vim b/vim/.vim/bundle/vinegar/plugin/vinegar.vim
new file mode 100644
index 0000000..f471141
--- /dev/null
+++ b/vim/.vim/bundle/vinegar/plugin/vinegar.vim
@@ -0,0 +1,96 @@
+" vinegar.vim - combine with netrw to create a delicious salad dressing
+" Maintainer:   Tim Pope <http://tpo.pe/>
+
+if exists("g:loaded_vinegar") || v:version < 700 || &cp
+  finish
+endif
+let g:loaded_vinegar = 1
+
+function! s:fnameescape(file) abort
+  if exists('*fnameescape')
+    return fnameescape(a:file)
+  else
+    return escape(a:file," \t\n*?[{`$\\%#'\"|!<")
+  endif
+endfunction
+
+let s:dotfiles = '\(^\|\s\s\)\zs\.\S\+'
+
+let g:netrw_sort_sequence = '[\/]$,*,\%(' . join(map(split(&suffixes, ','), 'escape(v:val, ".*$~")'), '\|') . '\)[*@]\=$'
+let s:escape = 'substitute(escape(v:val, ".$~"), "*", ".*", "g")'
+let g:netrw_list_hide =
+      \ join(map(split(&wildignore, ','), '"^".' . s:escape . '. "$"'), ',') . ',^\.\.\=/\=$' .
+      \ (get(g:, 'netrw_list_hide', '')[-strlen(s:dotfiles)-1:-1] ==# s:dotfiles ? ','.s:dotfiles : '')
+if !exists("g:netrw_banner")
+  let g:netrw_banner = 0
+endif
+let s:netrw_up = ''
+
+nnoremap <silent> <Plug>VinegarUp :call <SID>opendir('edit')<CR>
+if empty(maparg('-', 'n'))
+  nmap - <Plug>VinegarUp
+endif
+
+nnoremap <silent> <Plug>VinegarTabUp :call <SID>opendir('tabedit')<CR>
+nnoremap <silent> <Plug>VinegarSplitUp :call <SID>opendir('split')<CR>
+nnoremap <silent> <Plug>VinegarVerticalSplitUp :call <SID>opendir('vsplit')<CR>
+
+function! s:opendir(cmd) abort
+  let df = ','.s:dotfiles
+  if expand('%:t')[0] ==# '.' && g:netrw_list_hide[-strlen(df):-1] ==# df
+    let g:netrw_list_hide = g:netrw_list_hide[0 : -strlen(df)-1]
+  endif
+  if &filetype ==# 'netrw'
+    let currdir = fnamemodify(b:netrw_curdir, ':t')
+    execute s:netrw_up
+    call s:seek(currdir)
+  elseif expand('%') =~# '^$\|^term:[\/][\/]'
+    execute a:cmd '.'
+  else
+    execute a:cmd '%:h/'
+    call s:seek(expand('#:t'))
+  endif
+endfunction
+
+function! s:seek(file) abort
+  if get(b:, 'netrw_liststyle') == 2
+    let pattern = '\%(^\|\s\+\)\zs'.escape(a:file, '.*[]~\').'[/*|@=]\=\%($\|\s\+\)'
+  else
+    let pattern = '^\%(| \)*'.escape(a:file, '.*[]~\').'[/*|@=]\=\%($\|\t\)'
+  endif
+  call search(pattern, 'wc')
+  return pattern
+endfunction
+
+augroup vinegar
+  autocmd!
+  autocmd FileType netrw call s:setup_vinegar()
+augroup END
+
+function! s:escaped(first, last) abort
+  let files = getline(a:first, a:last)
+  call filter(files, 'v:val !~# "^\" "')
+  call map(files, 'substitute(v:val, "[/*|@=]\\=\\%(\\t.*\\)\\=$", "", "")')
+  return join(map(files, 'fnamemodify(b:netrw_curdir."/".v:val,":~:.")'), ' ')
+endfunction
+
+function! s:setup_vinegar() abort
+  if empty(s:netrw_up)
+    " save netrw mapping
+    let s:netrw_up = substitute(maparg('-', 'n'), '\c^:\%(<c-u>\)\=', '', '')
+    " saved string is like this:
+    " :exe "norm! 0"|call netrw#LocalBrowseCheck(<SNR>172_NetrwBrowseChgDir(1,'../'))<CR>
+    " remove <CR> at the end (otherwise raises "E488: Trailing characters")
+    let s:netrw_up = strpart(s:netrw_up, 0, strlen(s:netrw_up)-4)
+  endif
+  nmap <buffer> - <Plug>VinegarUp
+  nnoremap <buffer> ~ :edit ~/<CR>
+  nnoremap <buffer> . :<C-U> <C-R>=<SID>escaped(line('.'), line('.') - 1 + v:count1)<CR><Home>
+  xnoremap <buffer> . <Esc>: <C-R>=<SID>escaped(line("'<"), line("'>"))<CR><Home>
+  nmap <buffer> ! .!
+  xmap <buffer> ! .!
+  nnoremap <buffer> <silent> cg :exe 'keepjumps cd ' .<SID>fnameescape(b:netrw_curdir)<CR>
+  nnoremap <buffer> <silent> cl :exe 'keepjumps lcd '.<SID>fnameescape(b:netrw_curdir)<CR>
+  exe 'syn match netrwSuffixes =\%(\S\+ \)*\S\+\%('.join(map(split(&suffixes, ','), s:escape), '\|') . '\)[*@]\=\S\@!='
+  hi def link netrwSuffixes SpecialKey
+endfunction
diff --git a/vim/.vim/colors/halfdab.test.vim b/vim/.vim/colors/halfdab.test.vim
new file mode 100644
index 0000000..dddfa01
--- /dev/null
+++ b/vim/.vim/colors/halfdab.test.vim
@@ -0,0 +1,1116 @@
+" Name:     Halfdab vim colorscheme
+" Author:   Andrew R. M. TODO <amiller@linode.com>
+" URL:      TODO
+" License:  GPLv3 (see end of this file)
+" Created:  For fun
+" Modified: 2016 Oct 11
+"
+" Usage "{{{
+"
+" ---------------------------------------------------------------------
+" ABOUT:
+" ---------------------------------------------------------------------
+" Solarized is a carefully designed selective contrast colorscheme with dual
+" light and dark modes that runs in both GUI, 256 and 16 color modes.
+"
+" See the homepage above for screenshots and details.
+"
+" ---------------------------------------------------------------------
+" OPTIONS:
+" ---------------------------------------------------------------------
+" See the "solarized.txt" help file included with this colorscheme (in the 
+" "doc" subdirectory) for information on options, usage, the Toggle Background 
+" function and more. If you have already installed Solarized, this is available 
+" from the Solarized menu and command line as ":help solarized"
+"
+" ---------------------------------------------------------------------
+" INSTALLATION:
+" ---------------------------------------------------------------------
+" Two options for installation: manual or pathogen
+"
+" MANUAL INSTALLATION OPTION:
+" ---------------------------------------------------------------------
+"
+" 1.  Download the solarized distribution (available on the homepage above)
+"     and unarchive the file.
+" 2.  Move `solarized.vim` to your `.vim/colors` directory.
+" 3.  Move each of the files in each subdirectories to the corresponding .vim
+"     subdirectory (e.g. autoload/togglebg.vim goes into your .vim/autoload 
+"     directory as .vim/autoload/togglebg.vim).
+"
+" RECOMMENDED PATHOGEN INSTALLATION OPTION:
+" ---------------------------------------------------------------------
+"
+" 1.  Download and install Tim Pope's Pathogen from:
+"     https://github.com/tpope/vim-pathogen
+"
+" 2.  Next, move or clone the `vim-colors-solarized` directory so that it is
+"     a subdirectory of the `.vim/bundle` directory.
+"
+"     a. **clone with git:**
+"
+"       $ cd ~/.vim/bundle
+"       $ git clone git://github.com/altercation/vim-colors-solarized.git
+"
+"     b. **or move manually into the pathogen bundle directory:**
+"         In the parent directory of vim-colors-solarized:
+"
+"         $ mv vim-colors-solarized ~/.vim/bundle/
+"
+" MODIFY VIMRC:
+"
+" After either Option 1 or Option 2 above, put the following two lines in your
+" .vimrc:
+"
+"     syntax enable
+"     set background=dark
+"     colorscheme solarized
+"
+" or, for the light background mode of Solarized:
+"
+"     syntax enable
+"     set background=light
+"     colorscheme solarized
+"
+" I like to have a different background in GUI and terminal modes, so I can use
+" the following if-then. However, I find vim's background autodetection to be
+" pretty good and, at least with MacVim, I can leave this background value
+" assignment out entirely and get the same results.
+"
+"     if has('gui_running')
+"       set background=light
+"     else
+"       set background=dark
+"     endif
+"
+" See the Solarized homepage at http://ethanschoonover.com/solarized for
+" screenshots which will help you select either the light or dark background.
+"
+" ---------------------------------------------------------------------
+" COLOR VALUES
+" ---------------------------------------------------------------------
+" Download palettes and files from: http://ethanschoonover.com/solarized
+"
+" L\*a\*b values are canonical (White D65, Reference D50), other values are
+" matched in sRGB space.
+"
+" SOLARIZED HEX     16/8 TERMCOL  XTERM/HEX   L*A*B      sRGB        HSB
+" --------- ------- ---- -------  ----------- ---------- ----------- -----------
+" base03    #002b36  8/4 brblack  234 #1c1c1c 15 -12 -12   0  43  54 193 100  21
+" base02    #073642  0/4 black    235 #262626 20 -12 -12   7  54  66 192  90  26
+" base01    #586e75 10/7 brgreen  240 #4e4e4e 45 -07 -07  88 110 117 194  25  46
+" base00    #657b83 11/7 bryellow 241 #585858 50 -07 -07 101 123 131 195  23  51
+" base0     #839496 12/6 brblue   244 #808080 60 -06 -03 131 148 150 186  13  59
+" base1     #93a1a1 14/4 brcyan   245 #8a8a8a 65 -05 -02 147 161 161 180   9  63
+" base2     #eee8d5  7/7 white    254 #d7d7af 92 -00  10 238 232 213  44  11  93
+" base3     #fdf6e3 15/7 brwhite  230 #ffffd7 97  00  10 253 246 227  44  10  99
+" yellow    #b58900  3/3 yellow   136 #af8700 60  10  65 181 137   0  45 100  71
+" orange    #cb4b16  9/3 brred    166 #d75f00 50  50  55 203  75  22  18  89  80
+" red       #dc322f  1/1 red      160 #d70000 50  65  45 220  50  47   1  79  86
+" magenta   #d33682  5/5 magenta  125 #af005f 50  65 -05 211  54 130 331  74  83
+" violet    #6c71c4 13/5 brmagenta 61 #5f5faf 50  15 -45 108 113 196 237  45  77
+" blue      #268bd2  4/4 blue      33 #0087ff 55 -10 -45  38 139 210 205  82  82
+" cyan      #2aa198  6/6 cyan      37 #00afaf 60 -35 -05  42 161 152 175  74  63
+" green     #859900  2/2 green     64 #5f8700 60 -20  65 133 153   0  68 100  60
+"
+" ---------------------------------------------------------------------
+" COLORSCHEME HACKING
+" ---------------------------------------------------------------------
+"
+" Useful commands for testing colorschemes:
+" :source $VIMRUNTIME/syntax/hitest.vim
+" :help highlight-groups
+" :help cterm-colors
+" :help group-name
+"
+" Useful links for developing colorschemes:
+" http://www.vim.org/scripts/script.php?script_id=2937
+" http://vimcasts.org/episodes/creating-colorschemes-for-vim/
+" http://www.frexx.de/xterm-256-notes/"
+"
+" }}}
+" Environment Specific Overrides "{{{
+" Allow or disallow certain features based on current terminal emulator or 
+" environment.
+
+" Terminals that support italics
+let s:terms_italic=[
+            \"rxvt",
+            \"gnome-terminal"
+            \]
+" For reference only, terminals are known to be incomptible.
+" Terminals that are in neither list need to be tested.
+let s:terms_noitalic=[
+            \"iTerm.app",
+            \"Apple_Terminal"
+            \]
+if has("gui_running")
+    let s:terminal_italic=1 " TODO: could refactor to not require this at all
+else
+    let s:terminal_italic=0 " terminals will be guilty until proven compatible
+    for term in s:terms_italic
+        if $TERM_PROGRAM =~ term
+            let s:terminal_italic=1
+        endif
+    endfor
+endif
+
+" }}}
+" Default option values"{{{
+" ---------------------------------------------------------------------
+" s:options_list is used to autogenerate a list of all non-default options 
+" using "call SolarizedOptions()" or with the "Generate .vimrc commands" 
+" Solarized menu option. See the "Menus" section below for the function itself.
+let s:options_list=[
+            \'" this block of commands has been autogenerated by solarized.vim and',
+            \'" includes the current, non-default Solarized option values.',
+            \'" To use, place these commands in your .vimrc file (replacing any',
+            \'" existing colorscheme commands). See also ":help solarized"',
+            \'',
+            \'" ------------------------------------------------------------------',
+            \'" Solarized Colorscheme Config',
+            \'" ------------------------------------------------------------------',
+            \]
+let s:colorscheme_list=[
+            \'syntax enable',
+            \'set background='.&background,
+            \'colorscheme solarized',
+            \]
+let s:defaults_list=[
+            \'" ------------------------------------------------------------------',
+            \'',
+            \'" The following items are available options, but do not need to be',
+            \'" included in your .vimrc as they are currently set to their defaults.',
+            \''
+            \]
+let s:lazycat_list=[
+            \'" lazy method of appending this onto your .vimrc ":w! >> ~/.vimrc"',
+            \'" ------------------------------------------------------------------',
+            \]
+
+function! s:SetOption(name,default)
+    if type(a:default) == type(0)
+        let l:wrap=''
+        let l:ewrap=''
+    else
+        let l:wrap='"'
+        let l:ewrap='\"'
+    endif
+    if !exists("g:solarized_".a:name) || g:solarized_{a:name}==a:default
+        exe 'let g:solarized_'.a:name.'='.l:wrap.a:default.l:wrap.'"'
+        exe 'call add(s:defaults_list, "\" let g:solarized_'.a:name.'='.l:ewrap.g:solarized_{a:name}.l:ewrap.'")'
+    else
+        exe 'call add(s:options_list,  "let g:solarized_'.a:name.'='.l:ewrap.g:solarized_{a:name}.l:ewrap.'    \"default value is '.a:default.'")'
+    endif
+endfunction
+
+if ($TERM_PROGRAM ==? "apple_terminal" && &t_Co < 256)
+    let s:solarized_termtrans_default = 1
+else
+    let s:solarized_termtrans_default = 0
+endif
+call s:SetOption("termtrans",s:solarized_termtrans_default)
+call s:SetOption("degrade",0)
+call s:SetOption("bold",1)
+call s:SetOption("underline",1)
+call s:SetOption("italic",1) " note that we need to override this later if the terminal doesn't support
+call s:SetOption("termcolors",16)
+call s:SetOption("contrast","normal")
+call s:SetOption("visibility","normal")
+call s:SetOption("diffmode","normal")
+call s:SetOption("hitrail",0)
+call s:SetOption("menu",1)
+
+"}}}
+" Colorscheme initialization "{{{
+" ---------------------------------------------------------------------
+hi clear
+if exists("syntax_on")
+  syntax reset
+endif
+let colors_name = "solarized"
+
+"}}}
+" GUI & CSApprox hexadecimal palettes"{{{
+" ---------------------------------------------------------------------
+"
+" Set both gui and terminal color values in separate conditional statements
+" Due to possibility that CSApprox is running (though I suppose we could just
+" leave the hex values out entirely in that case and include only cterm colors)
+" We also check to see if user has set solarized (force use of the
+" neutral gray monotone palette component)
+if (has("gui_running") && g:solarized_degrade == 0)
+    let s:vmode       = "gui"
+    let s:base03      = "#002b36"
+    let s:base02      = "#073642"
+    let s:base01      = "#586e75"
+    let s:base00      = "#657b83"
+    let s:base0       = "#839496"
+    let s:base1       = "#93a1a1"
+    let s:base2       = "#eee8d5"
+    let s:base3       = "#fdf6e3"
+    let s:yellow      = "#b58900"
+    let s:orange      = "#cb4b16"
+    let s:red         = "#dc322f"
+    let s:magenta     = "#d33682"
+    let s:violet      = "#6c71c4"
+    let s:blue        = "#268bd2"
+    let s:cyan        = "#2aa198"
+    "let s:green       = "#859900" "original
+    let s:green       = "#719e07" "experimental
+elseif (has("gui_running") && g:solarized_degrade == 1)
+    " These colors are identical to the 256 color mode. They may be viewed
+    " while in gui mode via "let g:solarized_degrade=1", though this is not
+    " recommened and is for testing only.
+    let s:vmode       = "gui"
+    let s:base03      = "#1c1c1c"
+    let s:base02      = "#262626"
+    let s:base01      = "#4e4e4e"
+    let s:base00      = "#585858"
+    let s:base0       = "#808080"
+    let s:base1       = "#8a8a8a"
+    let s:base2       = "#d7d7af"
+    let s:base3       = "#ffffd7"
+    let s:yellow      = "#af8700"
+    let s:orange      = "#d75f00"
+    let s:red         = "#af0000"
+    let s:magenta     = "#af005f"
+    let s:violet      = "#5f5faf"
+    let s:blue        = "#0087ff"
+    let s:cyan        = "#00afaf"
+    let s:green       = "#5f8700"
+elseif g:solarized_termcolors != 256 && &t_Co >= 16
+    let s:vmode       = "cterm"
+    let s:base03      = "8"
+    let s:base02      = "0"
+    let s:base01      = "10"
+    let s:base00      = "11"
+    let s:base0       = "12"
+    let s:base1       = "14"
+    let s:base2       = "7"
+    let s:base3       = "15"
+    let s:yellow      = "3"
+    let s:orange      = "9"
+    let s:red         = "1"
+    let s:magenta     = "5"
+    let s:violet      = "13"
+    let s:blue        = "4"
+    let s:cyan        = "6"
+    let s:green       = "2"
+elseif g:solarized_termcolors == 256
+    let s:vmode       = "cterm"
+    let s:base03      = "234"
+    let s:base02      = "235"
+    let s:base01      = "239"
+    let s:base00      = "240"
+    let s:base0       = "244"
+    let s:base1       = "245"
+    let s:base2       = "187"
+    let s:base3       = "230"
+    let s:yellow      = "136"
+    let s:orange      = "166"
+    let s:red         = "124"
+    let s:magenta     = "125"
+    let s:violet      = "61"
+    let s:blue        = "33"
+    let s:cyan        = "37"
+    let s:green       = "64"
+else
+    let s:vmode       = "cterm"
+    let s:bright      = "* term=bold cterm=bold"
+"   let s:base03      = "0".s:bright
+"   let s:base02      = "0"
+"   let s:base01      = "2".s:bright
+"   let s:base00      = "3".s:bright
+"   let s:base0       = "4".s:bright
+"   let s:base1       = "6".s:bright
+"   let s:base2       = "7"
+"   let s:base3       = "7".s:bright
+"   let s:yellow      = "3"
+"   let s:orange      = "1".s:bright
+"   let s:red         = "1"
+"   let s:magenta     = "5"
+"   let s:violet      = "5".s:bright
+"   let s:blue        = "4"
+"   let s:cyan        = "6"
+"   let s:green       = "2"
+    let s:base03      = "DarkGray"      " 0*
+    let s:base02      = "Black"         " 0
+    let s:base01      = "LightGreen"    " 2*
+    let s:base00      = "LightYellow"   " 3*
+    let s:base0       = "LightBlue"     " 4*
+    let s:base1       = "LightCyan"     " 6*
+    let s:base2       = "LightGray"     " 7
+    let s:base3       = "White"         " 7*
+    let s:yellow      = "DarkYellow"    " 3
+    let s:orange      = "LightRed"      " 1*
+    let s:red         = "DarkRed"       " 1
+    let s:magenta     = "DarkMagenta"   " 5
+    let s:violet      = "LightMagenta"  " 5*
+    let s:blue        = "DarkBlue"      " 4
+    let s:cyan        = "DarkCyan"      " 6
+    let s:green       = "DarkGreen"     " 2
+
+endif
+"}}}
+" Formatting options and null values for passthrough effect "{{{
+" ---------------------------------------------------------------------
+    let s:none            = "NONE"
+    let s:none            = "NONE"
+    let s:t_none          = "NONE"
+    let s:n               = "NONE"
+    let s:c               = ",undercurl"
+    let s:r               = ",reverse"
+    let s:s               = ",standout"
+    let s:ou              = ""
+    let s:ob              = ""
+"}}}
+" Background value based on termtrans setting "{{{
+" ---------------------------------------------------------------------
+if (has("gui_running") || g:solarized_termtrans == 0)
+    let s:back        = s:base03
+else
+    let s:back        = "NONE"
+endif
+"}}}
+" Alternate light scheme "{{{
+" ---------------------------------------------------------------------
+if &background == "light"
+    let s:temp03      = s:base03
+    let s:temp02      = s:base02
+    let s:temp01      = s:base01
+    let s:temp00      = s:base00
+    let s:base03      = s:base3
+    let s:base02      = s:base2
+    let s:base01      = s:base1
+    let s:base00      = s:base0
+    let s:base0       = s:temp00
+    let s:base1       = s:temp01
+    let s:base2       = s:temp02
+    let s:base3       = s:temp03
+    if (s:back != "NONE")
+        let s:back    = s:base03
+    endif
+endif
+"}}}
+" Optional contrast schemes "{{{
+" ---------------------------------------------------------------------
+if g:solarized_contrast == "high"
+    let s:base01      = s:base00
+    let s:base00      = s:base0
+    let s:base0       = s:base1
+    let s:base1       = s:base2
+    let s:base2       = s:base3
+    let s:back        = s:back
+endif
+if g:solarized_contrast == "low"
+    let s:back        = s:base02
+    let s:ou          = ",underline"
+endif
+"}}}
+" Overrides dependent on user specified values and environment "{{{
+" ---------------------------------------------------------------------
+if (g:solarized_bold == 0 || &t_Co == 8 )
+    let s:b           = ""
+    let s:bb          = ",bold"
+else
+    let s:b           = ",bold"
+    let s:bb          = ""
+endif
+
+if g:solarized_underline == 0
+    let s:u           = ""
+else
+    let s:u           = ",underline"
+endif
+
+if g:solarized_italic == 0 || s:terminal_italic == 0
+    let s:i           = ""
+else
+    let s:i           = ",italic"
+endif
+"}}}
+" Highlighting primitives"{{{
+" ---------------------------------------------------------------------
+
+exe "let s:bg_none      = ' ".s:vmode."bg=".s:none   ."'"
+exe "let s:bg_back      = ' ".s:vmode."bg=".s:back   ."'"
+exe "let s:bg_base03    = ' ".s:vmode."bg=".s:base03 ."'"
+exe "let s:bg_base02    = ' ".s:vmode."bg=".s:base02 ."'"
+exe "let s:bg_base01    = ' ".s:vmode."bg=".s:base01 ."'"
+exe "let s:bg_base00    = ' ".s:vmode."bg=".s:base00 ."'"
+exe "let s:bg_base0     = ' ".s:vmode."bg=".s:base0  ."'"
+exe "let s:bg_base1     = ' ".s:vmode."bg=".s:base1  ."'"
+exe "let s:bg_base2     = ' ".s:vmode."bg=".s:base2  ."'"
+exe "let s:bg_base3     = ' ".s:vmode."bg=".s:base3  ."'"
+exe "let s:bg_green     = ' ".s:vmode."bg=".s:green  ."'"
+exe "let s:bg_yellow    = ' ".s:vmode."bg=".s:yellow ."'"
+exe "let s:bg_orange    = ' ".s:vmode."bg=".s:orange ."'"
+exe "let s:bg_red       = ' ".s:vmode."bg=".s:red    ."'"
+exe "let s:bg_magenta   = ' ".s:vmode."bg=".s:magenta."'"
+exe "let s:bg_violet    = ' ".s:vmode."bg=".s:violet ."'"
+exe "let s:bg_blue      = ' ".s:vmode."bg=".s:blue   ."'"
+exe "let s:bg_cyan      = ' ".s:vmode."bg=".s:cyan   ."'"
+
+exe "let s:fg_none      = ' ".s:vmode."fg=".s:none   ."'"
+exe "let s:fg_back      = ' ".s:vmode."fg=".s:back   ."'"
+exe "let s:fg_base03    = ' ".s:vmode."fg=".s:base03 ."'"
+exe "let s:fg_base02    = ' ".s:vmode."fg=".s:base02 ."'"
+exe "let s:fg_base01    = ' ".s:vmode."fg=".s:base01 ."'"
+exe "let s:fg_base00    = ' ".s:vmode."fg=".s:base00 ."'"
+exe "let s:fg_base0     = ' ".s:vmode."fg=".s:base0  ."'"
+exe "let s:fg_base1     = ' ".s:vmode."fg=".s:base1  ."'"
+exe "let s:fg_base2     = ' ".s:vmode."fg=".s:base2  ."'"
+exe "let s:fg_base3     = ' ".s:vmode."fg=".s:base3  ."'"
+exe "let s:fg_green     = ' ".s:vmode."fg=".s:green  ."'"
+exe "let s:fg_yellow    = ' ".s:vmode."fg=".s:yellow ."'"
+exe "let s:fg_orange    = ' ".s:vmode."fg=".s:orange ."'"
+exe "let s:fg_red       = ' ".s:vmode."fg=".s:red    ."'"
+exe "let s:fg_magenta   = ' ".s:vmode."fg=".s:magenta."'"
+exe "let s:fg_violet    = ' ".s:vmode."fg=".s:violet ."'"
+exe "let s:fg_blue      = ' ".s:vmode."fg=".s:blue   ."'"
+exe "let s:fg_cyan      = ' ".s:vmode."fg=".s:cyan   ."'"
+
+exe "let s:fmt_none     = ' ".s:vmode."=NONE".          " term=NONE".    "'"
+exe "let s:fmt_bold     = ' ".s:vmode."=NONE".s:b.      " term=NONE".s:b."'"
+exe "let s:fmt_bldi     = ' ".s:vmode."=NONE".s:b.      " term=NONE".s:b."'"
+exe "let s:fmt_undr     = ' ".s:vmode."=NONE".s:u.      " term=NONE".s:u."'"
+exe "let s:fmt_undb     = ' ".s:vmode."=NONE".s:u.s:b.  " term=NONE".s:u.s:b."'"
+exe "let s:fmt_undi     = ' ".s:vmode."=NONE".s:u.      " term=NONE".s:u."'"
+exe "let s:fmt_uopt     = ' ".s:vmode."=NONE".s:ou.     " term=NONE".s:ou."'"
+exe "let s:fmt_curl     = ' ".s:vmode."=NONE".s:c.      " term=NONE".s:c."'"
+exe "let s:fmt_ital     = ' ".s:vmode."=NONE".s:i.      " term=NONE".s:i."'"
+exe "let s:fmt_stnd     = ' ".s:vmode."=NONE".s:s.      " term=NONE".s:s."'"
+exe "let s:fmt_revr     = ' ".s:vmode."=NONE".s:r.      " term=NONE".s:r."'"
+exe "let s:fmt_revb     = ' ".s:vmode."=NONE".s:r.s:b.  " term=NONE".s:r.s:b."'"
+" revbb (reverse bold for bright colors) is only set to actual bold in low 
+" color terminals (t_co=8, such as OS X Terminal.app) and should only be used 
+" with colors 8-15.
+exe "let s:fmt_revbb    = ' ".s:vmode."=NONE".s:r.s:bb.   " term=NONE".s:r.s:bb."'"
+exe "let s:fmt_revbbu   = ' ".s:vmode."=NONE".s:r.s:bb.s:u." term=NONE".s:r.s:bb.s:u."'"
+
+if has("gui_running")
+    exe "let s:sp_none      = ' guisp=".s:none   ."'"
+    exe "let s:sp_back      = ' guisp=".s:back   ."'"
+    exe "let s:sp_base03    = ' guisp=".s:base03 ."'"
+    exe "let s:sp_base02    = ' guisp=".s:base02 ."'"
+    exe "let s:sp_base01    = ' guisp=".s:base01 ."'"
+    exe "let s:sp_base00    = ' guisp=".s:base00 ."'"
+    exe "let s:sp_base0     = ' guisp=".s:base0  ."'"
+    exe "let s:sp_base1     = ' guisp=".s:base1  ."'"
+    exe "let s:sp_base2     = ' guisp=".s:base2  ."'"
+    exe "let s:sp_base3     = ' guisp=".s:base3  ."'"
+    exe "let s:sp_green     = ' guisp=".s:green  ."'"
+    exe "let s:sp_yellow    = ' guisp=".s:yellow ."'"
+    exe "let s:sp_orange    = ' guisp=".s:orange ."'"
+    exe "let s:sp_red       = ' guisp=".s:red    ."'"
+    exe "let s:sp_magenta   = ' guisp=".s:magenta."'"
+    exe "let s:sp_violet    = ' guisp=".s:violet ."'"
+    exe "let s:sp_blue      = ' guisp=".s:blue   ."'"
+    exe "let s:sp_cyan      = ' guisp=".s:cyan   ."'"
+else
+    let s:sp_none      = ""
+    let s:sp_back      = ""
+    let s:sp_base03    = ""
+    let s:sp_base02    = ""
+    let s:sp_base01    = ""
+    let s:sp_base00    = ""
+    let s:sp_base0     = ""
+    let s:sp_base1     = ""
+    let s:sp_base2     = ""
+    let s:sp_base3     = ""
+    let s:sp_green     = ""
+    let s:sp_yellow    = ""
+    let s:sp_orange    = ""
+    let s:sp_red       = ""
+    let s:sp_magenta   = ""
+    let s:sp_violet    = ""
+    let s:sp_blue      = ""
+    let s:sp_cyan      = ""
+endif
+
+"}}}
+" Basic highlighting"{{{
+" ---------------------------------------------------------------------
+" note that link syntax to avoid duplicate configuration doesn't work with the
+" exe compiled formats
+
+exe "hi! Normal"         .s:fmt_none   .s:fg_base0  .s:bg_back
+
+exe "hi! Comment"        .s:fmt_ital   .s:fg_base01 .s:bg_none
+"       *Comment         any comment
+
+exe "hi! Constant"       .s:fmt_none   .s:fg_cyan   .s:bg_none
+"       *Constant        any constant
+"        String          a string constant: "this is a string"
+"        Character       a character constant: 'c', '\n'
+"        Number          a number constant: 234, 0xff
+"        Boolean         a boolean constant: TRUE, false
+"        Float           a floating point constant: 2.3e10
+
+exe "hi! Identifier"     .s:fmt_none   .s:fg_blue   .s:bg_none
+"       *Identifier      any variable name
+"        Function        function name (also: methods for classes)
+"
+exe "hi! Statement"      .s:fmt_none   .s:fg_green  .s:bg_none
+"       *Statement       any statement
+"        Conditional     if, then, else, endif, switch, etc.
+"        Repeat          for, do, while, etc.
+"        Label           case, default, etc.
+"        Operator        "sizeof", "+", "*", etc.
+"        Keyword         any other keyword
+"        Exception       try, catch, throw
+
+exe "hi! PreProc"        .s:fmt_none   .s:fg_orange .s:bg_none
+"       *PreProc         generic Preprocessor
+"        Include         preprocessor #include
+"        Define          preprocessor #define
+"        Macro           same as Define
+"        PreCondit       preprocessor #if, #else, #endif, etc.
+
+exe "hi! Type"           .s:fmt_none   .s:fg_yellow .s:bg_none
+"       *Type            int, long, char, etc.
+"        StorageClass    static, register, volatile, etc.
+"        Structure       struct, union, enum, etc.
+"        Typedef         A typedef
+
+exe "hi! Special"        .s:fmt_none   .s:fg_red    .s:bg_none
+"       *Special         any special symbol
+"        SpecialChar     special character in a constant
+"        Tag             you can use CTRL-] on this
+"        Delimiter       character that needs attention
+"        SpecialComment  special things inside a comment
+"        Debug           debugging statements
+
+exe "hi! Underlined"     .s:fmt_none   .s:fg_violet .s:bg_none
+"       *Underlined      text that stands out, HTML links
+
+exe "hi! Ignore"         .s:fmt_none   .s:fg_none   .s:bg_none
+"       *Ignore          left blank, hidden  |hl-Ignore|
+
+exe "hi! Error"          .s:fmt_bold   .s:fg_red    .s:bg_none
+"       *Error           any erroneous construct
+
+exe "hi! Todo"           .s:fmt_bold   .s:fg_magenta.s:bg_none
+"       *Todo            anything that needs extra attention; mostly the
+"                        keywords TODO FIXME and XXX
+"
+"}}}
+" Extended highlighting "{{{
+" ---------------------------------------------------------------------
+if      (g:solarized_visibility=="high")
+    exe "hi! SpecialKey" .s:fmt_revr   .s:fg_red    .s:bg_none
+    exe "hi! NonText"    .s:fmt_bold   .s:fg_red    .s:bg_none
+elseif  (g:solarized_visibility=="low")
+    exe "hi! SpecialKey" .s:fmt_bold   .s:fg_base02 .s:bg_none
+    exe "hi! NonText"    .s:fmt_bold   .s:fg_base02 .s:bg_none
+else
+    exe "hi! SpecialKey" .s:fmt_bold   .s:fg_base00 .s:bg_base02
+    exe "hi! NonText"    .s:fmt_bold   .s:fg_base00 .s:bg_none
+endif
+exe "hi! StatusLine"     .s:fmt_none   .s:fg_base1  .s:bg_base02 .s:fmt_revbb
+exe "hi! StatusLineNC"   .s:fmt_none   .s:fg_base00 .s:bg_base02 .s:fmt_revbb
+exe "hi! Visual"         .s:fmt_none   .s:fg_base01 .s:bg_base03 .s:fmt_revbb
+exe "hi! Directory"      .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! ErrorMsg"       .s:fmt_revr   .s:fg_red    .s:bg_none
+exe "hi! IncSearch"      .s:fmt_stnd   .s:fg_orange .s:bg_none
+exe "hi! Search"         .s:fmt_revr   .s:fg_yellow .s:bg_none
+exe "hi! MoreMsg"        .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! ModeMsg"        .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! LineNr"         .s:fmt_none   .s:fg_base01 .s:bg_base02
+exe "hi! Question"       .s:fmt_bold   .s:fg_cyan   .s:bg_none
+if ( has("gui_running") || &t_Co > 8 )
+    exe "hi! VertSplit"  .s:fmt_none   .s:fg_base00 .s:bg_base00
+else
+    exe "hi! VertSplit"  .s:fmt_revbb  .s:fg_base00 .s:bg_base02
+endif
+exe "hi! Title"          .s:fmt_bold   .s:fg_orange .s:bg_none
+exe "hi! VisualNOS"      .s:fmt_stnd   .s:fg_none   .s:bg_base02 .s:fmt_revbb
+exe "hi! WarningMsg"     .s:fmt_bold   .s:fg_red    .s:bg_none
+exe "hi! WildMenu"       .s:fmt_none   .s:fg_base2  .s:bg_base02 .s:fmt_revbb
+exe "hi! Folded"         .s:fmt_undb   .s:fg_base0  .s:bg_base02  .s:sp_base03
+exe "hi! FoldColumn"     .s:fmt_none   .s:fg_base0  .s:bg_base02
+if      (g:solarized_diffmode=="high")
+exe "hi! DiffAdd"        .s:fmt_revr   .s:fg_green  .s:bg_none
+exe "hi! DiffChange"     .s:fmt_revr   .s:fg_yellow .s:bg_none
+exe "hi! DiffDelete"     .s:fmt_revr   .s:fg_red    .s:bg_none
+exe "hi! DiffText"       .s:fmt_revr   .s:fg_blue   .s:bg_none
+elseif  (g:solarized_diffmode=="low")
+exe "hi! DiffAdd"        .s:fmt_undr   .s:fg_green  .s:bg_none   .s:sp_green
+exe "hi! DiffChange"     .s:fmt_undr   .s:fg_yellow .s:bg_none   .s:sp_yellow
+exe "hi! DiffDelete"     .s:fmt_bold   .s:fg_red    .s:bg_none
+exe "hi! DiffText"       .s:fmt_undr   .s:fg_blue   .s:bg_none   .s:sp_blue
+else " normal
+    if has("gui_running")
+exe "hi! DiffAdd"        .s:fmt_bold   .s:fg_green  .s:bg_base02 .s:sp_green
+exe "hi! DiffChange"     .s:fmt_bold   .s:fg_yellow .s:bg_base02 .s:sp_yellow
+exe "hi! DiffDelete"     .s:fmt_bold   .s:fg_red    .s:bg_base02
+exe "hi! DiffText"       .s:fmt_bold   .s:fg_blue   .s:bg_base02 .s:sp_blue
+    else
+exe "hi! DiffAdd"        .s:fmt_none   .s:fg_green  .s:bg_base02 .s:sp_green
+exe "hi! DiffChange"     .s:fmt_none   .s:fg_yellow .s:bg_base02 .s:sp_yellow
+exe "hi! DiffDelete"     .s:fmt_none   .s:fg_red    .s:bg_base02
+exe "hi! DiffText"       .s:fmt_none   .s:fg_blue   .s:bg_base02 .s:sp_blue
+    endif
+endif
+exe "hi! SignColumn"     .s:fmt_none   .s:fg_base0
+exe "hi! Conceal"        .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! SpellBad"       .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_red
+exe "hi! SpellCap"       .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_violet
+exe "hi! SpellRare"      .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_cyan
+exe "hi! SpellLocal"     .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_yellow
+exe "hi! Pmenu"          .s:fmt_none   .s:fg_base0  .s:bg_base02  .s:fmt_revbb
+exe "hi! PmenuSel"       .s:fmt_none   .s:fg_base01 .s:bg_base2   .s:fmt_revbb
+exe "hi! PmenuSbar"      .s:fmt_none   .s:fg_base2  .s:bg_base0   .s:fmt_revbb
+exe "hi! PmenuThumb"     .s:fmt_none   .s:fg_base0  .s:bg_base03  .s:fmt_revbb
+exe "hi! TabLine"        .s:fmt_undr   .s:fg_base0  .s:bg_base02  .s:sp_base0
+exe "hi! TabLineFill"    .s:fmt_undr   .s:fg_base0  .s:bg_base02  .s:sp_base0
+exe "hi! TabLineSel"     .s:fmt_undr   .s:fg_base01 .s:bg_base2   .s:sp_base0  .s:fmt_revbbu
+exe "hi! CursorColumn"   .s:fmt_none   .s:fg_none   .s:bg_base02
+exe "hi! CursorLine"     .s:fmt_uopt   .s:fg_none   .s:bg_base02  .s:sp_base1
+exe "hi! ColorColumn"    .s:fmt_none   .s:fg_none   .s:bg_base02
+exe "hi! Cursor"         .s:fmt_none   .s:fg_base03 .s:bg_base0
+hi! link lCursor Cursor
+exe "hi! MatchParen"     .s:fmt_bold   .s:fg_red    .s:bg_base01
+
+"}}}
+" vim syntax highlighting "{{{
+" ---------------------------------------------------------------------
+"exe "hi! vimLineComment" . s:fg_base01 .s:bg_none   .s:fmt_ital
+"hi! link vimComment Comment
+"hi! link vimLineComment Comment
+hi! link vimVar Identifier
+hi! link vimFunc Function
+hi! link vimUserFunc Function
+hi! link helpSpecial Special
+hi! link vimSet Normal
+hi! link vimSetEqual Normal
+exe "hi! vimCommentString"  .s:fmt_none    .s:fg_violet .s:bg_none
+exe "hi! vimCommand"        .s:fmt_none    .s:fg_yellow .s:bg_none
+exe "hi! vimCmdSep"         .s:fmt_bold    .s:fg_blue   .s:bg_none
+exe "hi! helpExample"       .s:fmt_none    .s:fg_base1  .s:bg_none
+exe "hi! helpOption"        .s:fmt_none    .s:fg_cyan   .s:bg_none
+exe "hi! helpNote"          .s:fmt_none    .s:fg_magenta.s:bg_none
+exe "hi! helpVim"           .s:fmt_none    .s:fg_magenta.s:bg_none
+exe "hi! helpHyperTextJump" .s:fmt_undr    .s:fg_blue   .s:bg_none
+exe "hi! helpHyperTextEntry".s:fmt_none    .s:fg_green  .s:bg_none
+exe "hi! vimIsCommand"      .s:fmt_none    .s:fg_base00 .s:bg_none
+exe "hi! vimSynMtchOpt"     .s:fmt_none    .s:fg_yellow .s:bg_none
+exe "hi! vimSynType"        .s:fmt_none    .s:fg_cyan   .s:bg_none
+exe "hi! vimHiLink"         .s:fmt_none    .s:fg_blue   .s:bg_none
+exe "hi! vimHiGroup"        .s:fmt_none    .s:fg_blue   .s:bg_none
+exe "hi! vimGroup"          .s:fmt_undb    .s:fg_blue   .s:bg_none
+"}}}
+" diff highlighting "{{{
+" ---------------------------------------------------------------------
+hi! link diffAdded Statement
+hi! link diffLine Identifier
+"}}}
+" git & gitcommit highlighting "{{{
+"git
+"exe "hi! gitDateHeader"
+"exe "hi! gitIdentityHeader"
+"exe "hi! gitIdentityKeyword"
+"exe "hi! gitNotesHeader"
+"exe "hi! gitReflogHeader"
+"exe "hi! gitKeyword"
+"exe "hi! gitIdentity"
+"exe "hi! gitEmailDelimiter"
+"exe "hi! gitEmail"
+"exe "hi! gitDate"
+"exe "hi! gitMode"
+"exe "hi! gitHashAbbrev"
+"exe "hi! gitHash"
+"exe "hi! gitReflogMiddle"
+"exe "hi! gitReference"
+"exe "hi! gitStage"
+"exe "hi! gitType"
+"exe "hi! gitDiffAdded"
+"exe "hi! gitDiffRemoved"
+"gitcommit
+"exe "hi! gitcommitSummary"      
+exe "hi! gitcommitComment"      .s:fmt_ital     .s:fg_base01    .s:bg_none
+hi! link gitcommitUntracked gitcommitComment
+hi! link gitcommitDiscarded gitcommitComment
+hi! link gitcommitSelected  gitcommitComment
+exe "hi! gitcommitUnmerged"     .s:fmt_bold     .s:fg_green     .s:bg_none
+exe "hi! gitcommitOnBranch"     .s:fmt_bold     .s:fg_base01    .s:bg_none
+exe "hi! gitcommitBranch"       .s:fmt_bold     .s:fg_magenta   .s:bg_none
+hi! link gitcommitNoBranch gitcommitBranch
+exe "hi! gitcommitDiscardedType".s:fmt_none     .s:fg_red       .s:bg_none
+exe "hi! gitcommitSelectedType" .s:fmt_none     .s:fg_green     .s:bg_none
+"exe "hi! gitcommitUnmergedType"
+"exe "hi! gitcommitType"
+"exe "hi! gitcommitNoChanges"
+"exe "hi! gitcommitHeader"
+exe "hi! gitcommitHeader"       .s:fmt_none     .s:fg_base01    .s:bg_none
+exe "hi! gitcommitUntrackedFile".s:fmt_bold     .s:fg_cyan      .s:bg_none
+exe "hi! gitcommitDiscardedFile".s:fmt_bold     .s:fg_red       .s:bg_none
+exe "hi! gitcommitSelectedFile" .s:fmt_bold     .s:fg_green     .s:bg_none
+exe "hi! gitcommitUnmergedFile" .s:fmt_bold     .s:fg_yellow    .s:bg_none
+exe "hi! gitcommitFile"         .s:fmt_bold     .s:fg_base0     .s:bg_none
+hi! link gitcommitDiscardedArrow gitcommitDiscardedFile
+hi! link gitcommitSelectedArrow  gitcommitSelectedFile
+hi! link gitcommitUnmergedArrow  gitcommitUnmergedFile
+"exe "hi! gitcommitArrow"
+"exe "hi! gitcommitOverflow"
+"exe "hi! gitcommitBlank"
+" }}}
+" html highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! htmlTag"           .s:fmt_none .s:fg_base01 .s:bg_none
+exe "hi! htmlEndTag"        .s:fmt_none .s:fg_base01 .s:bg_none
+exe "hi! htmlTagN"          .s:fmt_bold .s:fg_base1  .s:bg_none
+exe "hi! htmlTagName"       .s:fmt_bold .s:fg_blue   .s:bg_none
+exe "hi! htmlSpecialTagName".s:fmt_ital .s:fg_blue   .s:bg_none
+exe "hi! htmlArg"           .s:fmt_none .s:fg_base00 .s:bg_none
+exe "hi! javaScript"        .s:fmt_none .s:fg_yellow .s:bg_none
+"}}}
+" perl highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! perlHereDoc"    . s:fg_base1  .s:bg_back   .s:fmt_none
+exe "hi! perlVarPlain"   . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! perlStatementFileDesc". s:fg_cyan.s:bg_back.s:fmt_none
+
+"}}}
+" tex highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! texStatement"   . s:fg_cyan   .s:bg_back   .s:fmt_none
+exe "hi! texMathZoneX"   . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! texMathMatcher" . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! texMathMatcher" . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! texRefLabel"    . s:fg_yellow .s:bg_back   .s:fmt_none
+"}}}
+" ruby highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! rubyDefine"     . s:fg_base1  .s:bg_back   .s:fmt_bold
+"rubyInclude
+"rubySharpBang
+"rubyAccess
+"rubyPredefinedVariable
+"rubyBoolean
+"rubyClassVariable
+"rubyBeginEnd
+"rubyRepeatModifier
+"hi! link rubyArrayDelimiter    Special  " [ , , ]
+"rubyCurlyBlock  { , , }
+
+"hi! link rubyClass             Keyword
+"hi! link rubyModule            Keyword
+"hi! link rubyKeyword           Keyword
+"hi! link rubyOperator          Operator
+"hi! link rubyIdentifier        Identifier
+"hi! link rubyInstanceVariable  Identifier
+"hi! link rubyGlobalVariable    Identifier
+"hi! link rubyClassVariable     Identifier
+"hi! link rubyConstant          Type
+"}}}
+" haskell syntax highlighting"{{{
+" ---------------------------------------------------------------------
+" For use with syntax/haskell.vim : Haskell Syntax File
+" http://www.vim.org/scripts/script.php?script_id=3034
+" See also Steffen Siering's github repository:
+" http://github.com/urso/dotrc/blob/master/vim/syntax/haskell.vim
+" ---------------------------------------------------------------------
+"
+" Treat True and False specially, see the plugin referenced above
+let hs_highlight_boolean=1
+" highlight delims, see the plugin referenced above
+let hs_highlight_delimiters=1
+
+exe "hi! cPreCondit". s:fg_orange.s:bg_none   .s:fmt_none
+
+exe "hi! VarId"    . s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! ConId"    . s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! hsImport" . s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! hsString" . s:fg_base00 .s:bg_none   .s:fmt_none
+
+exe "hi! hsStructure"        . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hs_hlFunctionName"  . s:fg_blue   .s:bg_none
+exe "hi! hsStatement"        . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsImportLabel"      . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hs_OpFunctionName"  . s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! hs_DeclareFunction" . s:fg_orange .s:bg_none   .s:fmt_none
+exe "hi! hsVarSym"           . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsType"             . s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! hsTypedef"          . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsModuleName"       . s:fg_green  .s:bg_none   .s:fmt_undr
+exe "hi! hsModuleStartLabel" . s:fg_magenta.s:bg_none   .s:fmt_none
+hi! link hsImportParams      Delimiter
+hi! link hsDelimTypeExport   Delimiter
+hi! link hsModuleStartLabel  hsStructure
+hi! link hsModuleWhereLabel  hsModuleStartLabel
+
+" following is for the haskell-conceal plugin
+" the first two items don't have an impact, but better safe
+exe "hi! hsNiceOperator"     . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsniceoperator"     . s:fg_cyan   .s:bg_none   .s:fmt_none
+
+"}}}
+" pandoc markdown syntax highlighting "{{{
+" ---------------------------------------------------------------------
+
+"PandocHiLink pandocNormalBlock
+exe "hi! pandocTitleBlock"               .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocTitleBlockTitle"          .s:fg_blue   .s:bg_none   .s:fmt_bold
+exe "hi! pandocTitleComment"             .s:fg_blue   .s:bg_none   .s:fmt_bold
+exe "hi! pandocComment"                  .s:fg_base01 .s:bg_none   .s:fmt_ital
+exe "hi! pandocVerbatimBlock"            .s:fg_yellow .s:bg_none   .s:fmt_none
+hi! link pandocVerbatimBlockDeep         pandocVerbatimBlock
+hi! link pandocCodeBlock                 pandocVerbatimBlock
+hi! link pandocCodeBlockDelim            pandocVerbatimBlock
+exe "hi! pandocBlockQuote"               .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader1"        .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader2"        .s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader3"        .s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader4"        .s:fg_red    .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader5"        .s:fg_base0  .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader6"        .s:fg_base01 .s:bg_none   .s:fmt_none
+exe "hi! pandocListMarker"               .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocListReference"            .s:fg_magenta.s:bg_none   .s:fmt_undr
+
+" Definitions
+" ---------------------------------------------------------------------
+let s:fg_pdef = s:fg_violet
+exe "hi! pandocDefinitionBlock"              .s:fg_pdef  .s:bg_none  .s:fmt_none
+exe "hi! pandocDefinitionTerm"               .s:fg_pdef  .s:bg_none  .s:fmt_stnd
+exe "hi! pandocDefinitionIndctr"             .s:fg_pdef  .s:bg_none  .s:fmt_bold
+exe "hi! pandocEmphasisDefinition"           .s:fg_pdef  .s:bg_none  .s:fmt_ital
+exe "hi! pandocEmphasisNestedDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_bold
+exe "hi! pandocStrongEmphasisNestedDefinition"   .s:fg_pdef.s:bg_none.s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasisDefinition" .s:fg_pdef.s:bg_none.s:fmt_bldi
+exe "hi! pandocStrikeoutDefinition"          .s:fg_pdef  .s:bg_none  .s:fmt_revr
+exe "hi! pandocVerbatimInlineDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_none
+exe "hi! pandocSuperscriptDefinition"        .s:fg_pdef  .s:bg_none  .s:fmt_none
+exe "hi! pandocSubscriptDefinition"          .s:fg_pdef  .s:bg_none  .s:fmt_none
+
+" Tables
+" ---------------------------------------------------------------------
+let s:fg_ptable = s:fg_blue
+exe "hi! pandocTable"                        .s:fg_ptable.s:bg_none  .s:fmt_none
+exe "hi! pandocTableStructure"               .s:fg_ptable.s:bg_none  .s:fmt_none
+hi! link pandocTableStructureTop             pandocTableStructre
+hi! link pandocTableStructureEnd             pandocTableStructre
+exe "hi! pandocTableZebraLight"              .s:fg_ptable.s:bg_base03.s:fmt_none
+exe "hi! pandocTableZebraDark"               .s:fg_ptable.s:bg_base02.s:fmt_none
+exe "hi! pandocEmphasisTable"                .s:fg_ptable.s:bg_none  .s:fmt_ital
+exe "hi! pandocEmphasisNestedTable"          .s:fg_ptable.s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisTable"          .s:fg_ptable.s:bg_none  .s:fmt_bold
+exe "hi! pandocStrongEmphasisNestedTable"    .s:fg_ptable.s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasisTable"  .s:fg_ptable.s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrikeoutTable"               .s:fg_ptable.s:bg_none  .s:fmt_revr
+exe "hi! pandocVerbatimInlineTable"          .s:fg_ptable.s:bg_none  .s:fmt_none
+exe "hi! pandocSuperscriptTable"             .s:fg_ptable.s:bg_none  .s:fmt_none
+exe "hi! pandocSubscriptTable"               .s:fg_ptable.s:bg_none  .s:fmt_none
+
+" Headings
+" ---------------------------------------------------------------------
+let s:fg_phead = s:fg_orange
+exe "hi! pandocHeading"                      .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocHeadingMarker"                .s:fg_yellow.s:bg_none.s:fmt_bold
+exe "hi! pandocEmphasisHeading"              .s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocEmphasisNestedHeading"        .s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocStrongEmphasisHeading"        .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocStrongEmphasisNestedHeading"  .s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasisHeading".s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocStrikeoutHeading"             .s:fg_phead .s:bg_none.s:fmt_revr
+exe "hi! pandocVerbatimInlineHeading"        .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocSuperscriptHeading"           .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocSubscriptHeading"             .s:fg_phead .s:bg_none.s:fmt_bold
+
+" Links
+" ---------------------------------------------------------------------
+exe "hi! pandocLinkDelim"                .s:fg_base01 .s:bg_none   .s:fmt_none
+exe "hi! pandocLinkLabel"                .s:fg_blue   .s:bg_none   .s:fmt_undr
+exe "hi! pandocLinkText"                 .s:fg_blue   .s:bg_none   .s:fmt_undb
+exe "hi! pandocLinkURL"                  .s:fg_base00 .s:bg_none   .s:fmt_undr
+exe "hi! pandocLinkTitle"                .s:fg_base00 .s:bg_none   .s:fmt_undi
+exe "hi! pandocLinkTitleDelim"           .s:fg_base01 .s:bg_none   .s:fmt_undi   .s:sp_base00
+exe "hi! pandocLinkDefinition"           .s:fg_cyan   .s:bg_none   .s:fmt_undr   .s:sp_base00
+exe "hi! pandocLinkDefinitionID"         .s:fg_blue   .s:bg_none   .s:fmt_bold
+exe "hi! pandocImageCaption"             .s:fg_violet .s:bg_none   .s:fmt_undb
+exe "hi! pandocFootnoteLink"             .s:fg_green  .s:bg_none   .s:fmt_undr
+exe "hi! pandocFootnoteDefLink"          .s:fg_green  .s:bg_none   .s:fmt_bold
+exe "hi! pandocFootnoteInline"           .s:fg_green  .s:bg_none   .s:fmt_undb
+exe "hi! pandocFootnote"                 .s:fg_green  .s:bg_none   .s:fmt_none
+exe "hi! pandocCitationDelim"            .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocCitation"                 .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocCitationID"               .s:fg_magenta.s:bg_none   .s:fmt_undr
+exe "hi! pandocCitationRef"              .s:fg_magenta.s:bg_none   .s:fmt_none
+
+" Main Styles
+" ---------------------------------------------------------------------
+exe "hi! pandocStyleDelim"               .s:fg_base01 .s:bg_none  .s:fmt_none
+exe "hi! pandocEmphasis"                 .s:fg_base0  .s:bg_none  .s:fmt_ital
+exe "hi! pandocEmphasisNested"           .s:fg_base0  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasis"           .s:fg_base0  .s:bg_none  .s:fmt_bold
+exe "hi! pandocStrongEmphasisNested"     .s:fg_base0  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasis"   .s:fg_base0  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrikeout"                .s:fg_base01 .s:bg_none  .s:fmt_revr
+exe "hi! pandocVerbatimInline"           .s:fg_yellow .s:bg_none  .s:fmt_none
+exe "hi! pandocSuperscript"              .s:fg_violet .s:bg_none  .s:fmt_none
+exe "hi! pandocSubscript"                .s:fg_violet .s:bg_none  .s:fmt_none
+
+exe "hi! pandocRule"                     .s:fg_blue   .s:bg_none  .s:fmt_bold
+exe "hi! pandocRuleLine"                 .s:fg_blue   .s:bg_none  .s:fmt_bold
+exe "hi! pandocEscapePair"               .s:fg_red    .s:bg_none  .s:fmt_bold
+exe "hi! pandocCitationRef"              .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocNonBreakingSpace"         . s:fg_red   .s:bg_none  .s:fmt_revr
+hi! link pandocEscapedCharacter          pandocEscapePair
+hi! link pandocLineBreak                 pandocEscapePair
+
+" Embedded Code
+" ---------------------------------------------------------------------
+exe "hi! pandocMetadataDelim"            .s:fg_base01 .s:bg_none   .s:fmt_none
+exe "hi! pandocMetadata"                 .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocMetadataKey"              .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocMetadata"                 .s:fg_blue   .s:bg_none   .s:fmt_bold
+hi! link pandocMetadataTitle             pandocMetadata
+
+"}}}
+" Utility autocommand "{{{
+" ---------------------------------------------------------------------
+" In cases where Solarized is initialized inside a terminal vim session and 
+" then transferred to a gui session via the command `:gui`, the gui vim process 
+" does not re-read the colorscheme (or .vimrc for that matter) so any `has_gui` 
+" related code that sets gui specific values isn't executed.
+"
+" Currently, Solarized sets only the cterm or gui values for the colorscheme 
+" depending on gui or terminal mode. It's possible that, if the following 
+" autocommand method is deemed excessively poor form, that approach will be 
+" used again and the autocommand below will be dropped.
+"
+" However it seems relatively benign in this case to include the autocommand 
+" here. It fires only in cases where vim is transferring from terminal to gui 
+" mode (detected with the script scope s:vmode variable). It also allows for 
+" other potential terminal customizations that might make gui mode suboptimal.
+"
+autocmd GUIEnter * if (s:vmode != "gui") | exe "colorscheme " . g:colors_name | endif
+"}}}
+" Highlight Trailing Space {{{
+" Experimental: Different highlight when on cursorline
+function! s:SolarizedHiTrail()
+    if g:solarized_hitrail==0
+        hi! clear solarizedTrailingSpace
+    else
+        syn match solarizedTrailingSpace "\s*$"
+        exe "hi! solarizedTrailingSpace " .s:fmt_undr .s:fg_red .s:bg_none .s:sp_red
+    endif
+endfunction  
+augroup SolarizedHiTrail
+    autocmd!
+    if g:solarized_hitrail==1
+        autocmd! Syntax * call s:SolarizedHiTrail()
+        autocmd! ColorScheme * if g:colors_name == "solarized" | call s:SolarizedHiTrail() | else | augroup! s:SolarizedHiTrail | endif
+    endif
+augroup END
+" }}}
+" Menus "{{{
+" ---------------------------------------------------------------------
+" Turn off Solarized menu by including the following assignment in your .vimrc:
+"
+"    let g:solarized_menu=0
+
+function! s:SolarizedOptions()
+    new "new buffer
+    setf vim "vim filetype
+    let failed = append(0, s:defaults_list)
+    let failed = append(0, s:colorscheme_list)
+    let failed = append(0, s:options_list)
+    let failed = append(0, s:lazycat_list)
+    0 "jump back to the top
+endfunction
+if !exists(":SolarizedOptions")
+    command SolarizedOptions :call s:SolarizedOptions()
+endif
+
+function! SolarizedMenu()
+    if exists("g:loaded_solarized_menu")
+        try
+            silent! aunmenu Solarized
+        endtry
+    endif
+    let g:loaded_solarized_menu = 1
+
+    if g:colors_name == "solarized" && g:solarized_menu != 0
+
+        amenu &Solarized.&Contrast.&Low\ Contrast        :let g:solarized_contrast="low"       \| colorscheme solarized<CR>
+        amenu &Solarized.&Contrast.&Normal\ Contrast     :let g:solarized_contrast="normal"    \| colorscheme solarized<CR>
+        amenu &Solarized.&Contrast.&High\ Contrast       :let g:solarized_contrast="high"      \| colorscheme solarized<CR>
+        an    &Solarized.&Contrast.-sep-                 <Nop>
+        amenu &Solarized.&Contrast.&Help:\ Contrast      :help 'solarized_contrast'<CR>
+
+        amenu &Solarized.&Visibility.&Low\ Visibility    :let g:solarized_visibility="low"     \| colorscheme solarized<CR>
+        amenu &Solarized.&Visibility.&Normal\ Visibility :let g:solarized_visibility="normal"  \| colorscheme solarized<CR>
+        amenu &Solarized.&Visibility.&High\ Visibility   :let g:solarized_visibility="high"    \| colorscheme solarized<CR>
+        an    &Solarized.&Visibility.-sep-                 <Nop>
+        amenu &Solarized.&Visibility.&Help:\ Visibility    :help 'solarized_visibility'<CR>
+
+        amenu &Solarized.&Background.&Toggle\ Background :ToggleBG<CR>
+        amenu &Solarized.&Background.&Dark\ Background   :set background=dark  \| colorscheme solarized<CR>
+        amenu &Solarized.&Background.&Light\ Background  :set background=light \| colorscheme solarized<CR>
+        an    &Solarized.&Background.-sep-               <Nop>
+        amenu &Solarized.&Background.&Help:\ ToggleBG     :help togglebg<CR>
+
+        if g:solarized_bold==0 | let l:boldswitch="On" | else | let l:boldswitch="Off" | endif
+        exe "amenu &Solarized.&Styling.&Turn\\ Bold\\ ".l:boldswitch." :let g:solarized_bold=(abs(g:solarized_bold-1)) \\| colorscheme solarized<CR>"
+        if g:solarized_italic==0 | let l:italicswitch="On" | else | let l:italicswitch="Off" | endif
+        exe "amenu &Solarized.&Styling.&Turn\\ Italic\\ ".l:italicswitch." :let g:solarized_italic=(abs(g:solarized_italic-1)) \\| colorscheme solarized<CR>"
+        if g:solarized_underline==0 | let l:underlineswitch="On" | else | let l:underlineswitch="Off" | endif
+        exe "amenu &Solarized.&Styling.&Turn\\ Underline\\ ".l:underlineswitch." :let g:solarized_underline=(abs(g:solarized_underline-1)) \\| colorscheme solarized<CR>"
+
+        amenu &Solarized.&Diff\ Mode.&Low\ Diff\ Mode    :let g:solarized_diffmode="low"     \| colorscheme solarized<CR>
+        amenu &Solarized.&Diff\ Mode.&Normal\ Diff\ Mode :let g:solarized_diffmode="normal"  \| colorscheme solarized<CR>
+        amenu &Solarized.&Diff\ Mode.&High\ Diff\ Mode   :let g:solarized_diffmode="high"    \| colorscheme solarized<CR>
+
+        if g:solarized_hitrail==0 | let l:hitrailswitch="On" | else | let l:hitrailswitch="Off" | endif
+        exe "amenu &Solarized.&Experimental.&Turn\\ Highlight\\ Trailing\\ Spaces\\ ".l:hitrailswitch." :let g:solarized_hitrail=(abs(g:solarized_hitrail-1)) \\| colorscheme solarized<CR>"
+        an    &Solarized.&Experimental.-sep-               <Nop>
+        amenu &Solarized.&Experimental.&Help:\ HiTrail    :help 'solarized_hitrail'<CR>
+
+        an    &Solarized.-sep1-                          <Nop>
+
+        amenu &Solarized.&Autogenerate\ options          :SolarizedOptions<CR>
+
+        an    &Solarized.-sep2-                          <Nop>
+
+        amenu &Solarized.&Help.&Solarized\ Help          :help solarized<CR>
+        amenu &Solarized.&Help.&Toggle\ Background\ Help :help togglebg<CR>
+        amenu &Solarized.&Help.&Removing\ This\ Menu     :help solarized-menu<CR>
+
+        an 9999.77 &Help.&Solarized\ Colorscheme         :help solarized<CR>
+        an 9999.78 &Help.&Toggle\ Background             :help togglebg<CR>
+        an 9999.79 &Help.-sep3-                          <Nop>
+
+    endif
+endfunction
+
+autocmd ColorScheme * if g:colors_name != "solarized" | silent! aunmenu Solarized | else | call SolarizedMenu() | endif
+
+"}}}
+" License "{{{
+" ---------------------------------------------------------------------
+"
+" Copyright (c) 2011 Ethan Schoonover
+"
+" 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.
+"
+" vim:foldmethod=marker:foldlevel=0
+"}}}
diff --git a/vim/.vim/colors/halfdab.vim b/vim/.vim/colors/halfdab.vim
new file mode 100644
index 0000000..3fcb58a
--- /dev/null
+++ b/vim/.vim/colors/halfdab.vim
@@ -0,0 +1,155 @@
+"{- HalfDab -}#
+" A color scheme by nixy (https://github.com/nixy) "
+"  |- Inspired by sourcerer by Xero Harrison "
+
+"set background=dark
+highlight clear
+if exists("syntax_on")
+	syntax reset
+endif
+let g:colors_name = "halfdab"
+
+"{- VARIABLE DECLARATIONS -}"
+let s:black   = "0"
+let s:red     = "1"
+let s:green   = "2"
+let s:yellow  = "3"
+let s:blue    = "4"
+let s:magenta = "5"
+let s:cyan    = "6"
+let s:grey    = "7"
+
+let s:dark_grey      = "8"
+let s:bright_red     = "9"
+let s:bright_green   = "10"
+let s:bright_yellow  = "11"
+let s:bright_blue    = "12"
+let s:bright_magenta = "13"
+let s:bright_cyan    = "14"
+let s:white          = "15"
+
+let s:foreground="15"
+let s:background="0"
+
+exe "let s:bg_none           = ' ctermbg=NONE'"
+exe "let s:bg_default        = ' ctermbg=".s:background"'"
+exe "let s:bg_black          = ' ctermbg=".s:black"'"
+exe "let s:bg_red            = ' ctermbg=".s:red"'"
+exe "let s:bg_green          = ' ctermbg=".s:green"'"
+exe "let s:bg_yellow         = ' ctermbg=".s:yellow"'"
+exe "let s:bg_blue           = ' ctermbg=".s:blue"'"
+exe "let s:bg_magenta        = ' ctermbg=".s:magenta"'"
+exe "let s:bg_cyan           = ' ctermbg=".s:cyan"'"
+exe "let s:bg_grey           = ' ctermbg=".s:grey"'"
+exe "let s:bg_dark_grey      = ' ctermbg=".s:dark_grey"'"
+exe "let s:bg_bright_red     = ' ctermbg=".s:bright_red"'"
+exe "let s:bg_bright_green   = ' ctermbg=".s:bright_green"'"
+exe "let s:bg_bright_yellow  = ' ctermbg=".s:bright_yellow"'"
+exe "let s:bg_bright_blue    = ' ctermbg=".s:bright_blue"'"
+exe "let s:bg_bright_magenta = ' ctermbg=".s:bright_magenta"'"
+exe "let s:bg_bright_cyan    = ' ctermbg=".s:bright_cyan"'"
+exe "let s:bg_white          = ' ctermbg=".s:white"'"
+
+exe "let s:fg_none           = ' ctermfg=NONE'"
+exe "let s:fg_default        = ' ctermfg=".s:foreground"'"
+exe "let s:fg_black          = ' ctermfg=".s:black"'"
+exe "let s:fg_red            = ' ctermfg=".s:red"'"
+exe "let s:fg_green          = ' ctermfg=".s:green"'"
+exe "let s:fg_yellow         = ' ctermfg=".s:yellow"'"
+exe "let s:fg_blue           = ' ctermfg=".s:blue"'"
+exe "let s:fg_magenta        = ' ctermfg=".s:magenta"'"
+exe "let s:fg_cyan           = ' ctermfg=".s:cyan"'"
+exe "let s:fg_grey           = ' ctermfg=".s:grey"'"
+exe "let s:fg_dark_grey      = ' ctermfg=".s:dark_grey"'"
+exe "let s:fg_bright_red     = ' ctermfg=".s:bright_red"'"
+exe "let s:fg_bright_green   = ' ctermfg=".s:bright_green"'"
+exe "let s:fg_bright_yellow  = ' ctermfg=".s:bright_yellow"'"
+exe "let s:fg_bright_blue    = ' ctermfg=".s:bright_blue"'"
+exe "let s:fg_bright_magenta = ' ctermfg=".s:bright_magenta"'"
+exe "let s:fg_bright_cyan    = ' ctermfg=".s:bright_cyan"'"
+exe "let s:fg_white          = ' ctermfg=".s:white"'"
+
+exe "let s:fmt_none = ' cterm=NONE term=NONE'"
+exe "let s:fmt_bold = ' cterm=NONE term=NONE'"
+
+
+"{- BASIC HIGHLIGHTING -}"
+exe "hi! Normal"        .s:fmt_none .s:fg_default .s:bg_none
+
+exe "hi! Comment"       .s:fmt_none .s:fg_blue .s:bg_none
+"       *Comment        any comment
+
+exe "hi! Constant"      .s:fmt_none .s:fg_red .s:bg_none
+"       *Constant       any constant
+"        String         a string constant: "theory"
+"        Character      a character constant: 'o' '\t'
+"        Number         a number constant: 42 0xdab
+"        Boolean        a boolean constant: true FALSE
+"        Float          a floating point constant: 3.0e8
+
+exe "hi! Identifier"    .s:fmt_none .s:fg_cyan .s:bg_none
+"       *Identifier     any variable name
+"        Function       a function name
+
+exe "hi! Statement"      .s:fmt_none .s:fg_yellow .s:bg_none
+"       *Statement       any statement
+"       Conditional      if, then, else, endif, switch, etc.
+"       Repeat           for, do, while, etc.
+"       Label            case, default, etc.
+"       Operator         "sizeof", "+", "*", etc.
+"       Keyword          any other keyword
+"       Exception        try, catch, throw
+
+exe "hi! PreProc"        .s:fmt_none   .s:fg_magenta .s:bg_none
+"       *PreProc         generic Preprocessor
+"        Include         preprocessor #include
+"        Define          preprocessor #define
+"        Macro           same as Define
+"        PreCondit       preprocessor #if, #else, #endif, etc.
+
+exe "hi! Type"           .s:fmt_none   .s:fg_green .s:bg_none
+"       *Type            int, long, char, etc.
+"        StorageClass    static, register, volatile, etc.
+"        Structure       struct, union, enum, etc.
+"        Typedef         A typedef
+
+exe "hi! Special"        .s:fmt_none   .s:fg_magenta    .s:bg_none
+"       *Special         any special symbol
+"        SpecialChar     special character in a constant
+"        Tag             you can use CTRL-] on this
+"        Delimiter       character that needs attention
+"        SpecialComment  special things inside a comment
+"        Debug           debugging statements
+
+
+exe "hi! Underlined"     .s:fmt_none .s:fg_magenta .s:bg_none
+"       *Underlined      text that stands out, HTML links
+
+exe "hi! Ignore"         .s:fmt_none   .s:fg_grey   .s:bg_none
+"       *Ignore          left blank, hidden  |hl-Ignore|
+
+exe "hi! Error"          .s:fmt_bold   .s:fg_grey    .s:bg_red
+"       *Error           any erroneous construct
+
+exe "hi! Todo"           .s:fmt_bold   .s:fg_magenta.s:bg_none
+"       *Todo            anything that needs extra attention; mostly the
+"                        keywords TODO FIXME and XXX
+
+exe "hi! StatusLine"     .s:fg_dark_grey .s:bg_bright_red
+exe "hi! StatusLineNC"   .s:fg_dark_grey .s:bg_bright_magenta
+
+exe "hi! LineNr" .s:fg_dark_grey .s:bg_none
+exe "hi! CursorLineNr" .s:fg_bright_magenta .s:bg_none
+
+exe "hi! TabLine"     .s:fmt_none .s:fg_bright_red .s:bg_dark_grey
+exe "hi! TabLineSel"  .s:fmt_none .s:fg_bright_magenta .s:bg_dark_grey
+exe "hi! TabLineFill" .s:fmt_none .s:fg_none .s:bg_dark_grey
+
+exe "hi! CursorLine"   .s:fmt_none .s:bg_dark_grey
+exe "hi! CursorColumn" .s:fmt_none .s:bg_dark_grey
+
+exe "hi! VertSplit" .s:fg_dark_grey .s:bg_dark_grey
+
+"if &background == "light"
+"	highlight Normal ctermfg=0 ctermbg=15
+"endif
diff --git a/vim/.vim/colors/solarized.vim b/vim/.vim/colors/solarized.vim
new file mode 100644
index 0000000..70f5223
--- /dev/null
+++ b/vim/.vim/colors/solarized.vim
@@ -0,0 +1,1117 @@
+" Name:     Solarized vim colorscheme
+" Author:   Ethan Schoonover <es@ethanschoonover.com>
+" URL:      http://ethanschoonover.com/solarized
+"           (see this url for latest release & screenshots)
+" License:  OSI approved MIT license (see end of this file)
+" Created:  In the middle of the night
+" Modified: 2011 May 05
+"
+" Usage "{{{
+"
+" ---------------------------------------------------------------------
+" ABOUT:
+" ---------------------------------------------------------------------
+" Solarized is a carefully designed selective contrast colorscheme with dual
+" light and dark modes that runs in both GUI, 256 and 16 color modes.
+"
+" See the homepage above for screenshots and details.
+"
+" ---------------------------------------------------------------------
+" OPTIONS:
+" ---------------------------------------------------------------------
+" See the "solarized.txt" help file included with this colorscheme (in the 
+" "doc" subdirectory) for information on options, usage, the Toggle Background 
+" function and more. If you have already installed Solarized, this is available 
+" from the Solarized menu and command line as ":help solarized"
+"
+" ---------------------------------------------------------------------
+" INSTALLATION:
+" ---------------------------------------------------------------------
+" Two options for installation: manual or pathogen
+"
+" MANUAL INSTALLATION OPTION:
+" ---------------------------------------------------------------------
+"
+" 1.  Download the solarized distribution (available on the homepage above)
+"     and unarchive the file.
+" 2.  Move `solarized.vim` to your `.vim/colors` directory.
+" 3.  Move each of the files in each subdirectories to the corresponding .vim
+"     subdirectory (e.g. autoload/togglebg.vim goes into your .vim/autoload 
+"     directory as .vim/autoload/togglebg.vim).
+"
+" RECOMMENDED PATHOGEN INSTALLATION OPTION:
+" ---------------------------------------------------------------------
+"
+" 1.  Download and install Tim Pope's Pathogen from:
+"     https://github.com/tpope/vim-pathogen
+"
+" 2.  Next, move or clone the `vim-colors-solarized` directory so that it is
+"     a subdirectory of the `.vim/bundle` directory.
+"
+"     a. **clone with git:**
+"
+"       $ cd ~/.vim/bundle
+"       $ git clone git://github.com/altercation/vim-colors-solarized.git
+"
+"     b. **or move manually into the pathogen bundle directory:**
+"         In the parent directory of vim-colors-solarized:
+"
+"         $ mv vim-colors-solarized ~/.vim/bundle/
+"
+" MODIFY VIMRC:
+"
+" After either Option 1 or Option 2 above, put the following two lines in your
+" .vimrc:
+"
+"     syntax enable
+"     set background=dark
+"     colorscheme solarized
+"
+" or, for the light background mode of Solarized:
+"
+"     syntax enable
+"     set background=light
+"     colorscheme solarized
+"
+" I like to have a different background in GUI and terminal modes, so I can use
+" the following if-then. However, I find vim's background autodetection to be
+" pretty good and, at least with MacVim, I can leave this background value
+" assignment out entirely and get the same results.
+"
+"     if has('gui_running')
+"       set background=light
+"     else
+"       set background=dark
+"     endif
+"
+" See the Solarized homepage at http://ethanschoonover.com/solarized for
+" screenshots which will help you select either the light or dark background.
+"
+" ---------------------------------------------------------------------
+" COLOR VALUES
+" ---------------------------------------------------------------------
+" Download palettes and files from: http://ethanschoonover.com/solarized
+"
+" L\*a\*b values are canonical (White D65, Reference D50), other values are
+" matched in sRGB space.
+"
+" SOLARIZED HEX     16/8 TERMCOL  XTERM/HEX   L*A*B      sRGB        HSB
+" --------- ------- ---- -------  ----------- ---------- ----------- -----------
+" base03    #002b36  8/4 brblack  234 #1c1c1c 15 -12 -12   0  43  54 193 100  21
+" base02    #073642  0/4 black    235 #262626 20 -12 -12   7  54  66 192  90  26
+" base01    #586e75 10/7 brgreen  240 #4e4e4e 45 -07 -07  88 110 117 194  25  46
+" base00    #657b83 11/7 bryellow 241 #585858 50 -07 -07 101 123 131 195  23  51
+" base0     #839496 12/6 brblue   244 #808080 60 -06 -03 131 148 150 186  13  59
+" base1     #93a1a1 14/4 brcyan   245 #8a8a8a 65 -05 -02 147 161 161 180   9  63
+" base2     #eee8d5  7/7 white    254 #d7d7af 92 -00  10 238 232 213  44  11  93
+" base3     #fdf6e3 15/7 brwhite  230 #ffffd7 97  00  10 253 246 227  44  10  99
+" yellow    #b58900  3/3 yellow   136 #af8700 60  10  65 181 137   0  45 100  71
+" orange    #cb4b16  9/3 brred    166 #d75f00 50  50  55 203  75  22  18  89  80
+" red       #dc322f  1/1 red      160 #d70000 50  65  45 220  50  47   1  79  86
+" magenta   #d33682  5/5 magenta  125 #af005f 50  65 -05 211  54 130 331  74  83
+" violet    #6c71c4 13/5 brmagenta 61 #5f5faf 50  15 -45 108 113 196 237  45  77
+" blue      #268bd2  4/4 blue      33 #0087ff 55 -10 -45  38 139 210 205  82  82
+" cyan      #2aa198  6/6 cyan      37 #00afaf 60 -35 -05  42 161 152 175  74  63
+" green     #859900  2/2 green     64 #5f8700 60 -20  65 133 153   0  68 100  60
+"
+" ---------------------------------------------------------------------
+" COLORSCHEME HACKING
+" ---------------------------------------------------------------------
+"
+" Useful commands for testing colorschemes:
+" :source $VIMRUNTIME/syntax/hitest.vim
+" :help highlight-groups
+" :help cterm-colors
+" :help group-name
+"
+" Useful links for developing colorschemes:
+" http://www.vim.org/scripts/script.php?script_id=2937
+" http://vimcasts.org/episodes/creating-colorschemes-for-vim/
+" http://www.frexx.de/xterm-256-notes/"
+"
+" }}}
+" Environment Specific Overrides "{{{
+" Allow or disallow certain features based on current terminal emulator or 
+" environment.
+
+" Terminals that support italics
+let s:terms_italic=[
+            \"rxvt",
+            \"gnome-terminal"
+            \]
+" For reference only, terminals are known to be incomptible.
+" Terminals that are in neither list need to be tested.
+let s:terms_noitalic=[
+            \"iTerm.app",
+            \"Apple_Terminal"
+            \]
+if has("gui_running")
+    let s:terminal_italic=1 " TODO: could refactor to not require this at all
+else
+    let s:terminal_italic=0 " terminals will be guilty until proven compatible
+    for term in s:terms_italic
+        if $TERM_PROGRAM =~ term
+            let s:terminal_italic=1
+        endif
+    endfor
+endif
+
+" }}}
+" Default option values"{{{
+" ---------------------------------------------------------------------
+" s:options_list is used to autogenerate a list of all non-default options 
+" using "call SolarizedOptions()" or with the "Generate .vimrc commands" 
+" Solarized menu option. See the "Menus" section below for the function itself.
+let s:options_list=[
+            \'" this block of commands has been autogenerated by solarized.vim and',
+            \'" includes the current, non-default Solarized option values.',
+            \'" To use, place these commands in your .vimrc file (replacing any',
+            \'" existing colorscheme commands). See also ":help solarized"',
+            \'',
+            \'" ------------------------------------------------------------------',
+            \'" Solarized Colorscheme Config',
+            \'" ------------------------------------------------------------------',
+            \]
+let s:colorscheme_list=[
+            \'syntax enable',
+            \'set background='.&background,
+            \'colorscheme solarized',
+            \]
+let s:defaults_list=[
+            \'" ------------------------------------------------------------------',
+            \'',
+            \'" The following items are available options, but do not need to be',
+            \'" included in your .vimrc as they are currently set to their defaults.',
+            \''
+            \]
+let s:lazycat_list=[
+            \'" lazy method of appending this onto your .vimrc ":w! >> ~/.vimrc"',
+            \'" ------------------------------------------------------------------',
+            \]
+
+function! s:SetOption(name,default)
+    if type(a:default) == type(0)
+        let l:wrap=''
+        let l:ewrap=''
+    else
+        let l:wrap='"'
+        let l:ewrap='\"'
+    endif
+    if !exists("g:solarized_".a:name) || g:solarized_{a:name}==a:default
+        exe 'let g:solarized_'.a:name.'='.l:wrap.a:default.l:wrap.'"'
+        exe 'call add(s:defaults_list, "\" let g:solarized_'.a:name.'='.l:ewrap.g:solarized_{a:name}.l:ewrap.'")'
+    else
+        exe 'call add(s:options_list,  "let g:solarized_'.a:name.'='.l:ewrap.g:solarized_{a:name}.l:ewrap.'    \"default value is '.a:default.'")'
+    endif
+endfunction
+
+if ($TERM_PROGRAM ==? "apple_terminal" && &t_Co < 256)
+    let s:solarized_termtrans_default = 1
+else
+    let s:solarized_termtrans_default = 0
+endif
+call s:SetOption("termtrans",s:solarized_termtrans_default)
+call s:SetOption("degrade",0)
+call s:SetOption("bold",1)
+call s:SetOption("underline",1)
+call s:SetOption("italic",1) " note that we need to override this later if the terminal doesn't support
+call s:SetOption("termcolors",16)
+call s:SetOption("contrast","normal")
+call s:SetOption("visibility","normal")
+call s:SetOption("diffmode","normal")
+call s:SetOption("hitrail",0)
+call s:SetOption("menu",1)
+
+"}}}
+" Colorscheme initialization "{{{
+" ---------------------------------------------------------------------
+hi clear
+if exists("syntax_on")
+  syntax reset
+endif
+let colors_name = "solarized"
+
+"}}}
+" GUI & CSApprox hexadecimal palettes"{{{
+" ---------------------------------------------------------------------
+"
+" Set both gui and terminal color values in separate conditional statements
+" Due to possibility that CSApprox is running (though I suppose we could just
+" leave the hex values out entirely in that case and include only cterm colors)
+" We also check to see if user has set solarized (force use of the
+" neutral gray monotone palette component)
+if (has("gui_running") && g:solarized_degrade == 0)
+    let s:vmode       = "gui"
+    let s:base03      = "#002b36"
+    let s:base02      = "#073642"
+    let s:base01      = "#586e75"
+    let s:base00      = "#657b83"
+    let s:base0       = "#839496"
+    let s:base1       = "#93a1a1"
+    let s:base2       = "#eee8d5"
+    let s:base3       = "#fdf6e3"
+    let s:yellow      = "#b58900"
+    let s:orange      = "#cb4b16"
+    let s:red         = "#dc322f"
+    let s:magenta     = "#d33682"
+    let s:violet      = "#6c71c4"
+    let s:blue        = "#268bd2"
+    let s:cyan        = "#2aa198"
+    "let s:green       = "#859900" "original
+    let s:green       = "#719e07" "experimental
+elseif (has("gui_running") && g:solarized_degrade == 1)
+    " These colors are identical to the 256 color mode. They may be viewed
+    " while in gui mode via "let g:solarized_degrade=1", though this is not
+    " recommened and is for testing only.
+    let s:vmode       = "gui"
+    let s:base03      = "#1c1c1c"
+    let s:base02      = "#262626"
+    let s:base01      = "#4e4e4e"
+    let s:base00      = "#585858"
+    let s:base0       = "#808080"
+    let s:base1       = "#8a8a8a"
+    let s:base2       = "#d7d7af"
+    let s:base3       = "#ffffd7"
+    let s:yellow      = "#af8700"
+    let s:orange      = "#d75f00"
+    let s:red         = "#af0000"
+    let s:magenta     = "#af005f"
+    let s:violet      = "#5f5faf"
+    let s:blue        = "#0087ff"
+    let s:cyan        = "#00afaf"
+    let s:green       = "#5f8700"
+elseif g:solarized_termcolors != 256 && &t_Co >= 16
+    let s:vmode       = "cterm"
+    let s:base03      = "8"
+    let s:base02      = "0"
+    let s:base01      = "10"
+    let s:base00      = "11"
+    let s:base0       = "12"
+    let s:base1       = "14"
+    let s:base2       = "7"
+    let s:base3       = "15"
+    let s:yellow      = "3"
+    let s:orange      = "9"
+    let s:red         = "1"
+    let s:magenta     = "5"
+    let s:violet      = "13"
+    let s:blue        = "4"
+    let s:cyan        = "6"
+    let s:green       = "2"
+elseif g:solarized_termcolors == 256
+    let s:vmode       = "cterm"
+    let s:base03      = "234"
+    let s:base02      = "235"
+    let s:base01      = "239"
+    let s:base00      = "240"
+    let s:base0       = "244"
+    let s:base1       = "245"
+    let s:base2       = "187"
+    let s:base3       = "230"
+    let s:yellow      = "136"
+    let s:orange      = "166"
+    let s:red         = "124"
+    let s:magenta     = "125"
+    let s:violet      = "61"
+    let s:blue        = "33"
+    let s:cyan        = "37"
+    let s:green       = "64"
+else
+    let s:vmode       = "cterm"
+    let s:bright      = "* term=bold cterm=bold"
+"   let s:base03      = "0".s:bright
+"   let s:base02      = "0"
+"   let s:base01      = "2".s:bright
+"   let s:base00      = "3".s:bright
+"   let s:base0       = "4".s:bright
+"   let s:base1       = "6".s:bright
+"   let s:base2       = "7"
+"   let s:base3       = "7".s:bright
+"   let s:yellow      = "3"
+"   let s:orange      = "1".s:bright
+"   let s:red         = "1"
+"   let s:magenta     = "5"
+"   let s:violet      = "5".s:bright
+"   let s:blue        = "4"
+"   let s:cyan        = "6"
+"   let s:green       = "2"
+    let s:base03      = "DarkGray"      " 0*
+    let s:base02      = "Black"         " 0
+    let s:base01      = "LightGreen"    " 2*
+    let s:base00      = "LightYellow"   " 3*
+    let s:base0       = "LightBlue"     " 4*
+    let s:base1       = "LightCyan"     " 6*
+    let s:base2       = "LightGray"     " 7
+    let s:base3       = "White"         " 7*
+    let s:yellow      = "DarkYellow"    " 3
+    let s:orange      = "LightRed"      " 1*
+    let s:red         = "DarkRed"       " 1
+    let s:magenta     = "DarkMagenta"   " 5
+    let s:violet      = "LightMagenta"  " 5*
+    let s:blue        = "DarkBlue"      " 4
+    let s:cyan        = "DarkCyan"      " 6
+    let s:green       = "DarkGreen"     " 2
+
+endif
+"}}}
+" Formatting options and null values for passthrough effect "{{{
+" ---------------------------------------------------------------------
+    let s:none            = "NONE"
+    let s:none            = "NONE"
+    let s:t_none          = "NONE"
+    let s:n               = "NONE"
+    let s:c               = ",undercurl"
+    let s:r               = ",reverse"
+    let s:s               = ",standout"
+    let s:ou              = ""
+    let s:ob              = ""
+"}}}
+" Background value based on termtrans setting "{{{
+" ---------------------------------------------------------------------
+if (has("gui_running") || g:solarized_termtrans == 0)
+    let s:back        = s:base03
+else
+    let s:back        = "NONE"
+endif
+"}}}
+" Alternate light scheme "{{{
+" ---------------------------------------------------------------------
+if &background == "light"
+    let s:temp03      = s:base03
+    let s:temp02      = s:base02
+    let s:temp01      = s:base01
+    let s:temp00      = s:base00
+    let s:base03      = s:base3
+    let s:base02      = s:base2
+    let s:base01      = s:base1
+    let s:base00      = s:base0
+    let s:base0       = s:temp00
+    let s:base1       = s:temp01
+    let s:base2       = s:temp02
+    let s:base3       = s:temp03
+    if (s:back != "NONE")
+        let s:back    = s:base03
+    endif
+endif
+"}}}
+" Optional contrast schemes "{{{
+" ---------------------------------------------------------------------
+if g:solarized_contrast == "high"
+    let s:base01      = s:base00
+    let s:base00      = s:base0
+    let s:base0       = s:base1
+    let s:base1       = s:base2
+    let s:base2       = s:base3
+    let s:back        = s:back
+endif
+if g:solarized_contrast == "low"
+    let s:back        = s:base02
+    let s:ou          = ",underline"
+endif
+"}}}
+" Overrides dependent on user specified values and environment "{{{
+" ---------------------------------------------------------------------
+if (g:solarized_bold == 0 || &t_Co == 8 )
+    let s:b           = ""
+    let s:bb          = ",bold"
+else
+    let s:b           = ",bold"
+    let s:bb          = ""
+endif
+
+if g:solarized_underline == 0
+    let s:u           = ""
+else
+    let s:u           = ",underline"
+endif
+
+if g:solarized_italic == 0 || s:terminal_italic == 0
+    let s:i           = ""
+else
+    let s:i           = ",italic"
+endif
+"}}}
+" Highlighting primitives"{{{
+" ---------------------------------------------------------------------
+
+exe "let s:bg_none      = ' ".s:vmode."bg=".s:none   ."'"
+exe "let s:bg_back      = ' ".s:vmode."bg=".s:back   ."'"
+exe "let s:bg_base03    = ' ".s:vmode."bg=".s:base03 ."'"
+exe "let s:bg_base02    = ' ".s:vmode."bg=".s:base02 ."'"
+exe "let s:bg_base01    = ' ".s:vmode."bg=".s:base01 ."'"
+exe "let s:bg_base00    = ' ".s:vmode."bg=".s:base00 ."'"
+exe "let s:bg_base0     = ' ".s:vmode."bg=".s:base0  ."'"
+exe "let s:bg_base1     = ' ".s:vmode."bg=".s:base1  ."'"
+exe "let s:bg_base2     = ' ".s:vmode."bg=".s:base2  ."'"
+exe "let s:bg_base3     = ' ".s:vmode."bg=".s:base3  ."'"
+exe "let s:bg_green     = ' ".s:vmode."bg=".s:green  ."'"
+exe "let s:bg_yellow    = ' ".s:vmode."bg=".s:yellow ."'"
+exe "let s:bg_orange    = ' ".s:vmode."bg=".s:orange ."'"
+exe "let s:bg_red       = ' ".s:vmode."bg=".s:red    ."'"
+exe "let s:bg_magenta   = ' ".s:vmode."bg=".s:magenta."'"
+exe "let s:bg_violet    = ' ".s:vmode."bg=".s:violet ."'"
+exe "let s:bg_blue      = ' ".s:vmode."bg=".s:blue   ."'"
+exe "let s:bg_cyan      = ' ".s:vmode."bg=".s:cyan   ."'"
+
+exe "let s:fg_none      = ' ".s:vmode."fg=".s:none   ."'"
+exe "let s:fg_back      = ' ".s:vmode."fg=".s:back   ."'"
+exe "let s:fg_base03    = ' ".s:vmode."fg=".s:base03 ."'"
+exe "let s:fg_base02    = ' ".s:vmode."fg=".s:base02 ."'"
+exe "let s:fg_base01    = ' ".s:vmode."fg=".s:base01 ."'"
+exe "let s:fg_base00    = ' ".s:vmode."fg=".s:base00 ."'"
+exe "let s:fg_base0     = ' ".s:vmode."fg=".s:base0  ."'"
+exe "let s:fg_base1     = ' ".s:vmode."fg=".s:base1  ."'"
+exe "let s:fg_base2     = ' ".s:vmode."fg=".s:base2  ."'"
+exe "let s:fg_base3     = ' ".s:vmode."fg=".s:base3  ."'"
+exe "let s:fg_green     = ' ".s:vmode."fg=".s:green  ."'"
+exe "let s:fg_yellow    = ' ".s:vmode."fg=".s:yellow ."'"
+exe "let s:fg_orange    = ' ".s:vmode."fg=".s:orange ."'"
+exe "let s:fg_red       = ' ".s:vmode."fg=".s:red    ."'"
+exe "let s:fg_magenta   = ' ".s:vmode."fg=".s:magenta."'"
+exe "let s:fg_violet    = ' ".s:vmode."fg=".s:violet ."'"
+exe "let s:fg_blue      = ' ".s:vmode."fg=".s:blue   ."'"
+exe "let s:fg_cyan      = ' ".s:vmode."fg=".s:cyan   ."'"
+
+exe "let s:fmt_none     = ' ".s:vmode."=NONE".          " term=NONE".    "'"
+exe "let s:fmt_bold     = ' ".s:vmode."=NONE".s:b.      " term=NONE".s:b."'"
+exe "let s:fmt_bldi     = ' ".s:vmode."=NONE".s:b.      " term=NONE".s:b."'"
+exe "let s:fmt_undr     = ' ".s:vmode."=NONE".s:u.      " term=NONE".s:u."'"
+exe "let s:fmt_undb     = ' ".s:vmode."=NONE".s:u.s:b.  " term=NONE".s:u.s:b."'"
+exe "let s:fmt_undi     = ' ".s:vmode."=NONE".s:u.      " term=NONE".s:u."'"
+exe "let s:fmt_uopt     = ' ".s:vmode."=NONE".s:ou.     " term=NONE".s:ou."'"
+exe "let s:fmt_curl     = ' ".s:vmode."=NONE".s:c.      " term=NONE".s:c."'"
+exe "let s:fmt_ital     = ' ".s:vmode."=NONE".s:i.      " term=NONE".s:i."'"
+exe "let s:fmt_stnd     = ' ".s:vmode."=NONE".s:s.      " term=NONE".s:s."'"
+exe "let s:fmt_revr     = ' ".s:vmode."=NONE".s:r.      " term=NONE".s:r."'"
+exe "let s:fmt_revb     = ' ".s:vmode."=NONE".s:r.s:b.  " term=NONE".s:r.s:b."'"
+" revbb (reverse bold for bright colors) is only set to actual bold in low 
+" color terminals (t_co=8, such as OS X Terminal.app) and should only be used 
+" with colors 8-15.
+exe "let s:fmt_revbb    = ' ".s:vmode."=NONE".s:r.s:bb.   " term=NONE".s:r.s:bb."'"
+exe "let s:fmt_revbbu   = ' ".s:vmode."=NONE".s:r.s:bb.s:u." term=NONE".s:r.s:bb.s:u."'"
+
+if has("gui_running")
+    exe "let s:sp_none      = ' guisp=".s:none   ."'"
+    exe "let s:sp_back      = ' guisp=".s:back   ."'"
+    exe "let s:sp_base03    = ' guisp=".s:base03 ."'"
+    exe "let s:sp_base02    = ' guisp=".s:base02 ."'"
+    exe "let s:sp_base01    = ' guisp=".s:base01 ."'"
+    exe "let s:sp_base00    = ' guisp=".s:base00 ."'"
+    exe "let s:sp_base0     = ' guisp=".s:base0  ."'"
+    exe "let s:sp_base1     = ' guisp=".s:base1  ."'"
+    exe "let s:sp_base2     = ' guisp=".s:base2  ."'"
+    exe "let s:sp_base3     = ' guisp=".s:base3  ."'"
+    exe "let s:sp_green     = ' guisp=".s:green  ."'"
+    exe "let s:sp_yellow    = ' guisp=".s:yellow ."'"
+    exe "let s:sp_orange    = ' guisp=".s:orange ."'"
+    exe "let s:sp_red       = ' guisp=".s:red    ."'"
+    exe "let s:sp_magenta   = ' guisp=".s:magenta."'"
+    exe "let s:sp_violet    = ' guisp=".s:violet ."'"
+    exe "let s:sp_blue      = ' guisp=".s:blue   ."'"
+    exe "let s:sp_cyan      = ' guisp=".s:cyan   ."'"
+else
+    let s:sp_none      = ""
+    let s:sp_back      = ""
+    let s:sp_base03    = ""
+    let s:sp_base02    = ""
+    let s:sp_base01    = ""
+    let s:sp_base00    = ""
+    let s:sp_base0     = ""
+    let s:sp_base1     = ""
+    let s:sp_base2     = ""
+    let s:sp_base3     = ""
+    let s:sp_green     = ""
+    let s:sp_yellow    = ""
+    let s:sp_orange    = ""
+    let s:sp_red       = ""
+    let s:sp_magenta   = ""
+    let s:sp_violet    = ""
+    let s:sp_blue      = ""
+    let s:sp_cyan      = ""
+endif
+
+"}}}
+" Basic highlighting"{{{
+" ---------------------------------------------------------------------
+" note that link syntax to avoid duplicate configuration doesn't work with the
+" exe compiled formats
+
+exe "hi! Normal"         .s:fmt_none   .s:fg_base0  .s:bg_back
+
+exe "hi! Comment"        .s:fmt_ital   .s:fg_base01 .s:bg_none
+"       *Comment         any comment
+
+exe "hi! Constant"       .s:fmt_none   .s:fg_cyan   .s:bg_none
+"       *Constant        any constant
+"        String          a string constant: "this is a string"
+"        Character       a character constant: 'c', '\n'
+"        Number          a number constant: 234, 0xff
+"        Boolean         a boolean constant: TRUE, false
+"        Float           a floating point constant: 2.3e10
+
+exe "hi! Identifier"     .s:fmt_none   .s:fg_blue   .s:bg_none
+"       *Identifier      any variable name
+"        Function        function name (also: methods for classes)
+"
+exe "hi! Statement"      .s:fmt_none   .s:fg_green  .s:bg_none
+"       *Statement       any statement
+"        Conditional     if, then, else, endif, switch, etc.
+"        Repeat          for, do, while, etc.
+"        Label           case, default, etc.
+"        Operator        "sizeof", "+", "*", etc.
+"        Keyword         any other keyword
+"        Exception       try, catch, throw
+
+exe "hi! PreProc"        .s:fmt_none   .s:fg_orange .s:bg_none
+"       *PreProc         generic Preprocessor
+"        Include         preprocessor #include
+"        Define          preprocessor #define
+"        Macro           same as Define
+"        PreCondit       preprocessor #if, #else, #endif, etc.
+
+exe "hi! Type"           .s:fmt_none   .s:fg_yellow .s:bg_none
+"       *Type            int, long, char, etc.
+"        StorageClass    static, register, volatile, etc.
+"        Structure       struct, union, enum, etc.
+"        Typedef         A typedef
+
+exe "hi! Special"        .s:fmt_none   .s:fg_red    .s:bg_none
+"       *Special         any special symbol
+"        SpecialChar     special character in a constant
+"        Tag             you can use CTRL-] on this
+"        Delimiter       character that needs attention
+"        SpecialComment  special things inside a comment
+"        Debug           debugging statements
+
+exe "hi! Underlined"     .s:fmt_none   .s:fg_violet .s:bg_none
+"       *Underlined      text that stands out, HTML links
+
+exe "hi! Ignore"         .s:fmt_none   .s:fg_none   .s:bg_none
+"       *Ignore          left blank, hidden  |hl-Ignore|
+
+exe "hi! Error"          .s:fmt_bold   .s:fg_red    .s:bg_none
+"       *Error           any erroneous construct
+
+exe "hi! Todo"           .s:fmt_bold   .s:fg_magenta.s:bg_none
+"       *Todo            anything that needs extra attention; mostly the
+"                        keywords TODO FIXME and XXX
+"
+"}}}
+" Extended highlighting "{{{
+" ---------------------------------------------------------------------
+if      (g:solarized_visibility=="high")
+    exe "hi! SpecialKey" .s:fmt_revr   .s:fg_red    .s:bg_none
+    exe "hi! NonText"    .s:fmt_bold   .s:fg_red    .s:bg_none
+elseif  (g:solarized_visibility=="low")
+    exe "hi! SpecialKey" .s:fmt_bold   .s:fg_base02 .s:bg_none
+    exe "hi! NonText"    .s:fmt_bold   .s:fg_base02 .s:bg_none
+else
+    exe "hi! SpecialKey" .s:fmt_bold   .s:fg_base00 .s:bg_base02
+    exe "hi! NonText"    .s:fmt_bold   .s:fg_base00 .s:bg_none
+endif
+exe "hi! StatusLine"     .s:fmt_none   .s:fg_base1  .s:bg_base02 .s:fmt_revbb
+exe "hi! StatusLineNC"   .s:fmt_none   .s:fg_base00 .s:bg_base02 .s:fmt_revbb
+exe "hi! Visual"         .s:fmt_none   .s:fg_base01 .s:bg_base03 .s:fmt_revbb
+exe "hi! Directory"      .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! ErrorMsg"       .s:fmt_revr   .s:fg_red    .s:bg_none
+exe "hi! IncSearch"      .s:fmt_stnd   .s:fg_orange .s:bg_none
+exe "hi! Search"         .s:fmt_revr   .s:fg_yellow .s:bg_none
+exe "hi! MoreMsg"        .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! ModeMsg"        .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! LineNr"         .s:fmt_none   .s:fg_base01 .s:bg_base02
+exe "hi! Question"       .s:fmt_bold   .s:fg_cyan   .s:bg_none
+if ( has("gui_running") || &t_Co > 8 )
+    exe "hi! VertSplit"  .s:fmt_none   .s:fg_base00 .s:bg_base00
+else
+    exe "hi! VertSplit"  .s:fmt_revbb  .s:fg_base00 .s:bg_base02
+endif
+exe "hi! Title"          .s:fmt_bold   .s:fg_orange .s:bg_none
+exe "hi! VisualNOS"      .s:fmt_stnd   .s:fg_none   .s:bg_base02 .s:fmt_revbb
+exe "hi! WarningMsg"     .s:fmt_bold   .s:fg_red    .s:bg_none
+exe "hi! WildMenu"       .s:fmt_none   .s:fg_base2  .s:bg_base02 .s:fmt_revbb
+exe "hi! Folded"         .s:fmt_undb   .s:fg_base0  .s:bg_base02  .s:sp_base03
+exe "hi! FoldColumn"     .s:fmt_none   .s:fg_base0  .s:bg_base02
+if      (g:solarized_diffmode=="high")
+exe "hi! DiffAdd"        .s:fmt_revr   .s:fg_green  .s:bg_none
+exe "hi! DiffChange"     .s:fmt_revr   .s:fg_yellow .s:bg_none
+exe "hi! DiffDelete"     .s:fmt_revr   .s:fg_red    .s:bg_none
+exe "hi! DiffText"       .s:fmt_revr   .s:fg_blue   .s:bg_none
+elseif  (g:solarized_diffmode=="low")
+exe "hi! DiffAdd"        .s:fmt_undr   .s:fg_green  .s:bg_none   .s:sp_green
+exe "hi! DiffChange"     .s:fmt_undr   .s:fg_yellow .s:bg_none   .s:sp_yellow
+exe "hi! DiffDelete"     .s:fmt_bold   .s:fg_red    .s:bg_none
+exe "hi! DiffText"       .s:fmt_undr   .s:fg_blue   .s:bg_none   .s:sp_blue
+else " normal
+    if has("gui_running")
+exe "hi! DiffAdd"        .s:fmt_bold   .s:fg_green  .s:bg_base02 .s:sp_green
+exe "hi! DiffChange"     .s:fmt_bold   .s:fg_yellow .s:bg_base02 .s:sp_yellow
+exe "hi! DiffDelete"     .s:fmt_bold   .s:fg_red    .s:bg_base02
+exe "hi! DiffText"       .s:fmt_bold   .s:fg_blue   .s:bg_base02 .s:sp_blue
+    else
+exe "hi! DiffAdd"        .s:fmt_none   .s:fg_green  .s:bg_base02 .s:sp_green
+exe "hi! DiffChange"     .s:fmt_none   .s:fg_yellow .s:bg_base02 .s:sp_yellow
+exe "hi! DiffDelete"     .s:fmt_none   .s:fg_red    .s:bg_base02
+exe "hi! DiffText"       .s:fmt_none   .s:fg_blue   .s:bg_base02 .s:sp_blue
+    endif
+endif
+exe "hi! SignColumn"     .s:fmt_none   .s:fg_base0
+exe "hi! Conceal"        .s:fmt_none   .s:fg_blue   .s:bg_none
+exe "hi! SpellBad"       .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_red
+exe "hi! SpellCap"       .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_violet
+exe "hi! SpellRare"      .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_cyan
+exe "hi! SpellLocal"     .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_yellow
+exe "hi! Pmenu"          .s:fmt_none   .s:fg_base0  .s:bg_base02  .s:fmt_revbb
+exe "hi! PmenuSel"       .s:fmt_none   .s:fg_base01 .s:bg_base2   .s:fmt_revbb
+exe "hi! PmenuSbar"      .s:fmt_none   .s:fg_base2  .s:bg_base0   .s:fmt_revbb
+exe "hi! PmenuThumb"     .s:fmt_none   .s:fg_base0  .s:bg_base03  .s:fmt_revbb
+exe "hi! TabLine"        .s:fmt_undr   .s:fg_base0  .s:bg_base02  .s:sp_base0
+exe "hi! TabLineFill"    .s:fmt_undr   .s:fg_base0  .s:bg_base02  .s:sp_base0
+exe "hi! TabLineSel"     .s:fmt_undr   .s:fg_base01 .s:bg_base2   .s:sp_base0  .s:fmt_revbbu
+exe "hi! CursorColumn"   .s:fmt_none   .s:fg_none   .s:bg_base02
+exe "hi! CursorLine"     .s:fmt_uopt   .s:fg_none   .s:bg_base02  .s:sp_base1
+exe "hi! ColorColumn"    .s:fmt_none   .s:fg_none   .s:bg_base02
+exe "hi! Cursor"         .s:fmt_none   .s:fg_base03 .s:bg_base0
+hi! link lCursor Cursor
+exe "hi! MatchParen"     .s:fmt_bold   .s:fg_red    .s:bg_base01
+
+"}}}
+" vim syntax highlighting "{{{
+" ---------------------------------------------------------------------
+"exe "hi! vimLineComment" . s:fg_base01 .s:bg_none   .s:fmt_ital
+"hi! link vimComment Comment
+"hi! link vimLineComment Comment
+hi! link vimVar Identifier
+hi! link vimFunc Function
+hi! link vimUserFunc Function
+hi! link helpSpecial Special
+hi! link vimSet Normal
+hi! link vimSetEqual Normal
+exe "hi! vimCommentString"  .s:fmt_none    .s:fg_violet .s:bg_none
+exe "hi! vimCommand"        .s:fmt_none    .s:fg_yellow .s:bg_none
+exe "hi! vimCmdSep"         .s:fmt_bold    .s:fg_blue   .s:bg_none
+exe "hi! helpExample"       .s:fmt_none    .s:fg_base1  .s:bg_none
+exe "hi! helpOption"        .s:fmt_none    .s:fg_cyan   .s:bg_none
+exe "hi! helpNote"          .s:fmt_none    .s:fg_magenta.s:bg_none
+exe "hi! helpVim"           .s:fmt_none    .s:fg_magenta.s:bg_none
+exe "hi! helpHyperTextJump" .s:fmt_undr    .s:fg_blue   .s:bg_none
+exe "hi! helpHyperTextEntry".s:fmt_none    .s:fg_green  .s:bg_none
+exe "hi! vimIsCommand"      .s:fmt_none    .s:fg_base00 .s:bg_none
+exe "hi! vimSynMtchOpt"     .s:fmt_none    .s:fg_yellow .s:bg_none
+exe "hi! vimSynType"        .s:fmt_none    .s:fg_cyan   .s:bg_none
+exe "hi! vimHiLink"         .s:fmt_none    .s:fg_blue   .s:bg_none
+exe "hi! vimHiGroup"        .s:fmt_none    .s:fg_blue   .s:bg_none
+exe "hi! vimGroup"          .s:fmt_undb    .s:fg_blue   .s:bg_none
+"}}}
+" diff highlighting "{{{
+" ---------------------------------------------------------------------
+hi! link diffAdded Statement
+hi! link diffLine Identifier
+"}}}
+" git & gitcommit highlighting "{{{
+"git
+"exe "hi! gitDateHeader"
+"exe "hi! gitIdentityHeader"
+"exe "hi! gitIdentityKeyword"
+"exe "hi! gitNotesHeader"
+"exe "hi! gitReflogHeader"
+"exe "hi! gitKeyword"
+"exe "hi! gitIdentity"
+"exe "hi! gitEmailDelimiter"
+"exe "hi! gitEmail"
+"exe "hi! gitDate"
+"exe "hi! gitMode"
+"exe "hi! gitHashAbbrev"
+"exe "hi! gitHash"
+"exe "hi! gitReflogMiddle"
+"exe "hi! gitReference"
+"exe "hi! gitStage"
+"exe "hi! gitType"
+"exe "hi! gitDiffAdded"
+"exe "hi! gitDiffRemoved"
+"gitcommit
+"exe "hi! gitcommitSummary"      
+exe "hi! gitcommitComment"      .s:fmt_ital     .s:fg_base01    .s:bg_none
+hi! link gitcommitUntracked gitcommitComment
+hi! link gitcommitDiscarded gitcommitComment
+hi! link gitcommitSelected  gitcommitComment
+exe "hi! gitcommitUnmerged"     .s:fmt_bold     .s:fg_green     .s:bg_none
+exe "hi! gitcommitOnBranch"     .s:fmt_bold     .s:fg_base01    .s:bg_none
+exe "hi! gitcommitBranch"       .s:fmt_bold     .s:fg_magenta   .s:bg_none
+hi! link gitcommitNoBranch gitcommitBranch
+exe "hi! gitcommitDiscardedType".s:fmt_none     .s:fg_red       .s:bg_none
+exe "hi! gitcommitSelectedType" .s:fmt_none     .s:fg_green     .s:bg_none
+"exe "hi! gitcommitUnmergedType"
+"exe "hi! gitcommitType"
+"exe "hi! gitcommitNoChanges"
+"exe "hi! gitcommitHeader"
+exe "hi! gitcommitHeader"       .s:fmt_none     .s:fg_base01    .s:bg_none
+exe "hi! gitcommitUntrackedFile".s:fmt_bold     .s:fg_cyan      .s:bg_none
+exe "hi! gitcommitDiscardedFile".s:fmt_bold     .s:fg_red       .s:bg_none
+exe "hi! gitcommitSelectedFile" .s:fmt_bold     .s:fg_green     .s:bg_none
+exe "hi! gitcommitUnmergedFile" .s:fmt_bold     .s:fg_yellow    .s:bg_none
+exe "hi! gitcommitFile"         .s:fmt_bold     .s:fg_base0     .s:bg_none
+hi! link gitcommitDiscardedArrow gitcommitDiscardedFile
+hi! link gitcommitSelectedArrow  gitcommitSelectedFile
+hi! link gitcommitUnmergedArrow  gitcommitUnmergedFile
+"exe "hi! gitcommitArrow"
+"exe "hi! gitcommitOverflow"
+"exe "hi! gitcommitBlank"
+" }}}
+" html highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! htmlTag"           .s:fmt_none .s:fg_base01 .s:bg_none
+exe "hi! htmlEndTag"        .s:fmt_none .s:fg_base01 .s:bg_none
+exe "hi! htmlTagN"          .s:fmt_bold .s:fg_base1  .s:bg_none
+exe "hi! htmlTagName"       .s:fmt_bold .s:fg_blue   .s:bg_none
+exe "hi! htmlSpecialTagName".s:fmt_ital .s:fg_blue   .s:bg_none
+exe "hi! htmlArg"           .s:fmt_none .s:fg_base00 .s:bg_none
+exe "hi! javaScript"        .s:fmt_none .s:fg_yellow .s:bg_none
+"}}}
+" perl highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! perlHereDoc"    . s:fg_base1  .s:bg_back   .s:fmt_none
+exe "hi! perlVarPlain"   . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! perlStatementFileDesc". s:fg_cyan.s:bg_back.s:fmt_none
+
+"}}}
+" tex highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! texStatement"   . s:fg_cyan   .s:bg_back   .s:fmt_none
+exe "hi! texMathZoneX"   . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! texMathMatcher" . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! texMathMatcher" . s:fg_yellow .s:bg_back   .s:fmt_none
+exe "hi! texRefLabel"    . s:fg_yellow .s:bg_back   .s:fmt_none
+"}}}
+" ruby highlighting "{{{
+" ---------------------------------------------------------------------
+exe "hi! rubyDefine"     . s:fg_base1  .s:bg_back   .s:fmt_bold
+"rubyInclude
+"rubySharpBang
+"rubyAccess
+"rubyPredefinedVariable
+"rubyBoolean
+"rubyClassVariable
+"rubyBeginEnd
+"rubyRepeatModifier
+"hi! link rubyArrayDelimiter    Special  " [ , , ]
+"rubyCurlyBlock  { , , }
+
+"hi! link rubyClass             Keyword
+"hi! link rubyModule            Keyword
+"hi! link rubyKeyword           Keyword
+"hi! link rubyOperator          Operator
+"hi! link rubyIdentifier        Identifier
+"hi! link rubyInstanceVariable  Identifier
+"hi! link rubyGlobalVariable    Identifier
+"hi! link rubyClassVariable     Identifier
+"hi! link rubyConstant          Type
+"}}}
+" haskell syntax highlighting"{{{
+" ---------------------------------------------------------------------
+" For use with syntax/haskell.vim : Haskell Syntax File
+" http://www.vim.org/scripts/script.php?script_id=3034
+" See also Steffen Siering's github repository:
+" http://github.com/urso/dotrc/blob/master/vim/syntax/haskell.vim
+" ---------------------------------------------------------------------
+"
+" Treat True and False specially, see the plugin referenced above
+let hs_highlight_boolean=1
+" highlight delims, see the plugin referenced above
+let hs_highlight_delimiters=1
+
+exe "hi! cPreCondit". s:fg_orange.s:bg_none   .s:fmt_none
+
+exe "hi! VarId"    . s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! ConId"    . s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! hsImport" . s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! hsString" . s:fg_base00 .s:bg_none   .s:fmt_none
+
+exe "hi! hsStructure"        . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hs_hlFunctionName"  . s:fg_blue   .s:bg_none
+exe "hi! hsStatement"        . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsImportLabel"      . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hs_OpFunctionName"  . s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! hs_DeclareFunction" . s:fg_orange .s:bg_none   .s:fmt_none
+exe "hi! hsVarSym"           . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsType"             . s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! hsTypedef"          . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsModuleName"       . s:fg_green  .s:bg_none   .s:fmt_undr
+exe "hi! hsModuleStartLabel" . s:fg_magenta.s:bg_none   .s:fmt_none
+hi! link hsImportParams      Delimiter
+hi! link hsDelimTypeExport   Delimiter
+hi! link hsModuleStartLabel  hsStructure
+hi! link hsModuleWhereLabel  hsModuleStartLabel
+
+" following is for the haskell-conceal plugin
+" the first two items don't have an impact, but better safe
+exe "hi! hsNiceOperator"     . s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! hsniceoperator"     . s:fg_cyan   .s:bg_none   .s:fmt_none
+
+"}}}
+" pandoc markdown syntax highlighting "{{{
+" ---------------------------------------------------------------------
+
+"PandocHiLink pandocNormalBlock
+exe "hi! pandocTitleBlock"               .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocTitleBlockTitle"          .s:fg_blue   .s:bg_none   .s:fmt_bold
+exe "hi! pandocTitleComment"             .s:fg_blue   .s:bg_none   .s:fmt_bold
+exe "hi! pandocComment"                  .s:fg_base01 .s:bg_none   .s:fmt_ital
+exe "hi! pandocVerbatimBlock"            .s:fg_yellow .s:bg_none   .s:fmt_none
+hi! link pandocVerbatimBlockDeep         pandocVerbatimBlock
+hi! link pandocCodeBlock                 pandocVerbatimBlock
+hi! link pandocCodeBlockDelim            pandocVerbatimBlock
+exe "hi! pandocBlockQuote"               .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader1"        .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader2"        .s:fg_cyan   .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader3"        .s:fg_yellow .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader4"        .s:fg_red    .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader5"        .s:fg_base0  .s:bg_none   .s:fmt_none
+exe "hi! pandocBlockQuoteLeader6"        .s:fg_base01 .s:bg_none   .s:fmt_none
+exe "hi! pandocListMarker"               .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocListReference"            .s:fg_magenta.s:bg_none   .s:fmt_undr
+
+" Definitions
+" ---------------------------------------------------------------------
+let s:fg_pdef = s:fg_violet
+exe "hi! pandocDefinitionBlock"              .s:fg_pdef  .s:bg_none  .s:fmt_none
+exe "hi! pandocDefinitionTerm"               .s:fg_pdef  .s:bg_none  .s:fmt_stnd
+exe "hi! pandocDefinitionIndctr"             .s:fg_pdef  .s:bg_none  .s:fmt_bold
+exe "hi! pandocEmphasisDefinition"           .s:fg_pdef  .s:bg_none  .s:fmt_ital
+exe "hi! pandocEmphasisNestedDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_bold
+exe "hi! pandocStrongEmphasisNestedDefinition"   .s:fg_pdef.s:bg_none.s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasisDefinition" .s:fg_pdef.s:bg_none.s:fmt_bldi
+exe "hi! pandocStrikeoutDefinition"          .s:fg_pdef  .s:bg_none  .s:fmt_revr
+exe "hi! pandocVerbatimInlineDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_none
+exe "hi! pandocSuperscriptDefinition"        .s:fg_pdef  .s:bg_none  .s:fmt_none
+exe "hi! pandocSubscriptDefinition"          .s:fg_pdef  .s:bg_none  .s:fmt_none
+
+" Tables
+" ---------------------------------------------------------------------
+let s:fg_ptable = s:fg_blue
+exe "hi! pandocTable"                        .s:fg_ptable.s:bg_none  .s:fmt_none
+exe "hi! pandocTableStructure"               .s:fg_ptable.s:bg_none  .s:fmt_none
+hi! link pandocTableStructureTop             pandocTableStructre
+hi! link pandocTableStructureEnd             pandocTableStructre
+exe "hi! pandocTableZebraLight"              .s:fg_ptable.s:bg_base03.s:fmt_none
+exe "hi! pandocTableZebraDark"               .s:fg_ptable.s:bg_base02.s:fmt_none
+exe "hi! pandocEmphasisTable"                .s:fg_ptable.s:bg_none  .s:fmt_ital
+exe "hi! pandocEmphasisNestedTable"          .s:fg_ptable.s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisTable"          .s:fg_ptable.s:bg_none  .s:fmt_bold
+exe "hi! pandocStrongEmphasisNestedTable"    .s:fg_ptable.s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasisTable"  .s:fg_ptable.s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrikeoutTable"               .s:fg_ptable.s:bg_none  .s:fmt_revr
+exe "hi! pandocVerbatimInlineTable"          .s:fg_ptable.s:bg_none  .s:fmt_none
+exe "hi! pandocSuperscriptTable"             .s:fg_ptable.s:bg_none  .s:fmt_none
+exe "hi! pandocSubscriptTable"               .s:fg_ptable.s:bg_none  .s:fmt_none
+
+" Headings
+" ---------------------------------------------------------------------
+let s:fg_phead = s:fg_orange
+exe "hi! pandocHeading"                      .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocHeadingMarker"                .s:fg_yellow.s:bg_none.s:fmt_bold
+exe "hi! pandocEmphasisHeading"              .s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocEmphasisNestedHeading"        .s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocStrongEmphasisHeading"        .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocStrongEmphasisNestedHeading"  .s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasisHeading".s:fg_phead .s:bg_none.s:fmt_bldi
+exe "hi! pandocStrikeoutHeading"             .s:fg_phead .s:bg_none.s:fmt_revr
+exe "hi! pandocVerbatimInlineHeading"        .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocSuperscriptHeading"           .s:fg_phead .s:bg_none.s:fmt_bold
+exe "hi! pandocSubscriptHeading"             .s:fg_phead .s:bg_none.s:fmt_bold
+
+" Links
+" ---------------------------------------------------------------------
+exe "hi! pandocLinkDelim"                .s:fg_base01 .s:bg_none   .s:fmt_none
+exe "hi! pandocLinkLabel"                .s:fg_blue   .s:bg_none   .s:fmt_undr
+exe "hi! pandocLinkText"                 .s:fg_blue   .s:bg_none   .s:fmt_undb
+exe "hi! pandocLinkURL"                  .s:fg_base00 .s:bg_none   .s:fmt_undr
+exe "hi! pandocLinkTitle"                .s:fg_base00 .s:bg_none   .s:fmt_undi
+exe "hi! pandocLinkTitleDelim"           .s:fg_base01 .s:bg_none   .s:fmt_undi   .s:sp_base00
+exe "hi! pandocLinkDefinition"           .s:fg_cyan   .s:bg_none   .s:fmt_undr   .s:sp_base00
+exe "hi! pandocLinkDefinitionID"         .s:fg_blue   .s:bg_none   .s:fmt_bold
+exe "hi! pandocImageCaption"             .s:fg_violet .s:bg_none   .s:fmt_undb
+exe "hi! pandocFootnoteLink"             .s:fg_green  .s:bg_none   .s:fmt_undr
+exe "hi! pandocFootnoteDefLink"          .s:fg_green  .s:bg_none   .s:fmt_bold
+exe "hi! pandocFootnoteInline"           .s:fg_green  .s:bg_none   .s:fmt_undb
+exe "hi! pandocFootnote"                 .s:fg_green  .s:bg_none   .s:fmt_none
+exe "hi! pandocCitationDelim"            .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocCitation"                 .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocCitationID"               .s:fg_magenta.s:bg_none   .s:fmt_undr
+exe "hi! pandocCitationRef"              .s:fg_magenta.s:bg_none   .s:fmt_none
+
+" Main Styles
+" ---------------------------------------------------------------------
+exe "hi! pandocStyleDelim"               .s:fg_base01 .s:bg_none  .s:fmt_none
+exe "hi! pandocEmphasis"                 .s:fg_base0  .s:bg_none  .s:fmt_ital
+exe "hi! pandocEmphasisNested"           .s:fg_base0  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasis"           .s:fg_base0  .s:bg_none  .s:fmt_bold
+exe "hi! pandocStrongEmphasisNested"     .s:fg_base0  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrongEmphasisEmphasis"   .s:fg_base0  .s:bg_none  .s:fmt_bldi
+exe "hi! pandocStrikeout"                .s:fg_base01 .s:bg_none  .s:fmt_revr
+exe "hi! pandocVerbatimInline"           .s:fg_yellow .s:bg_none  .s:fmt_none
+exe "hi! pandocSuperscript"              .s:fg_violet .s:bg_none  .s:fmt_none
+exe "hi! pandocSubscript"                .s:fg_violet .s:bg_none  .s:fmt_none
+
+exe "hi! pandocRule"                     .s:fg_blue   .s:bg_none  .s:fmt_bold
+exe "hi! pandocRuleLine"                 .s:fg_blue   .s:bg_none  .s:fmt_bold
+exe "hi! pandocEscapePair"               .s:fg_red    .s:bg_none  .s:fmt_bold
+exe "hi! pandocCitationRef"              .s:fg_magenta.s:bg_none   .s:fmt_none
+exe "hi! pandocNonBreakingSpace"         . s:fg_red   .s:bg_none  .s:fmt_revr
+hi! link pandocEscapedCharacter          pandocEscapePair
+hi! link pandocLineBreak                 pandocEscapePair
+
+" Embedded Code
+" ---------------------------------------------------------------------
+exe "hi! pandocMetadataDelim"            .s:fg_base01 .s:bg_none   .s:fmt_none
+exe "hi! pandocMetadata"                 .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocMetadataKey"              .s:fg_blue   .s:bg_none   .s:fmt_none
+exe "hi! pandocMetadata"                 .s:fg_blue   .s:bg_none   .s:fmt_bold
+hi! link pandocMetadataTitle             pandocMetadata
+
+"}}}
+" Utility autocommand "{{{
+" ---------------------------------------------------------------------
+" In cases where Solarized is initialized inside a terminal vim session and 
+" then transferred to a gui session via the command `:gui`, the gui vim process 
+" does not re-read the colorscheme (or .vimrc for that matter) so any `has_gui` 
+" related code that sets gui specific values isn't executed.
+"
+" Currently, Solarized sets only the cterm or gui values for the colorscheme 
+" depending on gui or terminal mode. It's possible that, if the following 
+" autocommand method is deemed excessively poor form, that approach will be 
+" used again and the autocommand below will be dropped.
+"
+" However it seems relatively benign in this case to include the autocommand 
+" here. It fires only in cases where vim is transferring from terminal to gui 
+" mode (detected with the script scope s:vmode variable). It also allows for 
+" other potential terminal customizations that might make gui mode suboptimal.
+"
+autocmd GUIEnter * if (s:vmode != "gui") | exe "colorscheme " . g:colors_name | endif
+"}}}
+" Highlight Trailing Space {{{
+" Experimental: Different highlight when on cursorline
+function! s:SolarizedHiTrail()
+    if g:solarized_hitrail==0
+        hi! clear solarizedTrailingSpace
+    else
+        syn match solarizedTrailingSpace "\s*$"
+        exe "hi! solarizedTrailingSpace " .s:fmt_undr .s:fg_red .s:bg_none .s:sp_red
+    endif
+endfunction  
+augroup SolarizedHiTrail
+    autocmd!
+    if g:solarized_hitrail==1
+        autocmd! Syntax * call s:SolarizedHiTrail()
+        autocmd! ColorScheme * if g:colors_name == "solarized" | call s:SolarizedHiTrail() | else | augroup! s:SolarizedHiTrail | endif
+    endif
+augroup END
+" }}}
+" Menus "{{{
+" ---------------------------------------------------------------------
+" Turn off Solarized menu by including the following assignment in your .vimrc:
+"
+"    let g:solarized_menu=0
+
+function! s:SolarizedOptions()
+    new "new buffer
+    setf vim "vim filetype
+    let failed = append(0, s:defaults_list)
+    let failed = append(0, s:colorscheme_list)
+    let failed = append(0, s:options_list)
+    let failed = append(0, s:lazycat_list)
+    0 "jump back to the top
+endfunction
+if !exists(":SolarizedOptions")
+    command SolarizedOptions :call s:SolarizedOptions()
+endif
+
+function! SolarizedMenu()
+    if exists("g:loaded_solarized_menu")
+        try
+            silent! aunmenu Solarized
+        endtry
+    endif
+    let g:loaded_solarized_menu = 1
+
+    if g:colors_name == "solarized" && g:solarized_menu != 0
+
+        amenu &Solarized.&Contrast.&Low\ Contrast        :let g:solarized_contrast="low"       \| colorscheme solarized<CR>
+        amenu &Solarized.&Contrast.&Normal\ Contrast     :let g:solarized_contrast="normal"    \| colorscheme solarized<CR>
+        amenu &Solarized.&Contrast.&High\ Contrast       :let g:solarized_contrast="high"      \| colorscheme solarized<CR>
+        an    &Solarized.&Contrast.-sep-                 <Nop>
+        amenu &Solarized.&Contrast.&Help:\ Contrast      :help 'solarized_contrast'<CR>
+
+        amenu &Solarized.&Visibility.&Low\ Visibility    :let g:solarized_visibility="low"     \| colorscheme solarized<CR>
+        amenu &Solarized.&Visibility.&Normal\ Visibility :let g:solarized_visibility="normal"  \| colorscheme solarized<CR>
+        amenu &Solarized.&Visibility.&High\ Visibility   :let g:solarized_visibility="high"    \| colorscheme solarized<CR>
+        an    &Solarized.&Visibility.-sep-                 <Nop>
+        amenu &Solarized.&Visibility.&Help:\ Visibility    :help 'solarized_visibility'<CR>
+
+        amenu &Solarized.&Background.&Toggle\ Background :ToggleBG<CR>
+        amenu &Solarized.&Background.&Dark\ Background   :set background=dark  \| colorscheme solarized<CR>
+        amenu &Solarized.&Background.&Light\ Background  :set background=light \| colorscheme solarized<CR>
+        an    &Solarized.&Background.-sep-               <Nop>
+        amenu &Solarized.&Background.&Help:\ ToggleBG     :help togglebg<CR>
+
+        if g:solarized_bold==0 | let l:boldswitch="On" | else | let l:boldswitch="Off" | endif
+        exe "amenu &Solarized.&Styling.&Turn\\ Bold\\ ".l:boldswitch." :let g:solarized_bold=(abs(g:solarized_bold-1)) \\| colorscheme solarized<CR>"
+        if g:solarized_italic==0 | let l:italicswitch="On" | else | let l:italicswitch="Off" | endif
+        exe "amenu &Solarized.&Styling.&Turn\\ Italic\\ ".l:italicswitch." :let g:solarized_italic=(abs(g:solarized_italic-1)) \\| colorscheme solarized<CR>"
+        if g:solarized_underline==0 | let l:underlineswitch="On" | else | let l:underlineswitch="Off" | endif
+        exe "amenu &Solarized.&Styling.&Turn\\ Underline\\ ".l:underlineswitch." :let g:solarized_underline=(abs(g:solarized_underline-1)) \\| colorscheme solarized<CR>"
+
+        amenu &Solarized.&Diff\ Mode.&Low\ Diff\ Mode    :let g:solarized_diffmode="low"     \| colorscheme solarized<CR>
+        amenu &Solarized.&Diff\ Mode.&Normal\ Diff\ Mode :let g:solarized_diffmode="normal"  \| colorscheme solarized<CR>
+        amenu &Solarized.&Diff\ Mode.&High\ Diff\ Mode   :let g:solarized_diffmode="high"    \| colorscheme solarized<CR>
+
+        if g:solarized_hitrail==0 | let l:hitrailswitch="On" | else | let l:hitrailswitch="Off" | endif
+        exe "amenu &Solarized.&Experimental.&Turn\\ Highlight\\ Trailing\\ Spaces\\ ".l:hitrailswitch." :let g:solarized_hitrail=(abs(g:solarized_hitrail-1)) \\| colorscheme solarized<CR>"
+        an    &Solarized.&Experimental.-sep-               <Nop>
+        amenu &Solarized.&Experimental.&Help:\ HiTrail    :help 'solarized_hitrail'<CR>
+
+        an    &Solarized.-sep1-                          <Nop>
+
+        amenu &Solarized.&Autogenerate\ options          :SolarizedOptions<CR>
+
+        an    &Solarized.-sep2-                          <Nop>
+
+        amenu &Solarized.&Help.&Solarized\ Help          :help solarized<CR>
+        amenu &Solarized.&Help.&Toggle\ Background\ Help :help togglebg<CR>
+        amenu &Solarized.&Help.&Removing\ This\ Menu     :help solarized-menu<CR>
+
+        an 9999.77 &Help.&Solarized\ Colorscheme         :help solarized<CR>
+        an 9999.78 &Help.&Toggle\ Background             :help togglebg<CR>
+        an 9999.79 &Help.-sep3-                          <Nop>
+
+    endif
+endfunction
+
+autocmd ColorScheme * if g:colors_name != "solarized" | silent! aunmenu Solarized | else | call SolarizedMenu() | endif
+
+"}}}
+" License "{{{
+" ---------------------------------------------------------------------
+"
+" Copyright (c) 2011 Ethan Schoonover
+"
+" 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.
+"
+" vim:foldmethod=marker:foldlevel=0
+"}}}
diff --git a/vim/.vim/colors/sourcerer.vim b/vim/.vim/colors/sourcerer.vim
new file mode 100644
index 0000000..7a4d9fc
--- /dev/null
+++ b/vim/.vim/colors/sourcerer.vim
@@ -0,0 +1,216 @@
+"   ██████  ██████  ██   ██ ██████  █████   █████  ██████  █████  ██████
+"  ██░░░░  ██░░░░██░██  ░██░░██░░████░░░██ ██░░░██░░██░░████░░░██░░██░░██
+" ░░█████ ░██   ░██░██  ░██ ░██ ░░░██  ░░ ░███████ ░██ ░░░███████ ░██ ░░
+"  ░░░░░██░██   ░██░██  ░██ ░██   ░██   ██░██░░░░  ░██   ░██░░░░  ░██   
+"  ██████ ░░██████ ░░██████░███   ░░█████ ░░██████░███   ░░██████░███   
+" ░░░░░░   ░░░░░░   ░░░░░░ ░░░     ░░░░░   ░░░░░░ ░░░     ░░░░░░ ░░░   
+"  r  e  a  d     c  o  d  e     l  i  k  e     a     w  i  z  a  r  d 
+"
+" sourcerer by xero harrison (http://sourcerer.xero.nu)
+"  ├─ based on sorcerer by Jeet Sukumaran (http://jeetworks.org)
+"  └─ based on mustang by Henrique C. Alves (hcarvalhoalves@gmail.com)
+
+set background=dark
+hi clear
+
+if exists("syntax_on")
+  syntax reset
+endif
+
+let colors_name = "sourcerer"
+
+
+"  █▓▒░ GUI colors
+hi Normal       guifg=#c2c2b0 guibg=#222222 gui=NONE
+hi ColorColumn  guifg=NONE    guibg=#1c1c1c
+hi Cursor       guifg=NONE    guibg=#626262 gui=NONE
+hi CursorColumn guibg=#2d2d2d
+hi CursorLine   guibg=#2d2d2d
+hi DiffAdd      guifg=#000000 guibg=#3cb371 gui=NONE
+hi DiffDelete   guifg=#000000 guibg=#aa4450 gui=NONE
+hi DiffChange   guifg=#000000 guibg=#4f94cd gui=NONE
+hi DiffText     guifg=#000000 guibg=#8ee5ee gui=NONE
+hi Directory    guifg=#1e90ff guibg=NONE    gui=NONE
+hi ErrorMsg     guifg=#ff6a6a guibg=NONE    gui=bold
+hi FoldColumn   guifg=#68838b guibg=#4B4B4B gui=bold
+hi Folded       guifg=#406060 guibg=#232c2c gui=NONE
+hi IncSearch    guifg=#ffffff guibg=#ff4500 gui=bold
+hi LineNr       guifg=#878787 guibg=#3A3A3A gui=NONE
+hi MatchParen   guifg=#fff000 guibg=NONE    gui=bold
+hi ModeMsg      guifg=#afafaf guibg=#222222 gui=bold
+hi MoreMsg      guifg=#2e8b57 guibg=NONE    gui=bold
+hi NonText      guifg=#404050 guibg=NONE    gui=NONE
+
+" completions
+hi Pmenu        guifg=#A8A8A8 guibg=#3A3A3A
+hi PmenuSel     guifg=#000000 guibg=#528B8B
+hi PmenuSbar    guifg=#000000 guibg=#528B8B
+hi PmenuThumb   guifg=#000000 guibg=#528B8B
+
+hi Question     guifg=#00ee00 guibg=NONE    gui=bold
+hi Search       guifg=#000000 guibg=#d6e770 gui=bold
+hi SignColumn   guifg=#ffffff guibg=NONE    gui=NONE
+hi SpecialKey   guifg=#505060 guibg=NONE    gui=NONE
+hi SpellBad     guisp=#ee2c2c gui=undercurl
+hi SpellCap     guisp=#0000ff gui=undercurl
+hi SpellLocal   guisp=#008b8b gui=undercurl
+hi SpellRare    guisp=#ff00ff gui=undercurl
+hi StatusLine   guifg=#000000 guibg=#808070 gui=bold
+hi StatusLineNC guifg=#000000 guibg=#404c4c gui=italic
+hi VertSplit    guifg=#404c4c guibg=#404c4c gui=NONE
+hi TabLine      guifg=fg      guibg=#d3d3d3 gui=underline
+hi TabLineFill  guifg=fg      guibg=NONE    gui=reverse
+hi TabLineSel   guifg=fg      guibg=NONE    gui=bold
+hi Title        guifg=#528b8b guibg=NONE    gui=bold
+hi Visual       guifg=#000000 guibg=#6688aa gui=NONE
+hi WarningMsg   guifg=#ee9a00 guibg=NONE    gui=NONE
+hi WildMenu     guifg=#000000 guibg=#87ceeb gui=NONE
+hi ExtraWhitespace guifg=fg   guibg=#528b8b gui=NONE
+
+"  syntax highlighting
+hi Comment      guifg=#686858 gui=italic
+hi Boolean      guifg=#ff9800 gui=NONE
+hi String       guifg=#779b70 gui=NONE
+hi Identifier   guifg=#9ebac2 gui=NONE
+hi Function     guifg=#faf4c6 gui=NONE
+hi Type         guifg=#7e8aa2 gui=NONE
+hi Statement    guifg=#90b0d1 gui=NONE
+hi Keyword      guifg=#90b0d1 gui=NONE
+hi Constant     guifg=#ff9800 gui=NONE
+hi Number       guifg=#cc8800 gui=NONE
+hi Special      guifg=#719611 gui=NONE
+hi PreProc      guifg=#528b8b gui=NONE
+hi Todo         guifg=#8f6f8f guibg=#202020 gui=italic,underline,bold
+
+" diff
+hi diffOldFile      guifg=#88afcb   guibg=NONE      gui=italic
+hi diffNewFile      guifg=#88afcb   guibg=NONE      gui=italic
+hi diffFile         guifg=#88afcb   guibg=NONE      gui=italic
+hi diffLine         guifg=#88afcb   guibg=NONE      gui=italic
+hi link             diffSubname     diffLine
+hi diffAdded        guifg=#3cb371   guibg=NONE      gui=NONE
+hi diffRemoved      guifg=#aa4450   guibg=NONE      gui=NONE
+hi diffChanged      guifg=#4f94cd   guibg=NONE      gui=NONE
+hi link             diffOnly        Constant
+hi link             diffIdentical   Constant
+hi link             diffDiffer      Constant
+hi link             diffBDiffer     Constant
+hi link             diffIsA         Constant
+hi link             diffNoEOL       Constant
+hi link             diffCommon      Constant
+hi link             diffComment     Constant
+
+" python
+hi pythonException  guifg=#90b0d1 guibg=NONE gui=NONE
+hi pythonExClass    guifg=#996666 guibg=NONE gui=NONE
+hi pythonDecorator  guifg=#888555 guibg=NONE gui=NONE
+hi link pythonDecoratorFunction pythonDecorator
+
+"  █▓▒░ 256 colors 
+hi Normal                 cterm=NONE             ctermbg=NONE  ctermfg=145
+hi ColorColumn            cterm=NONE             ctermbg=16    ctermfg=NONE
+hi Cursor                 cterm=NONE             ctermbg=241   ctermfg=fg
+hi CursorColumn           cterm=NONE             ctermbg=16    ctermfg=fg
+hi CursorLine             cterm=NONE             ctermbg=236   ctermfg=fg
+hi DiffAdd                cterm=NONE             ctermbg=71    ctermfg=16
+hi DiffDelete             cterm=NONE             ctermbg=124   ctermfg=16
+hi DiffChange             cterm=NONE             ctermbg=68    ctermfg=16
+hi DiffText               cterm=NONE             ctermbg=117   ctermfg=16
+hi Directory              cterm=NONE             ctermbg=234   ctermfg=33
+hi ErrorMsg               cterm=bold             ctermbg=NONE  ctermfg=203
+hi FoldColumn             cterm=bold             ctermbg=239   ctermfg=66
+hi Folded                 cterm=NONE             ctermbg=16    ctermfg=60
+hi IncSearch              cterm=bold             ctermbg=202   ctermfg=231
+hi LineNr                 cterm=NONE             ctermbg=237   ctermfg=102
+hi MatchParen             cterm=bold             ctermbg=NONE  ctermfg=226
+hi ModeMsg                cterm=bold             ctermbg=NONE  ctermfg=145
+hi MoreMsg                cterm=bold             ctermbg=234   ctermfg=29
+hi NonText                cterm=NONE             ctermbg=NONE  ctermfg=59
+hi Pmenu                  cterm=NONE             ctermbg=238   ctermfg=231
+hi PmenuSbar              cterm=NONE             ctermbg=250   ctermfg=fg
+hi PmenuSel               cterm=NONE             ctermbg=149   ctermfg=16
+hi Question               cterm=bold             ctermbg=NONE  ctermfg=46
+hi Search                 cterm=bold             ctermbg=185   ctermfg=16
+hi SignColumn             cterm=NONE             ctermbg=NONE  ctermfg=231
+hi SpecialKey             cterm=NONE             ctermbg=NONE  ctermfg=59
+hi SpellBad               cterm=undercurl        ctermbg=NONE  ctermfg=196
+hi SpellCap               cterm=undercurl        ctermbg=NONE  ctermfg=21
+hi SpellLocal             cterm=undercurl        ctermbg=NONE  ctermfg=30
+hi SpellRare              cterm=undercurl        ctermbg=NONE  ctermfg=201
+hi StatusLine             cterm=bold             ctermbg=101   ctermfg=16
+hi StatusLineNC           cterm=NONE             ctermbg=102   ctermfg=16
+hi VertSplit              cterm=NONE             ctermbg=102   ctermfg=102
+hi TabLine                cterm=bold             ctermbg=102   ctermfg=16
+hi TabLineFill            cterm=NONE             ctermbg=102   ctermfg=16
+hi TabLineSel             cterm=bold             ctermbg=16    ctermfg=59
+hi Title                  cterm=bold             ctermbg=NONE  ctermfg=66
+hi Visual                 cterm=NONE             ctermbg=67    ctermfg=16
+hi WarningMsg             cterm=NONE             ctermbg=234   ctermfg=208
+hi WildMenu               cterm=NONE             ctermbg=116   ctermfg=16
+hi ExtraWhitespace        cterm=NONE             ctermbg=66    ctermfg=fg
+
+hi Comment                cterm=NONE             ctermbg=NONE  ctermfg=59
+hi Boolean                cterm=NONE             ctermbg=NONE  ctermfg=208
+hi String                 cterm=NONE             ctermbg=NONE  ctermfg=101
+hi Identifier             cterm=NONE             ctermbg=NONE  ctermfg=145
+hi Function               cterm=NONE             ctermbg=NONE  ctermfg=230
+hi Type                   cterm=NONE             ctermbg=NONE  ctermfg=103
+hi Statement              cterm=NONE             ctermbg=NONE  ctermfg=110
+hi Keyword                cterm=NONE             ctermbg=NONE  ctermfg=110
+hi Constant               cterm=NONE             ctermbg=NONE  ctermfg=208
+hi Number                 cterm=NONE             ctermbg=NONE  ctermfg=172
+hi Special                cterm=NONE             ctermbg=NONE  ctermfg=64
+hi PreProc                cterm=NONE             ctermbg=NONE  ctermfg=66
+hi Todo                   cterm=bold,underline   ctermbg=234   ctermfg=96
+
+hi diffOldFile            cterm=NONE             ctermbg=NONE  ctermfg=67
+hi diffNewFile            cterm=NONE             ctermbg=NONE  ctermfg=67
+hi diffFile               cterm=NONE             ctermbg=NONE  ctermfg=67
+hi diffLine               cterm=NONE             ctermbg=NONE  ctermfg=67
+hi diffAdded              cterm=NONE             ctermfg=NONE  ctermfg=71
+hi diffRemoved            cterm=NONE             ctermfg=NONE  ctermfg=124
+hi diffChanged            cterm=NONE             ctermfg=NONE  ctermfg=68
+hi link             diffSubname     diffLine
+hi link             diffOnly        Constant
+hi link             diffIdentical   Constant
+hi link             diffDiffer      Constant
+hi link             diffBDiffer     Constant
+hi link             diffIsA         Constant
+hi link             diffNoEOL       Constant
+hi link             diffCommon      Constant
+hi link             diffComment     Constant
+
+hi pythonClass            cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonDecorator        cterm=NONE             ctermbg=NONE  ctermfg=101
+hi pythonExClass          cterm=NONE             ctermbg=NONE  ctermfg=95
+hi pythonException        cterm=NONE             ctermbg=NONE  ctermfg=110
+hi pythonFunc             cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonFuncParams       cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonKeyword          cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonParam            cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonRawEscape        cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonSuperclasses     cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi pythonSync             cterm=NONE             ctermbg=NONE  ctermfg=fg
+
+hi Conceal                cterm=NONE             ctermbg=248   ctermfg=252
+hi Error                  cterm=NONE             ctermbg=196   ctermfg=231
+hi Ignore                 cterm=NONE             ctermbg=NONE  ctermfg=234
+hi InsertModeCursorLine   cterm=NONE             ctermbg=16    ctermfg=fg
+hi NormalModeCursorLine   cterm=NONE             ctermbg=235   ctermfg=fg
+hi PmenuThumb             cterm=reverse          ctermbg=NONE  ctermfg=fg
+hi StatusLineAlert        cterm=NONE             ctermbg=160   ctermfg=231
+hi StatusLineUnalert      cterm=NONE             ctermbg=238   ctermfg=144
+hi Test                   cterm=NONE             ctermbg=NONE  ctermfg=fg
+hi Underlined             cterm=underline        ctermbg=NONE  ctermfg=111
+hi VisualNOS              cterm=bold,underline   ctermbg=NONE  ctermfg=fg
+hi cCursor                cterm=reverse          ctermbg=NONE  ctermfg=fg
+hi iCursor                cterm=NONE             ctermbg=210   ctermfg=16
+hi lCursor                cterm=NONE             ctermbg=145   ctermfg=234
+hi nCursor                cterm=NONE             ctermbg=NONE  ctermfg=145
+hi vCursor                cterm=NONE             ctermbg=201   ctermfg=16
+
+hi Pmenu                  cterm=NONE             ctermfg=248   ctermbg=237
+hi PmenuSel               cterm=NONE             ctermfg=16    ctermbg=66
+hi PmenuSbar              cterm=NONE             ctermfg=16    ctermbg=66
+hi PmenuThumb             cterm=NONE             ctermfg=16    ctermbg=66
+
diff --git a/vim/.vim/syntax/cabal.vim b/vim/.vim/syntax/cabal.vim
new file mode 100644
index 0000000..019264a
--- /dev/null
+++ b/vim/.vim/syntax/cabal.vim
@@ -0,0 +1,142 @@
+" Vim syntax file
+" Language:	Haskell Cabal Build file
+" Maintainer:	Vincent Berthoux <twinside@gmail.com>
+" File Types:	.cabal
+" v1.4: Add benchmark support, thanks to Simon Meier
+" v1.3: Updated to the last version of cabal
+"       Added more highlighting for cabal function, true/false
+"       and version number. Also added missing comment highlighting.
+"       Cabal known compiler are highlighted too.
+"
+" V1.2: Added cpp-options which was missing. Feature implemented
+"       by GHC, found with a GHC warning, but undocumented. 
+"       Whatever...
+"
+" v1.1: Fixed operator problems and added ftdetect file
+"       (thanks to Sebastian Schwarz)
+"
+" v1.0: Cabal syntax in vimball format
+"       (thanks to Magnus Therning)
+
+" For version 5.x: Clear all syntax items
+" For version 6.x: Quit when a syntax file was already loaded
+if version < 600
+  syntax clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+syn match	cabalCategory	"\c\<executable\>"
+syn match	cabalCategory	"\c\<library\>"
+syn match	cabalCategory	"\c\<benchmark\>"
+syn match	cabalCategory	"\c\<test-suite\>"
+syn match	cabalCategory	"\c\<source-repository\>"
+syn match	cabalCategory	"\c\<flag\>"
+syn match	cabalCategory	"\c\<custom-setup\>"
+
+syn keyword     cabalConditional    if else
+syn match       cabalOperator       "&&\|||\|!\|==\|>=\|<="
+syn keyword     cabalFunction       os arche impl flag
+syn match       cabalComment    /--.*$/
+syn match       cabalVersion    "\d\+\(\.\(\d\)\+\)\+\(\.\*\)\?"
+
+syn match       cabalTruth      "\c\<true\>"
+syn match       cabalTruth      "\c\<false\>"
+
+syn match       cabalCompiler   "\c\<ghc\>"
+syn match       cabalCompiler   "\c\<nhc\>"
+syn match       cabalCompiler   "\c\<yhc\>"
+syn match       cabalCompiler   "\c\<hugs\>"
+syn match       cabalCompiler   "\c\<hbc\>"
+syn match       cabalCompiler   "\c\<helium\>"
+syn match       cabalCompiler   "\c\<jhc\>"
+syn match       cabalCompiler   "\c\<lhc\>"
+
+syn match	cabalStatement	/^\c\s*\<default-language\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<default-extensions\s*:/me=e-1
+
+syn match	cabalStatement	/^\c\s*\<author\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<branch\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<bug-reports\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<build-depends\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<build-tools\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<build-type\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<buildable\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<c-sources\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<cabal-version\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<category\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<cc-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<copyright\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<cpp-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<data-dir\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<data-files\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<default\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<description\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<executable\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<exposed-modules\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<exposed\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<extensions\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<extra-doc-files\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<extra-lib-dirs\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<extra-libraries\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<extra-source-files\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<extra-tmp-files\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<for example\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<frameworks\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<ghc-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<ghc-prof-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<ghc-shared-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<homepage\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<hs-source-dirs\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<hugs-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<include-dirs\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<includes\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<install-includes\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<ld-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<license-file\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<license\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<location\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<main-is\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<maintainer\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<module\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<name\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<nhc98-options\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<other-extensions\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<other-modules\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<package-url\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<pkgconfig-depends\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<setup-depends\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<stability\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<subdir\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<synopsis\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<tag\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<tested-with\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<type\s*:/me=e-1
+syn match	cabalStatement	/^\c\s*\<version\s*:/me=e-1
+
+" Define the default highlighting.
+" For version 5.7 and earlier: only when not done already
+" For version 5.8 and later: only when an item doesn't have highlighting yet
+if version >= 508 || !exists("did_cabal_syn_inits")
+  if version < 508
+    let did_cabal_syn_inits = 1
+    command -nargs=+ HiLink hi link <args>
+  else
+    command -nargs=+ HiLink hi def link <args>
+  endif
+
+  HiLink cabalVersion       Number
+  HiLink cabalTruth         Boolean
+  HiLink cabalComment       Comment
+  HiLink cabalStatement     Statement
+  HiLink cabalCategory      Type
+  HiLink cabalFunction      Function
+  HiLink cabalConditional   Conditional
+  HiLink cabalOperator      Operator
+  HiLink cabalCompiler      Constant
+  delcommand HiLink
+endif
+
+let b:current_syntax = "cabal"
+
+" vim: ts=8
diff --git a/vim/.vim/syntax/haskell.vim b/vim/.vim/syntax/haskell.vim
new file mode 100644
index 0000000..57da7f1
--- /dev/null
+++ b/vim/.vim/syntax/haskell.vim
@@ -0,0 +1,354 @@
+" Vim syntax file
+"
+" Modification of vims Haskell syntax file:
+"   - match types using regular expression
+"   - highlight toplevel functions
+"   - use "syntax keyword" instead of "syntax match" where appropriate
+"   - functions and types in import and module declarations are matched
+"   - removed hs_highlight_more_types (just not needed anymore)
+"   - enable spell checking in comments and strings only
+"   - FFI highlighting
+"   - QuasiQuotation
+"   - top level Template Haskell slices
+"   - PackageImport
+"
+" TODO: find out which vim versions are still supported
+"
+" From Original file:
+" ===================
+"
+" Language:		    Haskell
+" Maintainer:		Haskell Cafe mailinglist <haskell-cafe@haskell.org>
+" Last Change:		2010 Feb 21
+" Original Author:	John Williams <jrw@pobox.com>
+"
+" Thanks to Ryan Crumley for suggestions and John Meacham for
+" pointing out bugs. Also thanks to Ian Lynagh and Donald Bruce Stewart
+" for providing the inspiration for the inclusion of the handling
+" of C preprocessor directives, and for pointing out a bug in the
+" end-of-line comment handling.
+"
+" Options-assign a value to these variables to turn the option on:
+"
+" hs_highlight_delimiters - Highlight delimiter characters--users
+"			    with a light-colored background will
+"			    probably want to turn this on.
+" hs_highlight_boolean - Treat True and False as keywords.
+" hs_highlight_types - Treat names of primitive types as keywords.
+" hs_highlight_debug - Highlight names of debugging functions.
+" hs_allow_hash_operator - Don't highlight seemingly incorrect C
+"			   preprocessor directives but assume them to be
+"			   operators
+" 
+" 
+
+if version < 600
+  syn clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+"syntax sync fromstart "mmhhhh.... is this really ok to do so?
+syntax sync linebreaks=15 minlines=50 maxlines=500
+
+syn match  hsSpecialChar	contained "\\\([0-9]\+\|o[0-7]\+\|x[0-9a-fA-F]\+\|[\"\\'&\\abfnrtv]\|^[A-Z^_\[\\\]]\)"
+syn match  hsSpecialChar	contained "\\\(NUL\|SOH\|STX\|ETX\|EOT\|ENQ\|ACK\|BEL\|BS\|HT\|LF\|VT\|FF\|CR\|SO\|SI\|DLE\|DC1\|DC2\|DC3\|DC4\|NAK\|SYN\|ETB\|CAN\|EM\|SUB\|ESC\|FS\|GS\|RS\|US\|SP\|DEL\)"
+syn match  hsSpecialCharError	contained "\\&\|'''\+"
+sy region  hsString		start=+"+  skip=+\\\\\|\\"+  end=+"+  contains=hsSpecialChar,@Spell
+sy match   hsCharacter		"[^a-zA-Z0-9_']'\([^\\]\|\\[^']\+\|\\'\)'"lc=1 contains=hsSpecialChar,hsSpecialCharError
+sy match   hsCharacter		"^'\([^\\]\|\\[^']\+\|\\'\)'" contains=hsSpecialChar,hsSpecialCharError
+
+" (Qualified) identifiers (no default highlighting)
+syn match ConId "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=\<[A-Z][a-zA-Z0-9_']*\>"
+syn match VarId "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=\<[a-z][a-zA-Z0-9_']*\>"
+
+" Infix operators--most punctuation characters and any (qualified) identifier
+" enclosed in `backquotes`. An operator starting with : is a constructor,
+" others are variables (e.g. functions).
+syn match hsVarSym "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=[-!#$%&\*\+/<=>\?@\\^|~.][-!#$%&\*\+/<=>\?@\\^|~:.]*"
+syn match hsConSym "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=:[-!#$%&\*\+./<=>\?@\\^|~:]*"
+syn match hsVarSym "`\(\<[A-Z][a-zA-Z0-9_']*\.\)\=[a-z][a-zA-Z0-9_']*`"
+syn match hsConSym "`\(\<[A-Z][a-zA-Z0-9_']*\.\)\=[A-Z][a-zA-Z0-9_']*`"
+
+" Toplevel Template Haskell support
+"sy match hsTHTopLevel "^[a-z]\(\(.\&[^=]\)\|\(\n[^a-zA-Z0-9]\)\)*"
+sy match hsTHIDTopLevel "^[a-z]\S*" 
+sy match hsTHTopLevel "^\$(\?" nextgroup=hsTHTopLevelName 
+sy match hsTHTopLevelName "[a-z]\S*" contained
+
+" Reserved symbols--cannot be overloaded.
+syn match hsDelimiter  "(\|)\|\[\|\]\|,\|;\|_\|{\|}"
+
+sy region hsInnerParen start="(" end=")" contained contains=hsInnerParen,hsConSym,hsType,hsVarSym
+sy region hs_InfixOpFunctionName start="^(" end=")\s*[^:`]\(\W\&\S\&[^'\"`()[\]{}@]\)\+"re=s
+    \ contained keepend contains=hsInnerParen,hs_HlInfixOp
+
+sy match hs_hlFunctionName "[a-z_]\(\S\&[^,\(\)\[\]]\)*" contained 
+sy match hs_FunctionName "^[a-z_]\(\S\&[^,\(\)\[\]]\)*" contained contains=hs_hlFunctionName
+sy match hs_HighliteInfixFunctionName "`[a-z_][^`]*`" contained
+sy match hs_InfixFunctionName "^\S[^=]*`[a-z_][^`]*`"me=e-1 contained contains=hs_HighliteInfixFunctionName,hsType,hsConSym,hsVarSym,hsString,hsCharacter
+sy match hs_HlInfixOp "\(\W\&\S\&[^`(){}'[\]]\)\+" contained contains=hsString
+sy match hs_InfixOpFunctionName "^\(\(\w\|[[\]{}]\)\+\|\(\".*\"\)\|\('.*'\)\)\s*[^:]=*\(\W\&\S\&[^='\"`()[\]{}@]\)\+"
+    \ contained contains=hs_HlInfixOp,hsCharacter
+
+sy match hs_OpFunctionName        "(\(\W\&[^(),\"]\)\+)" contained
+"sy region hs_Function start="^["'a-z_([{]" end="=\(\s\|\n\|\w\|[([]\)" keepend extend
+sy region hs_Function start="^["'a-zA-Z_([{]\(\(.\&[^=]\)\|\(\n\s\)\)*=" end="\(\s\|\n\|\w\|[([]\)" 
+        \ contains=hs_OpFunctionName,hs_InfixOpFunctionName,hs_InfixFunctionName,hs_FunctionName,hsType,hsConSym,hsVarSym,hsString,hsCharacter
+
+sy match hs_DeclareFunction "^[a-z_(]\S*\(\s\|\n\)*::" contains=hs_FunctionName,hs_OpFunctionName
+
+" hi hs_InfixOpFunctionName guibg=bg
+" hi hs_Function guibg=green
+" hi hs_InfixFunctionName guibg=red
+" hi hs_DeclareFunction guibg=red
+
+sy keyword hsStructure data family class where instance default deriving
+sy keyword hsTypedef type newtype
+
+sy keyword hsInfix infix infixl infixr
+sy keyword hsStatement  do case of let in
+sy keyword hsConditional if then else
+
+"if exists("hs_highlight_types")
+  " Primitive types from the standard prelude and libraries.
+  sy match hsType "\<[A-Z]\(\S\&[^,.]\)*\>"
+  sy match hsType "()"
+"endif
+
+" Not real keywords, but close.
+if exists("hs_highlight_boolean")
+  " Boolean constants from the standard prelude.
+  syn keyword hsBoolean True False
+endif
+
+syn region	hsPackageString	start=+L\="+ skip=+\\\\\|\\"\|\\$+ excludenl end=+"+ end='$' contains=cSpecial contained
+sy match   hsModuleName  excludenl "\([A-Z]\w*\.\?\)*" contained 
+
+sy match hsImport "\<import\>\s\+\(qualified\s\+\)\?\(\<\(\w\|\.\)*\>\)" 
+    \ contains=hsModuleName,hsImportLabel
+    \ nextgroup=hsImportParams,hsImportIllegal skipwhite
+sy keyword hsImportLabel import qualified contained
+
+sy match hsImportIllegal "\w\+" contained
+
+sy keyword hsAsLabel as contained
+sy keyword hsHidingLabel hiding contained
+
+sy match hsImportParams "as\s\+\(\w\+\)" contained
+    \ contains=hsModuleName,hsAsLabel
+    \ nextgroup=hsImportParams,hsImportIllegal skipwhite
+sy match hsImportParams "hiding" contained
+    \ contains=hsHidingLabel
+    \ nextgroup=hsImportParams,hsImportIllegal skipwhite 
+sy match hsImportParams "\(\w\*\)" contained
+    \ contains=hsBlockComment,hsLineComment,hsType,hsDelimTypeExport,hs_hlFunctionName,hs_OpFunctionName
+    \ nextgroup=hsImportIllegal skipwhite
+
+"hi hsImport guibg=red
+"hi hsImportParams guibg=bg
+"hi hsImportIllegal guibg=bg
+"hi hsModuleName guibg=bg
+
+"sy match hsImport		"\<import\>\(.\|[^(]\)*\((.*)\)\?" 
+"         \ contains=hsPackageString,hsImportLabel,hsImportMod,hsModuleName,hsImportList
+"sy keyword hsImportLabel import contained
+"sy keyword hsImportMod		as qualified hiding contained
+"sy region hsImportListInner start="(" end=")" contained keepend extend contains=hs_OpFunctionName
+"sy region  hsImportList matchgroup=hsImportListParens start="("rs=s+1 end=")"re=e-1
+"        \ contained 
+"        \ keepend extend
+"        \ contains=hsType,hsLineComment,hsBlockComment,hs_hlFunctionName,hsImportListInner
+
+
+
+" new module highlighting
+syn region hsDelimTypeExport start="\<[A-Z]\(\S\&[^,.]\)*\>(" end=")" contained
+   \ contains=hsType
+
+sy keyword hsExportModuleLabel module contained
+sy match hsExportModule "\<module\>\(\s\|\t\|\n\)*\([A-Z]\w*\.\?\)*" contained contains=hsExportModuleLabel,hsModuleName
+
+sy keyword hsModuleStartLabel module contained
+sy keyword hsModuleWhereLabel where contained
+
+syn match hsModuleStart "^module\(\s\|\n\)*\(\<\(\w\|\.\)*\>\)\(\s\|\n\)*" 
+  \ contains=hsModuleStartLabel,hsModuleName
+  \ nextgroup=hsModuleCommentA,hsModuleExports,hsModuleWhereLabel
+
+syn region hsModuleCommentA start="{-" end="-}"
+  \ contains=hsModuleCommentA,hsCommentTodo,@Spell contained
+  \ nextgroup=hsModuleCommentA,hsModuleExports,hsModuleWhereLabel skipwhite skipnl
+
+syn match hsModuleCommentA "--.*\n"
+  \ contains=hsCommentTodo,@Spell contained
+  \ nextgroup=hsModuleCommentA,hsModuleExports,hsModuleWhereLabel skipwhite skipnl
+
+syn match hsModuleExports "\(\w\*\)" contained
+   \ nextgroup=hsModuleCommentB,hsModuleWhereLabel skipwhite skipnl
+   \ contains=hsBlockComment,hsLineComment,hsType,hsDelimTypeExport,hs_hlFunctionName,hs_OpFunctionName,hsExportModule
+
+syn match hsModuleCommentB "--.*\n"
+  \ contains=hsCommentTodo,@Spell contained
+  \ nextgroup=hsModuleCommentB,hsModuleWhereLabel skipwhite skipnl
+
+syn region hsModuleCommentB start="{-" end="-}"
+   \ contains=hsModuleCommentB,hsCommentTodo,@Spell contained
+   \ nextgroup=hsModuleCommentB,hsModuleWhereLabel skipwhite skipnl
+" end module highlighting
+
+" FFI support
+sy keyword hsFFIForeign foreign contained
+"sy keyword hsFFIImportExport import export contained
+sy keyword hsFFIImportExport export contained
+sy keyword hsFFICallConvention ccall stdcall contained
+sy keyword hsFFISafety safe unsafe contained
+sy region  hsFFIString		start=+"+  skip=+\\\\\|\\"+  end=+"+  contained contains=hsSpecialChar
+sy match hsFFI excludenl "\<foreign\>\(.\&[^\"]\)*\"\(.\)*\"\(\s\|\n\)*\(.\)*::"
+  \ keepend
+  \ contains=hsFFIForeign,hsFFIImportExport,hsFFICallConvention,hsFFISafety,hsFFIString,hs_OpFunctionName,hs_hlFunctionName
+
+
+sy match   hsNumber		"\<[0-9]\+\>\|\<0[xX][0-9a-fA-F]\+\>\|\<0[oO][0-7]\+\>"
+sy match   hsFloat		"\<[0-9]\+\.[0-9]\+\([eE][-+]\=[0-9]\+\)\=\>"
+
+" Comments
+sy keyword hsCommentTodo    TODO FIXME XXX TBD contained
+sy match   hsLineComment      "---*\([^-!#$%&\*\+./<=>\?@\\^|~].*\)\?$" contains=hsCommentTodo,@Spell
+sy region  hsBlockComment     start="{-"  end="-}" contains=hsBlockComment,hsCommentTodo,@Spell
+sy region  hsPragma	       start="{-#" end="#-}"
+
+" QuasiQuotation
+sy region hsQQ start="\[\$" end="|\]"me=e-2 keepend contains=hsQQVarID,hsQQContent nextgroup=hsQQEnd
+sy region hsQQNew start="\[\(.\&[^|]\&\S\)*|" end="|\]"me=e-2 keepend contains=hsQQVarIDNew,hsQQContent nextgroup=hsQQEnd
+sy match hsQQContent ".*" contained
+sy match hsQQEnd "|\]" contained
+sy match hsQQVarID "\[\$\(.\&[^|]\)*|" contained
+sy match hsQQVarIDNew "\[\(.\&[^|]\)*|" contained
+
+if exists("hs_highlight_debug")
+  " Debugging functions from the standard prelude.
+  syn keyword hsDebug undefined error trace
+endif
+
+
+" C Preprocessor directives. Shamelessly ripped from c.vim and trimmed
+" First, see whether to flag directive-like lines or not
+if (!exists("hs_allow_hash_operator"))
+    syn match	cError		display "^\s*\(%:\|#\).*$"
+endif
+" Accept %: for # (C99)
+syn region	cPreCondit	start="^\s*\(%:\|#\)\s*\(if\|ifdef\|ifndef\|elif\)\>" skip="\\$" end="$" end="//"me=s-1 contains=cComment,cCppString,cCommentError
+syn match	cPreCondit	display "^\s*\(%:\|#\)\s*\(else\|endif\)\>"
+syn region	cCppOut		start="^\s*\(%:\|#\)\s*if\s\+0\+\>" end=".\@=\|$" contains=cCppOut2
+syn region	cCppOut2	contained start="0" end="^\s*\(%:\|#\)\s*\(endif\>\|else\>\|elif\>\)" contains=cCppSkip
+syn region	cCppSkip	contained start="^\s*\(%:\|#\)\s*\(if\>\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\(%:\|#\)\s*endif\>" contains=cCppSkip
+syn region	cIncluded	display contained start=+"+ skip=+\\\\\|\\"+ end=+"+
+syn match	cIncluded	display contained "<[^>]*>"
+syn match	cInclude	display "^\s*\(%:\|#\)\s*include\>\s*["<]" contains=cIncluded
+syn cluster	cPreProcGroup	contains=cPreCondit,cIncluded,cInclude,cDefine,cCppOut,cCppOut2,cCppSkip,cCommentStartError
+syn region	cDefine		matchgroup=cPreCondit start="^\s*\(%:\|#\)\s*\(define\|undef\)\>" skip="\\$" end="$"
+syn region	cPreProc	matchgroup=cPreCondit start="^\s*\(%:\|#\)\s*\(pragma\>\|line\>\|warning\>\|warn\>\|error\>\)" skip="\\$" end="$" keepend
+
+syn region	cComment	matchgroup=cCommentStart start="/\*" end="\*/" contains=cCommentStartError,cSpaceError contained
+syntax match	cCommentError	display "\*/" contained
+syntax match	cCommentStartError display "/\*"me=e-1 contained
+syn region	cCppString	start=+L\="+ skip=+\\\\\|\\"\|\\$+ excludenl end=+"+ end='$' contains=cSpecial contained
+
+
+if version >= 508 || !exists("did_hs_syntax_inits")
+  if version < 508
+    let did_hs_syntax_inits = 1
+    command -nargs=+ HiLink hi link <args>
+  else
+    command -nargs=+ HiLink hi def link <args>
+  endif
+
+  HiLink hs_hlFunctionName    Function
+  HiLink hs_HighliteInfixFunctionName Function
+  HiLink hs_HlInfixOp       Function
+  HiLink hs_OpFunctionName  Function
+  HiLink hsTypedef          Typedef
+  HiLink hsVarSym           hsOperator
+  HiLink hsConSym           hsOperator
+  if exists("hs_highlight_delimiters")
+    " Some people find this highlighting distracting.
+	HiLink hsDelimiter        Delimiter
+  endif
+
+  HiLink hsModuleStartLabel Structure
+  HiLink hsExportModuleLabel Keyword
+  HiLink hsModuleWhereLabel Structure
+  HiLink hsModuleName       Normal
+  
+  HiLink hsImportIllegal    Error
+  HiLink hsAsLabel          hsImportLabel
+  HiLink hsHidingLabel      hsImportLabel
+  HiLink hsImportLabel      Include
+  HiLink hsImportMod        Include
+  HiLink hsPackageString    hsString
+
+  HiLink hsOperator         Operator
+
+  HiLink hsInfix            Keyword
+  HiLink hsStructure        Structure
+  HiLink hsStatement        Statement
+  HiLink hsConditional      Conditional
+
+  HiLink hsSpecialCharError Error
+  HiLink hsSpecialChar      SpecialChar
+  HiLink hsString           String
+  HiLink hsFFIString        String
+  HiLink hsCharacter        Character
+  HiLink hsNumber           Number
+  HiLink hsFloat            Float
+
+  HiLink hsLiterateComment		  hsComment
+  HiLink hsBlockComment     hsComment
+  HiLink hsLineComment      hsComment
+  HiLink hsModuleCommentA   hsComment
+  HiLink hsModuleCommentB   hsComment
+  HiLink hsComment          Comment
+  HiLink hsCommentTodo      Todo
+  HiLink hsPragma           SpecialComment
+  HiLink hsBoolean			  Boolean
+
+  if exists("hs_highlight_types")
+      HiLink hsDelimTypeExport  hsType
+      HiLink hsType             Type
+  endif
+
+  HiLink hsDebug            Debug
+
+  HiLink cCppString         hsString
+  HiLink cCommentStart      hsComment
+  HiLink cCommentError      hsError
+  HiLink cCommentStartError hsError
+  HiLink cInclude           Include
+  HiLink cPreProc           PreProc
+  HiLink cDefine            Macro
+  HiLink cIncluded          hsString
+  HiLink cError             Error
+  HiLink cPreCondit         PreCondit
+  HiLink cComment           Comment
+  HiLink cCppSkip           cCppOut
+  HiLink cCppOut2           cCppOut
+  HiLink cCppOut            Comment
+
+  HiLink hsFFIForeign       Keyword
+  HiLink hsFFIImportExport  Structure
+  HiLink hsFFICallConvention Keyword
+  HiLink hsFFISafety         Keyword
+
+  HiLink hsTHIDTopLevel   Macro
+  HiLink hsTHTopLevelName Macro
+
+  HiLink hsQQVarID Keyword
+  HiLink hsQQVarIDNew Keyword
+  HiLink hsQQEnd   Keyword
+  HiLink hsQQContent String
+
+  delcommand HiLink
+endif
+
+let b:current_syntax = "haskell"
diff --git a/vimrc b/vim/.vimrc
similarity index 85%
rename from vimrc
rename to vim/.vimrc
index 4c5062b..5d359d3 100644
--- a/vimrc
+++ b/vim/.vimrc
@@ -9,7 +9,21 @@ set nocompatible
     runtime bundle/pathogen/autoload/pathogen.vim
     execute pathogen#infect()
 
+  "{- SLIME -}"
+    " Use screen as slime's target
+      let g:slime_target = "screen"
+
+    " Use a temporary file to contain slime's paste buffer
+      let g:slime_paste_file = tempname()
+
+    " Default session for screen
+      let g:slime_default_config = {"sessionname": "REPL", "windowname": ""}
+
   "{- SUPERTAB -}"
+    " Use the default vim completion keys for supertab completion
+      let g:SuperTabMappingForward = '<c-p>'
+      let g:SuperTabMappingBackward = '<c-p>'
+
     " Use context sensitive completion to allow filename and omni completion
       let g:SuperTabDefaultCompletionType = "context"
 
@@ -131,5 +145,5 @@ set nocompatible
 
   " Use the system clipboard when deleting, pasting, or yanking "
     if has("clipboard")
-      set clipboard=unnamedplus,autoselect
+      set clipboard=unnamed,unnamedplus
     endif
diff --git a/vim/bundle/commentary b/vim/bundle/commentary
deleted file mode 160000
index 73e0d9a..0000000
--- a/vim/bundle/commentary
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 73e0d9a9d1f51b6cc9dc965f62669194ae851cb1
diff --git a/vim/bundle/endwise b/vim/bundle/endwise
deleted file mode 160000
index 0067ced..0000000
--- a/vim/bundle/endwise
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 0067ceda37725d01b7bd5bf249d63b1b5d4e2ab4
diff --git a/vim/bundle/eunuch b/vim/bundle/eunuch
deleted file mode 160000
index 7eeb681..0000000
--- a/vim/bundle/eunuch
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 7eeb681ff3caedc1c01e50966bc293951f7b3e21
diff --git a/vim/bundle/filetype-nix b/vim/bundle/filetype-nix
deleted file mode 160000
index a61495a..0000000
--- a/vim/bundle/filetype-nix
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit a61495a762feacc00f24cab4392b09cc3250decf
diff --git a/vim/bundle/fugitive b/vim/bundle/fugitive
deleted file mode 160000
index aac85a2..0000000
--- a/vim/bundle/fugitive
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit aac85a268e89a6c8be79341e130ac90256fadbd6
diff --git a/vim/bundle/pathogen b/vim/bundle/pathogen
deleted file mode 160000
index 8c91196..0000000
--- a/vim/bundle/pathogen
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 8c91196cfd9c8fe619f35fac6f2ac81be10677f8
diff --git a/vim/bundle/pencil b/vim/bundle/pencil
deleted file mode 160000
index 3e8b6f3..0000000
--- a/vim/bundle/pencil
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 3e8b6f34170d83eb5074608ef07b215477026852
diff --git a/vim/bundle/sleuth b/vim/bundle/sleuth
deleted file mode 160000
index a174627..0000000
--- a/vim/bundle/sleuth
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit a17462708aa40a7fc0afd4effa559087d8a2c908
diff --git a/vim/bundle/snipmate b/vim/bundle/snipmate
deleted file mode 160000
index 3198619..0000000
--- a/vim/bundle/snipmate
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 31986191ac9923afcd53bf6425c9b6c35fdbb214
diff --git a/vim/bundle/snipmate-addon-mw-utils b/vim/bundle/snipmate-addon-mw-utils
deleted file mode 160000
index 0c5612f..0000000
--- a/vim/bundle/snipmate-addon-mw-utils
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 0c5612fa31ee434ba055e21c76f456244b3b5109
diff --git a/vim/bundle/snipmate-tlib b/vim/bundle/snipmate-tlib
deleted file mode 160000
index 8c74564..0000000
--- a/vim/bundle/snipmate-tlib
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 8c74564396e368788a5cb901b0e8017a3166cee9
diff --git a/vim/bundle/supertab b/vim/bundle/supertab
deleted file mode 160000
index 6651177..0000000
--- a/vim/bundle/supertab
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 66511772a430a5eaad7f7d03dbb02e8f33c4a641
diff --git a/vim/bundle/tagbar b/vim/bundle/tagbar
deleted file mode 160000
index 2955f71..0000000
--- a/vim/bundle/tagbar
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 2955f71856536d503c79c15daab3de890a6d83e9
diff --git a/vim/bundle/vinegar b/vim/bundle/vinegar
deleted file mode 160000
index bd7f7b7..0000000
--- a/vim/bundle/vinegar
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit bd7f7b7929260072864462c04dde3b9f4c5e0d23