Merge submodule contents for vim/master

.vim/.gitignore

+.VimballRecord
+.netrwhist
+doc/*
+plugged
+view
+spell/en.utf-8.add.spl
+autoload/plug.vim.old

.vim/.ycm_extra_conf.py

+# Partially stolen from https://bitbucket.org/mblum/libgp/src/2537ea7329ef/.ycm_extra_conf.py
+import os
+import ycm_core
+
+# These are the compilation flags that will be used in case there's no
+# compilation database set (by default, one is not set).
+# CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
+flags = [
+    '-Wall',
+    '-Wextra',
+    '-Werror',
+    '-Wno-long-long',
+    '-Wno-variadic-macros',
+    '-fexceptions',
+    # THIS IS IMPORTANT! Without a "-std=<something>" flag, clang won't know which
+    # language to use when compiling headers. So it will guess. Badly. So C++
+    # headers will be compiled as C headers. You don't want that so ALWAYS specify
+    # a "-std=<something>".
+    # For a C project, you would set this to something like 'c99' instead of
+    # 'c++11'.
+    '-std=c++14',
+    # ...and the same thing goes for the magic -x option which specifies the
+    # language that the files to be compiled are written in. This is mostly
+    # relevant for c++ headers.
+    # For a C project, you would set this to 'c' instead of 'c++'.
+    '-x', 'c++',
+    # This path will only work on OS X, but extra paths that don't exist are not
+    # harmful
+    '-isystem', '/usr/local/include',
+    '-isystem', '/usr/local/include/eigen3',
+    '-I', 'include',
+    '-I.',
+]
+
+# Set this to the absolute path to the folder (NOT the file!) containing the
+# compile_commands.json file to use that instead of 'flags'. See here for
+# more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
+#
+# Most projects will NOT need to set this to anything; you can just change the
+# 'flags' list of compilation flags. Notice that YCM itself uses that approach.
+compilation_database_folder = ''
+
+if compilation_database_folder:
+  database = ycm_core.CompilationDatabase( compilation_database_folder )
+else:
+  database = None
+
+
+def DirectoryOfThisScript():
+  return os.path.dirname( os.path.abspath( __file__ ) )
+
+
+def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
+  if not working_directory:
+    return list( flags )
+  new_flags = []
+  make_next_absolute = False
+  path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
+  for flag in flags:
+    new_flag = flag
+
+    if make_next_absolute:
+      make_next_absolute = False
+      if not flag.startswith( '/' ):
+        new_flag = os.path.join( working_directory, flag )
+
+    for path_flag in path_flags:
+      if flag == path_flag:
+        make_next_absolute = True
+        break
+
+      if flag.startswith( path_flag ):
+        path = flag[ len( path_flag ): ]
+        new_flag = path_flag + os.path.join( working_directory, path )
+        break
+
+    if new_flag:
+      new_flags.append( new_flag )
+  return new_flags
+
+
+def FlagsForFile( filename ):
+  if database:
+    # Bear in mind that compilation_info.compiler_flags_ does NOT return a
+    # python list, but a "list-like" StringVec object
+    compilation_info = database.GetCompilationInfoForFile( filename )
+    final_flags = MakeRelativePathsInFlagsAbsolute(
+      compilation_info.compiler_flags_,
+      compilation_info.compiler_working_dir_ )
+  else:
+    # relative_to = DirectoryOfThisScript()
+    relative_to = os.path.dirname(os.path.abspath(filename))
+    final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
+
+  return {
+    'flags': final_flags,
+    'do_cache': True
+  }

.vim/README.md

+# My vimrc
+
+This repository contains my `.vim` folder.  The `vimrc` file is inside the folder.
+
+Of note:
+
+- `sudo` write: `cmap w!! w !sudo tee >/dev/null %`  
+If you opened a root-owned file but forgot to use `sudo`, use `:w!!` to write.
+- Only the latest for me:
+
+        let g:syntastic_cpp_compiler_options=' -std=c++11'
+        let g:syntastic_python_python_exec = '/usr/bin/python3'
+- May the `Shift` not be with you:
+
+        nore ; :
+        nore , ;
+  
+## [Plugins](bundle)
+
+Since I use `vim-plug` to handle plugins, a `:PlugInstall` would be appropriate on first run.
+
+- [vim-plug](https://github.com/junegunn/vim-plug) - for managing plugins
+- [supertab](https://github.com/ervandew/supertab) - for completion awesomeness
+- [syntastic](https://github.com/scrooloose/syntastic) - for highlighting the living daylights out of syntax errors
+- [YouCompleteMe](https://github.com/Valloric/YouCompleteMe.git)
+- [vim-airline](https://github.com/bling/vim-airline)
+- [ctrlp.vim](https://github.com/ctrlpvim/ctrlp.vim.git)
+- [diffchar.vim](https://github.com/vim-scripts/diffchar.vim)
+- [molokai](https://github.com/tomasr/molokai.git)
+- [nerdtree](https://github.com/scrooloose/nerdtree.git)
+- [tabular](https://github.com/godlygeek/tabular.git)
+- [tagbar](https://github.com/majutsushi/tagbar.git)
+- [vim-fugitive](https://github.com/tpope/vim-fugitive.git)
+- [vim-go](https://github.com/fatih/vim-go.git)
+- [vim-markdown](https://github.com/gabrielelana/vim-markdown)
+- [vim-surround](https://github.com/tpope/vim-surround.git)
+- [vimtex](https://github.com/lervag/vimtex)
+- [vim2hs](https://github.com/dag/vim2hs) - Haskell in all its visual beauty:
+
+        symbol :: Eq s => s -> Parser s s
+        symbol a x = satisfy (a == ) x
+ Becomes:
+
+        symbol :: Eq s ⇒ s → Parser s s
+        symbol a x = satisfy (a ≡ ) x

.vim/after/syntax/tex.vim

+"syntax iskeyword @,48-57,192-255,
+syntax keyword texMathS a4paper a5paper abbrv abovedisplayshortskip abovedisplayskip abstract abstractname acute addcontentsline address addtime addtocontents addtocounter addtolength addvspace aleph align alph Alph alpha amalg amsmath amsthm and angle Ankh appendix appendixname approx approxeq aquarius Aquarius arabic aries Aries array arraycolsep arrayrulewidth arraystretch article ascnode ast astrosun asymp ataribox author b5paper backepsilon backmatter backprime backsim backsimeq backslash bar barwedge baselineskip baselinestretch Bat batchmode Bbbk because begin bell belowdisplayshortskip belowdisplayskip beta between bezier bfseries bibindent bibitem bibliography bibliographystyle bibname big Big bigcap bigcirc bigcup bigg Bigg biggl Biggl biggm Biggm biggr Biggr bigl Bigl bigm Bigm bigodot bigoplus bigotimes bigr Bigr bigskip bigskipamount bigsqcup bigstar bigtriangledown bigtriangleup biguplus bigvee bigwedge binom blacklozenge blacksmiley blacksquare blacktriangle blacktriangledown blacktriangleleft blacktriangleright blg boldmath boldsymbol book bot botfigrule bottmofraction bottomnumber Bouquet bowtie Bowtie Box boxdot boxedminipage boxminus boxplus boxtimes breve brokenvert bullet bumpeq Bumpeq calc cancer Cancer cap Cap Capricorn capricornus caption caption2 capt-of cases ccaption ccname cdot cdotp cdots cdotscenter celsius Celtcross cent centerdot centering cercle cfrac changebar chapter chapterbib chaptername check checked checkmark chi circ circeq circlearrowleft circlearrowright CircledA circledast circledcirc circleddash circledR circledS cite cleardoublepage clearpage cline clock closing clubsuit colon COLON columnsep columnseprule columnwidth complement cong conjunction contentsline contentsname coprod copyright Cross cup Cup curlyeqprec curlyeqsucc curlyvee curlywedge currency curvearrowleft curvearrowright dag dagger dashbox dashleftarrow dashrightarrow dashv date dbinom dblfigure dblfloatpage dblfloatsep dbltextfloatsep dbltopfraction dbltopnumber dcolumn ddag ddagger ddot ddots DeclareMathOperator degree delta Delta Denarius depth descnode description dfrac diagdown diagup diameter diamond Diamond diamondsuit digamma displaylimits displaymath displaystyle div divideontimes document documentclass dot doteq doteqdot dotfill dotplus dots dotsb dotsc dotsi dotsint dotsm dotso doublebarwedge doublerulesep downarrow Downarrow DOWNarrow downbracefill downdownarrows downharpoonleft downharpoonright draft dropping dywiz earth Earth Ecommerce ell Email Emailct emph empty emptyset encl enclname end endfloat enlargethispage enskip enspace ensuremath enumerate enumi enumii enumiii enumiv epsilon eqcirc eqnarray eqslantgtr eqslantless equation equiv errorstopmode eta eth eucal eufrak EUR EURcr EURdig EURhv EURtm evensidemargin everyship executivepaper exists expdlist extracolsep extramark EyesDollar fallingdotseq fancybox fancyhdr fax FAX Faxmachine fbox fboxrule fboxsep female FHBOlogo FHBOLOGO figure figurename file filecontents final fint Finv flafter flat fleqn floatflt floatpagefraction floatsep flushbottom flushleft flushright fn2end fnpara fnsymbol fontenc footheight footmisc footnote footnotemark footnoterule footnotesep footnotesize footnotetext footnpag footskip forall frac frame framebox frenchspacing frontmatter frown frownie Frowny ftnright FullFHBO fullmoon fussy Game gamma Gamma gather gemini Gemini genfrac geometry geq geqq geqslant ggg glossary glossaryentry gnapprox gneq gneqq gnsim graphicx graphpaper grave gtrapprox gtrdot gtreqless gtreqqless gtrless gtrsim guillemotleft guillemotright guilsinglleft guilsinglright gvertneqq hat hbar hbox headheihgt headings headsep Heart heartsuit height helvet hfill hhline hline hookleftarrow hookrightarrow hrulefill hslash hspace huge Huge HUGE hyperref hyphenation iddots idotsint ifthen iiiint iiint iint imath include includeonly indent indentfirst index indexentry indexname indexspace infty inplus input inputenc int intercal intertext intextsep invdiameter invisible iota item itemindent itemize itemsep itshape jmath Join jot jupiter Jupiter kappa kill kreuz label labelenumi labelenumii labelenumiii labelenumiv labelitemi labelitemii labelitemiii labelitemiv labelsep labelwidth lambda Lambda landdownint landscape landupint langle large Large LARGE LaTeX LaTeXe latexsym lbag Lbag lceil ldotp ldots leadsto left leftarrow Leftarrow LEFTarrow leftarrowfill leftarrowtail leftarrowtriangle lefteqn leftharpoondown leftharpoonup leftleftarrows leftmargin leftmargini leftmarginii leftmarginiii leftmarginiv leftmarginv leftmarginvi leftmark leftmoon leftrightarrow Leftrightarrow leftrightarroweq leftrightarrows leftrightarrowtriangle leftrightharpoons leftrightsquigarrow leftthreetimes legalpaper leo Leo leq leqno leqq leqslant lessapprox lessdot lesseqgtr lesseqqgtr lessgtr lesssim letter Letter letterpaper letterspace lfloor lhd LHD lhead libra Libra lightning Lightning limits line linebreak linethickness linewidth list listfigurename listfiles listoffigures listoftables listparindent llbracket llceil Lleftarrow llfloor lll llparenthesis lnapprox lneq lneqq lnsim location longleftarrow Longleftarrow longleftrightarrow Longleftrightarrow longmapsfrom Longmapsfrom longmapsto Longmapsto longrightarrow Longrightarrow longtable looparrowleft looparrowright lozenge lrbox lscape Lsh ltimes lvertneqq mainmatter makeatletter makeatother makebox makeglossary makeidx makeindex makelabel maketitle male maltese manyfoot mapsfrom Mapsfrom mapsto Mapsto marginpar marginparpush marginparsep marginparwidth markboth markleft markright mars Mars MartinVogel math mathbb mathbf mathbin mathcal mathclose mathdollar mathds mathellipsis mathfrak mathindent mathit mathnormal mathop mathopen mathord mathparagraph mathpunct mathrel mathrm mathscr mathsection mathsf mathsterling mathstrut mathtt mathunderscore mathversion mbox mdseries measuredangle medmuskip medskip medskipamount mercury Mercury mho micro mid minipage minitoc minus mkern Mobilefone models Moon moreverbatim mpfootnote multicol multicolumn multilanguage multimap multiput multirow Mundus MVAt MVRightarrow myheadings nabla name natural ncong nearrow NeedsTeXFormat neg neptune Neptune neq newcommand newcounter newenvironment newfont newlength newline newmoon newpage newsavebox newtheorem nexists ngeq ngeqq ngeqslant ngtr niplus nleftarrow nLeftarrow nleftrightarrow nLeftrightarrow nleq nleqq nleqslant nless nmid nnearrow nnwarrow nocite nofiles noindent nolimits nolinebreak nomathsymbols nonfrenchspacing nonumber nopagebreak normalfont normalsize not notag note notin notitlepage nparallel nprec npreceq nrightarrow nRightarrow nshortmid nshortparallel nsim nsubseteq nsucc nsucceq nsupseteq nsupseteqq ntriangleleft ntrianglelefteq ntriangleright ntrianglerighteq numberline numline numprint nvdash nvDash nVDash nwarrow ocircle oddsidemargin odot ohm ohorn OHORN oiint oint ointclockwise ointctrclockwise oldstyle omega Omega ominus onecolumn oneside onlynotes onlyslides openany openbib opening openright operatorname oplus opposition oslash otimes oval overbrace overlay overleftarrow overline overrightarrow page pagebreak pagenumbering pageref pagestyle paperheight paperwidth par paragraph parallel parbox parindent parr parsep parskip part partial partname partopsep pauza permil perp perthousand Pfund phi Phi phone Pickup picture pisces Pisces pitchfork plain PLdateending plmath PLSlash plus pluto Pluto pmb pmod pointer polski poptabs pounds ppauza prec precapprox preccurlyeq preceq precnapprox precnsim precsim prefixing prime printindex prod propto protect providecommand psi Psi pushtabs put qbezier qbeziermax qquad quad quotation quote quotedblbase quotesinglbase ragged2e raggedbottom raggedleft raggedright raisebox rangle ratio rbag Rbag rceil real recorder ref refname refstepcounter relsize renewcommand renewenvironment report reversemarginpar rfloor rhd RHD rhead rho right rightarrow Rightarrow RIGHTarrow rightarrowfill rightarrowtail rightarrowtriangle rightharpoondown rightharpoonup rightleftarrows rightleftharpoons rightmargin rightmark rightmoon rightrightarrows rightsquigarrow rightthreetimes risingdotseq rmfamily roman Roman rotate rotating rrbracket rrceil rrfloor Rrightarrow rrparenthesis Rsh rtimes rule sagittarius Sagittarius samepage saturn Saturn savebox sbox scorpio Scorpio scriptscriptstyle scriptsize scriptstyle scrollmode scshape searrow secnumdepth section sectionmark see seename selectfont selectlanguage setcounter setlength setminus settime settodepth settoheight settowidth sffamily shadethm shadow shapepar sharp Shilling shortdownarrow shortleftarrow shortmid shortparallel shortrightarrow shortstack shortuparrow showlabels sidecap sigma Sigma signature sim simeq sin skull slide slides sloppy sloppybar slshape small smallfrown smallsetminus smallskip smallskipamount smallsmile smile smiley Smiley soul space spadesuit sphericalangle sqcap sqcup sqiint sqint sqrt sqsubset sqsubseteq sqsupset sqsupseteq square ssearrow sswarrow stackrel star startbreaks stepcounter stop stopbreaks stretch strut subfigure subitem subparagraph subsection subset Subset subseteq subseteqq subsetneq subsetneqq subsubitem subsubsection succ succapprox succcurlyeq succeq succnapprox succnsim succsim sum sun Sun supressfloats supset Supset supseteq supseteqq supsetneq supsetneqq surd swarrow symbol tabbing tabcolsep table tablename tableofcontents tabular tabularx tag tan tau taurus Taurus tbinom Telefon telephone TeX textaolig textasciicircum textasciitilde textasteriskcentered textbabygamma textbackslash textbaht textbar textbarb textbarc textbard textbardbl textbardotlessj textbarg textbarglotstop textbari textbarl textbaro textbarrevglotstop textbaru textbeltl textbenttailyogh textbeta textbf textbigcircle textbktailgamma textblank textbraceleft textbraceright textbrokenbar textbullet textbullseye textceltpal textcent textcentoldstyle textchi textcircled textcircledP textcloseepsilon textcloseomega textcloserevepsilon textcolonmonetary textcommatailz textcompwordmark textcopyleft textcopyright textcorner textcrb textcrd textcrg textcrh textcrinvglotstop textcrlambda textcrtwo textctc textctd textctdctzlig textctesh textctinvglotstop textctj textctjvar textctn textctstretchc textctstretchcvar textctt textcttctclig textctturnt textctyogh textctz textcurrency textdagger textdaggerdbl textdblhyphen textdblhyphenchar textdblig textdctzlig textdegree textdiscount textdiv textdollar textdollaroldstyle textdong textdoublebaresh textdoublebarpipe textdoublebarpipevar textdoublebarslash textdoublepipe textdoublepipevar textdoublevertline textdownarrow textdownfullarrow textdownstep textdyoghlig textdzlig textellipsis textemdash textendash textepsilon textesh textestimated texteuro textexclamdown textfemale textfishhookr textfloatsep textflorin textfraction textfractionsolidus textfrbarn textfrhookd textfrhookdvar textfrhookt textfrtailgamma textg textgamma textglobfall textglobrise textglotstop textglotstopvari textglotstopvarii textglotstopvariii textgreater textgrgamma textguarani texthalflength texthardsign textheight textheng texthmlig texthooktop texthtb texthtbardotlessj texthtbardotlessjvar texthtc texthtd texthtg texthth texththeng texthtk texthtp texthtq texthtrtaild texthtscg texthtt texthvlig textinterrobang textinterrobangdown textinvglotstop textinvomega textinvsca textinvscr textinvscripta textiota textit textlambda textlangle textlbrackdbl textleftarrow textlengthmark textless textlfishhookrlig textlhookfour textlhookp textlhookt textlhti textlhtlongi textlhtlongy textlira textlnot textlonglegr textlooptoprevesh textlptr textlquill textltailm textltailn textltilde textlyoghlig textmd textminus textmusicalnote textnaira textnormal textnrleg textnumero textObardotlessj textObullseye textOlyoghlig textomega textonehalf textonequarter textonesuperior textopenbullet textopencorner textopeno textordfeminine textordmasculine textpalhook textpalhooklong textpalhookvar textparagraph textperiodcenter textperiodcentered textpertenthousand textperthousand textpeso textphi textpilcrow textpipe textpipevar textpm textprimstress textqplig textquestiondown textquotedbl textquotedblleft textquotedblright textquoteleft textquoteright textquotesingle textquotestraightbase textquotestraightdblbase textraiseglotstop textraisevibyi textramshorns textrangle textrbrackdbl textrecipe textrectangle textreferencemark textregistered textretractingvar textrevapostrophe textreve textrevepsilon textrevglotstop textrevscl textrevscr textrevyogh textrhooka textrhooke textrhookepsilon textrhookopeno textrhookrevepsilon textrhookschwa textrhoticity textrightarrow textrm textrptr textrquill textrtaild textrtailhth textrtaill textrtailn textrtailr textrtails textrtailt textrtailz textrthook textrthooklong textsc textsca textscaolig textscb textscdelta textsce textscf textscg textsch textschwa textsci textscj textsck textscl textscm textscn textscoelig textscomega textscp textscq textscr textscripta textscriptg textscriptv textscu textscy textsecstress textsection textservicemark textsf textsl textsoftsign textspleftarrow textsterling textstretchc textstretchcvar textstyle textsubdoublearrow textsubrightarrow textsuperscript textsurd texttctclig textteshlig texttheta textthorn textthornvari textthornvarii textthornvariii textthornvariv textthreequarters textthreequartersemdash textthreesuperior texttildelow texttimes texttoneletterstem texttrademark texttslig texttt textturna textturncelig textturnglotstop textturnh textturnk textturnlonglegr textturnm textturnmrleg textturnr textturnrrtail textturnsck textturnscripta textturnscu textturnt textturnthree textturntwo textturnv textturnw textturny texttwelveudash texttwosuperior textuncrfemale textunderscore textup textuparrow textupfullarrow textupsilon textupstep textvertline textvibyi textvibyy textvisiblespace textwidth textwon textwynn textyen textyogh tfrac thanks the thebibliography theindex theorem thepage therefore thesection theta Theta thickapprox thicklines thickmuskip thicksim thinlines thispagestyle threeparttable tilde time times tiny title titlepage tocdepth today top topfigrule topfraction topmargin topsep topskip totalheight totalnumber triangle triangledown triangleleft trianglelefteq triangleq triangleright trianglerighteq trivlist ttfamily twocolumn twoheadleftarrow twoheadrightarrow twoside typein typeout uhorn UHORN ulem unboldmath underbrace underline unlhd unrhd unsort unsrt upalpha uparrow Uparrow UParrow upbeta upbracefill upchi updelta Updelta updownarrow Updownarrow upepsilon upeta upgamma Upgamma upharpoonleft upharpoonright upiota upkappa uplambda Uplambda uplus upmu upnu upomega Upomega upphi Upphi uppi Uppi uppsi Uppsi uprho upshape upsigma Upsigma upsilon Upsilon uptau uptheta Uptheta upuparrows upupsilon Upupsilon upvarepsilon upvarphi upvarpi upvarrho upvarsigma upvartheta upxi Upxi upzeta uranus Uranus usebox usecounter usefont usepackage value varepsilon varkappa varnothing varoiint varointclockwise varointctrclockwise varphi varpi varpropto varrho varsigma varsubsetneq varsubsetneqq varsupsetneq varsupsetneqq vartheta vartriangle vartriangleleft vartriangleright vbox vdash vDash Vdash vdots vec vector vee veebar venus Venus verb verbatim vernal verse vfill virgo Virgo visible vline vmargin voffset vspace Vvdash wasylozenge wedge widehat widetilde width with Womanface wrapfig xleftarrow xrightarrow Yinyang zeta
+highlight link texMathS Identifier

.vim/autoload/plug.vim

+" vim-plug: Vim plugin manager
+" ============================
+"
+" Download plug.vim and put it in ~/.vim/autoload
+"
+"   curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
+"     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
+"
+" Edit your .vimrc
+"
+"   call plug#begin('~/.vim/plugged')
+"
+"   " Make sure you use single quotes
+"
+"   " Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
+"   Plug 'junegunn/vim-easy-align'
+"
+"   " Any valid git URL is allowed
+"   Plug 'https://github.com/junegunn/vim-github-dashboard.git'
+"
+"   " Multiple Plug commands can be written in a single line using | separators
+"   Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'
+"
+"   " On-demand loading
+"   Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
+"   Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
+"
+"   " Using a non-master branch
+"   Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
+"
+"   " Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
+"   Plug 'fatih/vim-go', { 'tag': '*' }
+"
+"   " Plugin options
+"   Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
+"
+"   " Plugin outside ~/.vim/plugged with post-update hook
+"   Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
+"
+"   " Unmanaged plugin (manually installed and updated)
+"   Plug '~/my-prototype-plugin'
+"
+"   " Initialize plugin system
+"   call plug#end()
+"
+" Then reload .vimrc and :PlugInstall to install plugins.
+"
+" Plug options:
+"
+"| Option                  | Description                                      |
+"| ----------------------- | ------------------------------------------------ |
+"| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use       |
+"| `rtp`                   | Subdirectory that contains Vim plugin            |
+"| `dir`                   | Custom directory for the plugin                  |
+"| `as`                    | Use different name for the plugin                |
+"| `do`                    | Post-update hook (string or funcref)             |
+"| `on`                    | On-demand loading: Commands or `<Plug>`-mappings |
+"| `for`                   | On-demand loading: File types                    |
+"| `frozen`                | Do not update unless explicitly specified        |
+"
+" More information: https://github.com/junegunn/vim-plug
+"
+"
+" Copyright (c) 2017 Junegunn Choi
+"
+" MIT License
+"
+" 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.
+
+if exists('g:loaded_plug')
+  finish
+endif
+let g:loaded_plug = 1
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+let s:plug_src = 'https://github.com/junegunn/vim-plug.git'
+let s:plug_tab = get(s:, 'plug_tab', -1)
+let s:plug_buf = get(s:, 'plug_buf', -1)
+let s:mac_gui = has('gui_macvim') && has('gui_running')
+let s:is_win = has('win32') || has('win64')
+let s:nvim = has('nvim-0.2') || (has('nvim') && exists('*jobwait') && !s:is_win)
+let s:vim8 = has('patch-8.0.0039') && exists('*job_start')
+let s:me = resolve(expand('<sfile>:p'))
+let s:base_spec = { 'branch': 'master', 'frozen': 0 }
+let s:TYPE = {
+\   'string':  type(''),
+\   'list':    type([]),
+\   'dict':    type({}),
+\   'funcref': type(function('call'))
+\ }
+let s:loaded = get(s:, 'loaded', {})
+let s:triggers = get(s:, 'triggers', {})
+
+function! plug#begin(...)
+  if a:0 > 0
+    let s:plug_home_org = a:1
+    let home = s:path(fnamemodify(expand(a:1), ':p'))
+  elseif exists('g:plug_home')
+    let home = s:path(g:plug_home)
+  elseif !empty(&rtp)
+    let home = s:path(split(&rtp, ',')[0]) . '/plugged'
+  else
+    return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.')
+  endif
+  if fnamemodify(home, ':t') ==# 'plugin' && fnamemodify(home, ':h') ==# s:first_rtp
+    return s:err('Invalid plug home. '.home.' is a standard Vim runtime path and is not allowed.')
+  endif
+
+  let g:plug_home = home
+  let g:plugs = {}
+  let g:plugs_order = []
+  let s:triggers = {}
+
+  call s:define_commands()
+  return 1
+endfunction
+
+function! s:define_commands()
+  command! -nargs=+ -bar Plug call plug#(<args>)
+  if !executable('git')
+    return s:err('`git` executable not found. Most commands will not be available. To suppress this message, prepend `silent!` to `call plug#begin(...)`.')
+  endif
+  command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install(<bang>0, [<f-args>])
+  command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate  call s:update(<bang>0, [<f-args>])
+  command! -nargs=0 -bar -bang PlugClean call s:clean(<bang>0)
+  command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif
+  command! -nargs=0 -bar PlugStatus  call s:status()
+  command! -nargs=0 -bar PlugDiff    call s:diff()
+  command! -nargs=? -bar -bang -complete=file PlugSnapshot call s:snapshot(<bang>0, <f-args>)
+endfunction
+
+function! s:to_a(v)
+  return type(a:v) == s:TYPE.list ? a:v : [a:v]
+endfunction
+
+function! s:to_s(v)
+  return type(a:v) == s:TYPE.string ? a:v : join(a:v, "\n") . "\n"
+endfunction
+
+function! s:glob(from, pattern)
+  return s:lines(globpath(a:from, a:pattern))
+endfunction
+
+function! s:source(from, ...)
+  let found = 0
+  for pattern in a:000
+    for vim in s:glob(a:from, pattern)
+      execute 'source' s:esc(vim)
+      let found = 1
+    endfor
+  endfor
+  return found
+endfunction
+
+function! s:assoc(dict, key, val)
+  let a:dict[a:key] = add(get(a:dict, a:key, []), a:val)
+endfunction
+
+function! s:ask(message, ...)
+  call inputsave()
+  echohl WarningMsg
+  let answer = input(a:message.(a:0 ? ' (y/N/a) ' : ' (y/N) '))
+  echohl None
+  call inputrestore()
+  echo "\r"
+  return (a:0 && answer =~? '^a') ? 2 : (answer =~? '^y') ? 1 : 0
+endfunction
+
+function! s:ask_no_interrupt(...)
+  try
+    return call('s:ask', a:000)
+  catch
+    return 0
+  endtry
+endfunction
+
+function! plug#end()
+  if !exists('g:plugs')
+    return s:err('Call plug#begin() first')
+  endif
+
+  if exists('#PlugLOD')
+    augroup PlugLOD
+      autocmd!
+    augroup END
+    augroup! PlugLOD
+  endif
+  let lod = { 'ft': {}, 'map': {}, 'cmd': {} }
+
+  if exists('g:did_load_filetypes')
+    filetype off
+  endif
+  for name in g:plugs_order
+    if !has_key(g:plugs, name)
+      continue
+    endif
+    let plug = g:plugs[name]
+    if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for')
+      let s:loaded[name] = 1
+      continue
+    endif
+
+    if has_key(plug, 'on')
+      let s:triggers[name] = { 'map': [], 'cmd': [] }
+      for cmd in s:to_a(plug.on)
+        if cmd =~? '^<Plug>.\+'
+          if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i'))
+            call s:assoc(lod.map, cmd, name)
+          endif
+          call add(s:triggers[name].map, cmd)
+        elseif cmd =~# '^[A-Z]'
+          let cmd = substitute(cmd, '!*$', '', '')
+          if exists(':'.cmd) != 2
+            call s:assoc(lod.cmd, cmd, name)
+          endif
+          call add(s:triggers[name].cmd, cmd)
+        else
+          call s:err('Invalid `on` option: '.cmd.
+          \ '. Should start with an uppercase letter or `<Plug>`.')
+        endif
+      endfor
+    endif
+
+    if has_key(plug, 'for')
+      let types = s:to_a(plug.for)
+      if !empty(types)
+        augroup filetypedetect
+        call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim')
+        augroup END
+      endif
+      for type in types
+        call s:assoc(lod.ft, type, name)
+      endfor
+    endif
+  endfor
+
+  for [cmd, names] in items(lod.cmd)
+    execute printf(
+    \ 'command! -nargs=* -range -bang -complete=file %s call s:lod_cmd(%s, "<bang>", <line1>, <line2>, <q-args>, %s)',
+    \ cmd, string(cmd), string(names))
+  endfor
+
+  for [map, names] in items(lod.map)
+    for [mode, map_prefix, key_prefix] in
+          \ [['i', '<C-O>', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']]
+      execute printf(
+      \ '%snoremap <silent> %s %s:<C-U>call <SID>lod_map(%s, %s, %s, "%s")<CR>',
+      \ mode, map, map_prefix, string(map), string(names), mode != 'i', key_prefix)
+    endfor
+  endfor
+
+  for [ft, names] in items(lod.ft)
+    augroup PlugLOD
+      execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)',
+            \ ft, string(ft), string(names))
+    augroup END
+  endfor
+
+  call s:reorg_rtp()
+  filetype plugin indent on
+  if has('vim_starting')
+    if has('syntax') && !exists('g:syntax_on')
+      syntax enable
+    end
+  else
+    call s:reload_plugins()
+  endif
+endfunction
+
+function! s:loaded_names()
+  return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)')
+endfunction
+
+function! s:load_plugin(spec)
+  call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim')
+endfunction
+
+function! s:reload_plugins()
+  for name in s:loaded_names()
+    call s:load_plugin(g:plugs[name])
+  endfor
+endfunction
+
+function! s:trim(str)
+  return substitute(a:str, '[\/]\+$', '', '')
+endfunction
+
+function! s:version_requirement(val, min)
+  for idx in range(0, len(a:min) - 1)
+    let v = get(a:val, idx, 0)
+    if     v < a:min[idx] | return 0
+    elseif v > a:min[idx] | return 1
+    endif
+  endfor
+  return 1
+endfunction
+
+function! s:git_version_requirement(...)
+  if !exists('s:git_version')
+    let s:git_version = map(split(split(s:system('git --version'))[2], '\.'), 'str2nr(v:val)')
+  endif
+  return s:version_requirement(s:git_version, a:000)
+endfunction
+
+function! s:progress_opt(base)
+  return a:base && !s:is_win &&
+        \ s:git_version_requirement(1, 7, 1) ? '--progress' : ''
+endfunction
+
+if s:is_win
+  function! s:rtp(spec)
+    return s:path(a:spec.dir . get(a:spec, 'rtp', ''))
+  endfunction
+
+  function! s:path(path)
+    return s:trim(substitute(a:path, '/', '\', 'g'))
+  endfunction
+
+  function! s:dirpath(path)
+    return s:path(a:path) . '\'
+  endfunction
+
+  function! s:is_local_plug(repo)
+    return a:repo =~? '^[a-z]:\|^[%~]'
+  endfunction
+else
+  function! s:rtp(spec)
+    return s:dirpath(a:spec.dir . get(a:spec, 'rtp', ''))
+  endfunction
+
+  function! s:path(path)
+    return s:trim(a:path)
+  endfunction
+
+  function! s:dirpath(path)
+    return substitute(a:path, '[/\\]*$', '/', '')
+  endfunction
+
+  function! s:is_local_plug(repo)
+    return a:repo[0] =~ '[/$~]'
+  endfunction
+endif
+
+function! s:err(msg)
+  echohl ErrorMsg
+  echom '[vim-plug] '.a:msg
+  echohl None
+endfunction
+
+function! s:warn(cmd, msg)
+  echohl WarningMsg
+  execute a:cmd 'a:msg'
+  echohl None
+endfunction
+
+function! s:esc(path)
+  return escape(a:path, ' ')
+endfunction
+
+function! s:escrtp(path)
+  return escape(a:path, ' ,')
+endfunction
+
+function! s:remove_rtp()
+  for name in s:loaded_names()
+    let rtp = s:rtp(g:plugs[name])
+    execute 'set rtp-='.s:escrtp(rtp)
+    let after = globpath(rtp, 'after')
+    if isdirectory(after)
+      execute 'set rtp-='.s:escrtp(after)
+    endif
+  endfor
+endfunction
+
+function! s:reorg_rtp()
+  if !empty(s:first_rtp)
+    execute 'set rtp-='.s:first_rtp
+    execute 'set rtp-='.s:last_rtp
+  endif
+
+  " &rtp is modified from outside
+  if exists('s:prtp') && s:prtp !=# &rtp
+    call s:remove_rtp()
+    unlet! s:middle
+  endif
+
+  let s:middle = get(s:, 'middle', &rtp)
+  let rtps     = map(s:loaded_names(), 's:rtp(g:plugs[v:val])')
+  let afters   = filter(map(copy(rtps), 'globpath(v:val, "after")'), '!empty(v:val)')
+  let rtp      = join(map(rtps, 'escape(v:val, ",")'), ',')
+                 \ . ','.s:middle.','
+                 \ . join(map(afters, 'escape(v:val, ",")'), ',')
+  let &rtp     = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g')
+  let s:prtp   = &rtp
+
+  if !empty(s:first_rtp)
+    execute 'set rtp^='.s:first_rtp
+    execute 'set rtp+='.s:last_rtp
+  endif
+endfunction
+
+function! s:doautocmd(...)
+  if exists('#'.join(a:000, '#'))
+    execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '<nomodeline>' : '') join(a:000)
+  endif
+endfunction
+
+function! s:dobufread(names)
+  for name in a:names
+    let path = s:rtp(g:plugs[name]).'/**'
+    for dir in ['ftdetect', 'ftplugin']
+      if len(finddir(dir, path))
+        if exists('#BufRead')
+          doautocmd BufRead
+        endif
+        return
+      endif
+    endfor
+  endfor
+endfunction
+
+function! plug#load(...)
+  if a:0 == 0
+    return s:err('Argument missing: plugin name(s) required')
+  endif
+  if !exists('g:plugs')
+    return s:err('plug#begin was not called')
+  endif
+  let names = a:0 == 1 && type(a:1) == s:TYPE.list ? a:1 : a:000
+  let unknowns = filter(copy(names), '!has_key(g:plugs, v:val)')
+  if !empty(unknowns)
+    let s = len(unknowns) > 1 ? 's' : ''
+    return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', ')))
+  end
+  let unloaded = filter(copy(names), '!get(s:loaded, v:val, 0)')
+  if !empty(unloaded)
+    for name in unloaded
+      call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
+    endfor
+    call s:dobufread(unloaded)
+    return 1
+  end
+  return 0
+endfunction
+
+function! s:remove_triggers(name)
+  if !has_key(s:triggers, a:name)
+    return
+  endif
+  for cmd in s:triggers[a:name].cmd
+    execute 'silent! delc' cmd
+  endfor
+  for map in s:triggers[a:name].map
+    execute 'silent! unmap' map
+    execute 'silent! iunmap' map
+  endfor
+  call remove(s:triggers, a:name)
+endfunction
+
+function! s:lod(names, types, ...)
+  for name in a:names
+    call s:remove_triggers(name)
+    let s:loaded[name] = 1
+  endfor
+  call s:reorg_rtp()
+
+  for name in a:names
+    let rtp = s:rtp(g:plugs[name])
+    for dir in a:types
+      call s:source(rtp, dir.'/**/*.vim')
+    endfor
+    if a:0
+      if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2))
+        execute 'runtime' a:1
+      endif
+      call s:source(rtp, a:2)
+    endif
+    call s:doautocmd('User', name)
+  endfor
+endfunction
+
+function! s:lod_ft(pat, names)
+  let syn = 'syntax/'.a:pat.'.vim'
+  call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn)
+  execute 'autocmd! PlugLOD FileType' a:pat
+  call s:doautocmd('filetypeplugin', 'FileType')
+  call s:doautocmd('filetypeindent', 'FileType')
+endfunction
+
+function! s:lod_cmd(cmd, bang, l1, l2, args, names)
+  call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
+  call s:dobufread(a:names)
+  execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args)
+endfunction
+
+function! s:lod_map(map, names, with_prefix, prefix)
+  call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
+  call s:dobufread(a:names)
+  let extra = ''
+  while 1
+    let c = getchar(0)
+    if c == 0
+      break
+    endif
+    let extra .= nr2char(c)
+  endwhile
+
+  if a:with_prefix
+    let prefix = v:count ? v:count : ''
+    let prefix .= '"'.v:register.a:prefix
+    if mode(1) == 'no'
+      if v:operator == 'c'
+        let prefix = "\<esc>" . prefix
+      endif
+      let prefix .= v:operator
+    endif
+    call feedkeys(prefix, 'n')
+  endif
+  call feedkeys(substitute(a:map, '^<Plug>', "\<Plug>", '') . extra)
+endfunction
+
+function! plug#(repo, ...)
+  if a:0 > 1
+    return s:err('Invalid number of arguments (1..2)')
+  endif
+
+  try
+    let repo = s:trim(a:repo)
+    let opts = a:0 == 1 ? s:parse_options(a:1) : s:base_spec
+    let name = get(opts, 'as', fnamemodify(repo, ':t:s?\.git$??'))
+    let spec = extend(s:infer_properties(name, repo), opts)
+    if !has_key(g:plugs, name)
+      call add(g:plugs_order, name)
+    endif
+    let g:plugs[name] = spec
+    let s:loaded[name] = get(s:loaded, name, 0)
+  catch
+    return s:err(v:exception)
+  endtry
+endfunction
+
+function! s:parse_options(arg)
+  let opts = copy(s:base_spec)
+  let type = type(a:arg)
+  if type == s:TYPE.string
+    let opts.tag = a:arg
+  elseif type == s:TYPE.dict
+    call extend(opts, a:arg)
+    if has_key(opts, 'dir')
+      let opts.dir = s:dirpath(expand(opts.dir))
+    endif
+  else
+    throw 'Invalid argument type (expected: string or dictionary)'
+  endif
+  return opts
+endfunction
+
+function! s:infer_properties(name, repo)
+  let repo = a:repo
+  if s:is_local_plug(repo)
+    return { 'dir': s:dirpath(expand(repo)) }
+  else
+    if repo =~ ':'
+      let uri = repo
+    else
+      if repo !~ '/'
+        throw printf('Invalid argument: %s (implicit `vim-scripts'' expansion is deprecated)', repo)
+      endif
+      let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git')
+      let uri = printf(fmt, repo)
+    endif
+    return { 'dir': s:dirpath(g:plug_home.'/'.a:name), 'uri': uri }
+  endif
+endfunction
+
+function! s:install(force, names)
+  call s:update_impl(0, a:force, a:names)
+endfunction
+
+function! s:update(force, names)
+  call s:update_impl(1, a:force, a:names)
+endfunction
+
+function! plug#helptags()
+  if !exists('g:plugs')
+    return s:err('plug#begin was not called')
+  endif
+  for spec in values(g:plugs)
+    let docd = join([s:rtp(spec), 'doc'], '/')
+    if isdirectory(docd)
+      silent! execute 'helptags' s:esc(docd)
+    endif
+  endfor
+  return 1
+endfunction
+
+function! s:syntax()
+  syntax clear
+  syntax region plug1 start=/\%1l/ end=/\%2l/ contains=plugNumber
+  syntax region plug2 start=/\%2l/ end=/\%3l/ contains=plugBracket,plugX
+  syn match plugNumber /[0-9]\+[0-9.]*/ contained
+  syn match plugBracket /[[\]]/ contained
+  syn match plugX /x/ contained
+  syn match plugDash /^-/
+  syn match plugPlus /^+/
+  syn match plugStar /^*/
+  syn match plugMessage /\(^- \)\@<=.*/
+  syn match plugName /\(^- \)\@<=[^ ]*:/
+  syn match plugSha /\%(: \)\@<=[0-9a-f]\{4,}$/
+  syn match plugTag /(tag: [^)]\+)/
+  syn match plugInstall /\(^+ \)\@<=[^:]*/
+  syn match plugUpdate /\(^* \)\@<=[^:]*/
+  syn match plugCommit /^  \X*[0-9a-f]\{7,9} .*/ contains=plugRelDate,plugEdge,plugTag
+  syn match plugEdge /^  \X\+$/
+  syn match plugEdge /^  \X*/ contained nextgroup=plugSha
+  syn match plugSha /[0-9a-f]\{7,9}/ contained
+  syn match plugRelDate /([^)]*)$/ contained
+  syn match plugNotLoaded /(not loaded)$/
+  syn match plugError /^x.*/
+  syn region plugDeleted start=/^\~ .*/ end=/^\ze\S/
+  syn match plugH2 /^.*:\n-\+$/
+  syn keyword Function PlugInstall PlugStatus PlugUpdate PlugClean
+  hi def link plug1       Title
+  hi def link plug2       Repeat
+  hi def link plugH2      Type
+  hi def link plugX       Exception
+  hi def link plugBracket Structure
+  hi def link plugNumber  Number
+
+  hi def link plugDash    Special
+  hi def link plugPlus    Constant
+  hi def link plugStar    Boolean
+
+  hi def link plugMessage Function
+  hi def link plugName    Label
+  hi def link plugInstall Function
+  hi def link plugUpdate  Type
+
+  hi def link plugError   Error
+  hi def link plugDeleted Ignore
+  hi def link plugRelDate Comment
+  hi def link plugEdge    PreProc
+  hi def link plugSha     Identifier
+  hi def link plugTag     Constant
+
+  hi def link plugNotLoaded Comment
+endfunction
+
+function! s:lpad(str, len)
+  return a:str . repeat(' ', a:len - len(a:str))
+endfunction
+
+function! s:lines(msg)
+  return split(a:msg, "[\r\n]")
+endfunction
+
+function! s:lastline(msg)
+  return get(s:lines(a:msg), -1, '')
+endfunction
+
+function! s:new_window()
+  execute get(g:, 'plug_window', 'vertical topleft new')
+endfunction
+
+function! s:plug_window_exists()
+  let buflist = tabpagebuflist(s:plug_tab)
+  return !empty(buflist) && index(buflist, s:plug_buf) >= 0
+endfunction
+
+function! s:switch_in()
+  if !s:plug_window_exists()
+    return 0
+  endif
+
+  if winbufnr(0) != s:plug_buf
+    let s:pos = [tabpagenr(), winnr(), winsaveview()]
+    execute 'normal!' s:plug_tab.'gt'
+    let winnr = bufwinnr(s:plug_buf)
+    execute winnr.'wincmd w'
+    call add(s:pos, winsaveview())
+  else
+    let s:pos = [winsaveview()]
+  endif
+
+  setlocal modifiable
+  return 1
+endfunction
+
+function! s:switch_out(...)
+  call winrestview(s:pos[-1])
+  setlocal nomodifiable
+  if a:0 > 0
+    execute a:1
+  endif
+
+  if len(s:pos) > 1
+    execute 'normal!' s:pos[0].'gt'
+    execute s:pos[1] 'wincmd w'
+    call winrestview(s:pos[2])
+  endif
+endfunction
+
+function! s:finish_bindings()
+  nnoremap <silent> <buffer> R  :call <SID>retry()<cr>
+  nnoremap <silent> <buffer> D  :PlugDiff<cr>
+  nnoremap <silent> <buffer> S  :PlugStatus<cr>
+  nnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
+  xnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
+  nnoremap <silent> <buffer> ]] :silent! call <SID>section('')<cr>
+  nnoremap <silent> <buffer> [[ :silent! call <SID>section('b')<cr>
+endfunction
+
+function! s:prepare(...)
+  if empty(getcwd())
+    throw 'Invalid current working directory. Cannot proceed.'
+  endif
+
+  for evar in ['$GIT_DIR', '$GIT_WORK_TREE']
+    if exists(evar)
+      throw evar.' detected. Cannot proceed.'
+    endif
+  endfor
+
+  call s:job_abort()
+  if s:switch_in()
+    if b:plug_preview == 1
+      pc
+    endif
+    enew
+  else
+    call s:new_window()
+  endif
+
+  nnoremap <silent> <buffer> q  :if b:plug_preview==1<bar>pc<bar>endif<bar>bd<cr>
+  if a:0 == 0
+    call s:finish_bindings()
+  endif
+  let b:plug_preview = -1
+  let s:plug_tab = tabpagenr()
+  let s:plug_buf = winbufnr(0)
+  call s:assign_name()
+
+  for k in ['<cr>', 'L', 'o', 'X', 'd', 'dd']
+    execute 'silent! unmap <buffer>' k
+  endfor
+  setlocal buftype=nofile bufhidden=wipe nobuflisted nolist noswapfile nowrap cursorline modifiable nospell
+  setf vim-plug
+  if exists('g:syntax_on')
+    call s:syntax()
+  endif
+endfunction
+
+function! s:assign_name()
+  " Assign buffer name
+  let prefix = '[Plugins]'
+  let name   = prefix
+  let idx    = 2
+  while bufexists(name)
+    let name = printf('%s (%s)', prefix, idx)
+    let idx = idx + 1
+  endwhile
+  silent! execute 'f' fnameescape(name)
+endfunction
+
+function! s:chsh(swap)
+  let prev = [&shell, &shellcmdflag, &shellredir]
+  if s:is_win
+    set shell=cmd.exe shellcmdflag=/c shellredir=>%s\ 2>&1
+  elseif a:swap
+    set shell=sh shellredir=>%s\ 2>&1
+  endif
+  return prev
+endfunction
+
+function! s:bang(cmd, ...)
+  try
+    let [sh, shellcmdflag, shrd] = s:chsh(a:0)
+    " FIXME: Escaping is incomplete. We could use shellescape with eval,
+    "        but it won't work on Windows.
+    let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd
+    if s:is_win
+      let batchfile = tempname().'.bat'
+      call writefile(['@echo off', cmd], batchfile)
+      let cmd = batchfile
+    endif
+    let g:_plug_bang = (s:is_win && has('gui_running') ? 'silent ' : '').'!'.escape(cmd, '#!%')
+    execute "normal! :execute g:_plug_bang\<cr>\<cr>"
+  finally
+    unlet g:_plug_bang
+    let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
+    if s:is_win
+      call delete(batchfile)
+    endif
+  endtry
+  return v:shell_error ? 'Exit status: ' . v:shell_error : ''
+endfunction
+
+function! s:regress_bar()
+  let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '')
+  call s:progress_bar(2, bar, len(bar))
+endfunction
+
+function! s:is_updated(dir)
+  return !empty(s:system_chomp('git log --pretty=format:"%h" "HEAD...HEAD@{1}"', a:dir))
+endfunction
+
+function! s:do(pull, force, todo)
+  for [name, spec] in items(a:todo)
+    if !isdirectory(spec.dir)
+      continue
+    endif
+    let installed = has_key(s:update.new, name)
+    let updated = installed ? 0 :
+      \ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir))
+    if a:force || installed || updated
+      execute 'cd' s:esc(spec.dir)
+      call append(3, '- Post-update hook for '. name .' ... ')
+      let error = ''
+      let type = type(spec.do)
+      if type == s:TYPE.string
+        if spec.do[0] == ':'
+          if !get(s:loaded, name, 0)
+            let s:loaded[name] = 1
+            call s:reorg_rtp()
+          endif
+          call s:load_plugin(spec)
+          try
+            execute spec.do[1:]
+          catch
+            let error = v:exception
+          endtry
+          if !s:plug_window_exists()
+            cd -
+            throw 'Warning: vim-plug was terminated by the post-update hook of '.name
+          endif
+        else
+          let error = s:bang(spec.do)
+        endif
+      elseif type == s:TYPE.funcref
+        try
+          let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged')
+          call spec.do({ 'name': name, 'status': status, 'force': a:force })
+        catch
+          let error = v:exception
+        endtry
+      else
+        let error = 'Invalid hook type'
+      endif
+      call s:switch_in()
+      call setline(4, empty(error) ? (getline(4) . 'OK')
+                                 \ : ('x' . getline(4)[1:] . error))
+      if !empty(error)
+        call add(s:update.errors, name)
+        call s:regress_bar()
+      endif
+      cd -
+    endif
+  endfor
+endfunction
+
+function! s:hash_match(a, b)
+  return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0
+endfunction
+
+function! s:checkout(spec)
+  let sha = a:spec.commit
+  let output = s:system('git rev-parse HEAD', a:spec.dir)
+  if !v:shell_error && !s:hash_match(sha, s:lines(output)[0])
+    let output = s:system(
+          \ 'git fetch --depth 999999 && git checkout '.s:esc(sha).' --', a:spec.dir)
+  endif
+  return output
+endfunction
+
+function! s:finish(pull)
+  let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen'))
+  if new_frozen
+    let s = new_frozen > 1 ? 's' : ''
+    call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s))
+  endif
+  call append(3, '- Finishing ... ') | 4
+  redraw
+  call plug#helptags()
+  call plug#end()
+  call setline(4, getline(4) . 'Done!')
+  redraw
+  let msgs = []
+  if !empty(s:update.errors)
+    call add(msgs, "Press 'R' to retry.")
+  endif
+  if a:pull && len(s:update.new) < len(filter(getline(5, '$'),
+                \ "v:val =~ '^- ' && stridx(v:val, 'Already up-to-date') < 0"))
+    call add(msgs, "Press 'D' to see the updated changes.")
+  endif
+  echo join(msgs, ' ')
+  call s:finish_bindings()
+endfunction
+
+function! s:retry()
+  if empty(s:update.errors)
+    return
+  endif
+  echo
+  call s:update_impl(s:update.pull, s:update.force,
+        \ extend(copy(s:update.errors), [s:update.threads]))
+endfunction
+
+function! s:is_managed(name)
+  return has_key(g:plugs[a:name], 'uri')
+endfunction
+
+function! s:names(...)
+  return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)'))
+endfunction
+
+function! s:check_ruby()
+  silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'")
+  if !exists('g:plug_ruby')
+    redraw!
+    return s:warn('echom', 'Warning: Ruby interface is broken')
+  endif
+  let ruby_version = split(g:plug_ruby, '\.')
+  unlet g:plug_ruby
+  return s:version_requirement(ruby_version, [1, 8, 7])
+endfunction
+
+function! s:update_impl(pull, force, args) abort
+  let sync = index(a:args, '--sync') >= 0 || has('vim_starting')
+  let args = filter(copy(a:args), 'v:val != "--sync"')
+  let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ?
+                  \ remove(args, -1) : get(g:, 'plug_threads', 16)
+
+  let managed = filter(copy(g:plugs), 's:is_managed(v:key)')
+  let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') :
+                         \ filter(managed, 'index(args, v:key) >= 0')
+
+  if empty(todo)
+    return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install'))
+  endif
+
+  if !s:is_win && s:git_version_requirement(2, 3)
+    let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : ''
+    let $GIT_TERMINAL_PROMPT = 0
+    for plug in values(todo)
+      let plug.uri = substitute(plug.uri,
+            \ '^https://git::@github\.com', 'https://github.com', '')
+    endfor
+  endif
+
+  if !isdirectory(g:plug_home)
+    try
+      call mkdir(g:plug_home, 'p')
+    catch
+      return s:err(printf('Invalid plug directory: %s. '.
+              \ 'Try to call plug#begin with a valid directory', g:plug_home))
+    endtry
+  endif
+
+  if has('nvim') && !exists('*jobwait') && threads > 1
+    call s:warn('echom', '[vim-plug] Update Neovim for parallel installer')
+  endif
+
+  let use_job = s:nvim || s:vim8
+  let python = (has('python') || has('python3')) && !use_job
+  let ruby = has('ruby') && !use_job && (v:version >= 703 || v:version == 702 && has('patch374')) && !(s:is_win && has('gui_running')) && threads > 1 && s:check_ruby()
+
+  let s:update = {
+    \ 'start':   reltime(),
+    \ 'all':     todo,
+    \ 'todo':    copy(todo),
+    \ 'errors':  [],
+    \ 'pull':    a:pull,
+    \ 'force':   a:force,
+    \ 'new':     {},
+    \ 'threads': (python || ruby || use_job) ? min([len(todo), threads]) : 1,
+    \ 'bar':     '',
+    \ 'fin':     0
+  \ }
+
+  call s:prepare(1)
+  call append(0, ['', ''])
+  normal! 2G
+  silent! redraw
+
+  let s:clone_opt = get(g:, 'plug_shallow', 1) ?
+        \ '--depth 1' . (s:git_version_requirement(1, 7, 10) ? ' --no-single-branch' : '') : ''
+
+  if has('win32unix')
+    let s:clone_opt .= ' -c core.eol=lf -c core.autocrlf=input'
+  endif
+
+  " Python version requirement (>= 2.7)
+  if python && !has('python3') && !ruby && !use_job && s:update.threads > 1
+    redir => pyv
+    silent python import platform; print platform.python_version()
+    redir END
+    let python = s:version_requirement(
+          \ map(split(split(pyv)[0], '\.'), 'str2nr(v:val)'), [2, 6])
+  endif
+
+  if (python || ruby) && s:update.threads > 1
+    try
+      let imd = &imd
+      if s:mac_gui
+        set noimd
+      endif
+      if ruby
+        call s:update_ruby()
+      else
+        call s:update_python()
+      endif
+    catch
+      let lines = getline(4, '$')
+      let printed = {}
+      silent! 4,$d _
+      for line in lines
+        let name = s:extract_name(line, '.', '')
+        if empty(name) || !has_key(printed, name)
+          call append('$', line)
+          if !empty(name)
+            let printed[name] = 1
+            if line[0] == 'x' && index(s:update.errors, name) < 0
+              call add(s:update.errors, name)
+            end
+          endif
+        endif
+      endfor
+    finally
+      let &imd = imd
+      call s:update_finish()
+    endtry
+  else
+    call s:update_vim()
+    while use_job && sync
+      sleep 100m
+      if s:update.fin
+        break
+      endif
+    endwhile
+  endif
+endfunction
+
+function! s:log4(name, msg)
+  call setline(4, printf('- %s (%s)', a:msg, a:name))
+  redraw
+endfunction
+
+function! s:update_finish()
+  if exists('s:git_terminal_prompt')
+    let $GIT_TERMINAL_PROMPT = s:git_terminal_prompt
+  endif
+  if s:switch_in()
+    call append(3, '- Updating ...') | 4
+    for [name, spec] in items(filter(copy(s:update.all), 'index(s:update.errors, v:key) < 0 && (s:update.force || s:update.pull || has_key(s:update.new, v:key))'))
+      let [pos, _] = s:logpos(name)
+      if !pos
+        continue
+      endif
+      if has_key(spec, 'commit')
+        call s:log4(name, 'Checking out '.spec.commit)
+        let out = s:checkout(spec)
+      elseif has_key(spec, 'tag')
+        let tag = spec.tag
+        if tag =~ '\*'
+          let tags = s:lines(s:system('git tag --list '.s:shellesc(tag).' --sort -version:refname 2>&1', spec.dir))
+          if !v:shell_error && !empty(tags)
+            let tag = tags[0]
+            call s:log4(name, printf('Latest tag for %s -> %s', spec.tag, tag))
+            call append(3, '')
+          endif
+        endif
+        call s:log4(name, 'Checking out '.tag)
+        let out = s:system('git checkout -q '.s:esc(tag).' -- 2>&1', spec.dir)
+      else
+        let branch = s:esc(get(spec, 'branch', 'master'))
+        call s:log4(name, 'Merging origin/'.branch)
+        let out = s:system('git checkout -q '.branch.' -- 2>&1'
+              \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only origin/'.branch.' 2>&1')), spec.dir)
+      endif
+      if !v:shell_error && filereadable(spec.dir.'/.gitmodules') &&
+            \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir))
+        call s:log4(name, 'Updating submodules. This may take a while.')
+        let out .= s:bang('git submodule update --init --recursive 2>&1', spec.dir)
+      endif
+      let msg = s:format_message(v:shell_error ? 'x': '-', name, out)
+      if v:shell_error
+        call add(s:update.errors, name)
+        call s:regress_bar()
+        silent execute pos 'd _'
+        call append(4, msg) | 4
+      elseif !empty(out)
+        call setline(pos, msg[0])
+      endif
+      redraw
+    endfor
+    silent 4 d _
+    try
+      call s:do(s:update.pull, s:update.force, filter(copy(s:update.all), 'index(s:update.errors, v:key) < 0 && has_key(v:val, "do")'))
+    catch
+      call s:warn('echom', v:exception)
+      call s:warn('echo', '')
+      return
+    endtry
+    call s:finish(s:update.pull)
+    call setline(1, 'Updated. Elapsed time: ' . split(reltimestr(reltime(s:update.start)))[0] . ' sec.')
+    call s:switch_out('normal! gg')
+  endif
+endfunction
+
+function! s:job_abort()
+  if (!s:nvim && !s:vim8) || !exists('s:jobs')
+    return
+  endif
+
+  for [name, j] in items(s:jobs)
+    if s:nvim
+      silent! call jobstop(j.jobid)
+    elseif s:vim8
+      silent! call job_stop(j.jobid)
+    endif
+    if j.new
+      call s:system('rm -rf ' . s:shellesc(g:plugs[name].dir))
+    endif
+  endfor
+  let s:jobs = {}
+endfunction
+
+function! s:last_non_empty_line(lines)
+  let len = len(a:lines)
+  for idx in range(len)
+    let line = a:lines[len-idx-1]
+    if !empty(line)
+      return line
+    endif
+  endfor
+  return ''
+endfunction
+
+function! s:job_out_cb(self, data) abort
+  let self = a:self
+  let data = remove(self.lines, -1) . a:data
+  let lines = map(split(data, "\n", 1), 'split(v:val, "\r", 1)[-1]')
+  call extend(self.lines, lines)
+  " To reduce the number of buffer updates
+  let self.tick = get(self, 'tick', -1) + 1
+  if !self.running || self.tick % len(s:jobs) == 0
+    let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-')
+    let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines)
+    call s:log(bullet, self.name, result)
+  endif
+endfunction
+
+function! s:job_exit_cb(self, data) abort
+  let a:self.running = 0
+  let a:self.error = a:data != 0
+  call s:reap(a:self.name)
+  call s:tick()
+endfunction
+
+function! s:job_cb(fn, job, ch, data)
+  if !s:plug_window_exists() " plug window closed
+    return s:job_abort()
+  endif
+  call call(a:fn, [a:job, a:data])
+endfunction
+
+function! s:nvim_cb(job_id, data, event) dict abort
+  return a:event == 'stdout' ?
+    \ s:job_cb('s:job_out_cb',  self, 0, join(a:data, "\n")) :
+    \ s:job_cb('s:job_exit_cb', self, 0, a:data)
+endfunction
+
+function! s:spawn(name, cmd, opts)
+  let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''],
+            \ 'batchfile': (s:is_win && (s:nvim || s:vim8)) ? tempname().'.bat' : '',
+            \ 'new': get(a:opts, 'new', 0) }
+  let s:jobs[a:name] = job
+  let cmd = has_key(a:opts, 'dir') ? s:with_cd(a:cmd, a:opts.dir) : a:cmd
+  if !empty(job.batchfile)
+    call writefile(['@echo off', cmd], job.batchfile)
+    let cmd = job.batchfile
+  endif
+  let argv = add(s:is_win ? ['cmd', '/c'] : ['sh', '-c'], cmd)
+
+  if s:nvim
+    call extend(job, {
+    \ 'on_stdout': function('s:nvim_cb'),
+    \ 'on_exit':   function('s:nvim_cb'),
+    \ })
+    let jid = jobstart(argv, job)
+    if jid > 0
+      let job.jobid = jid
+    else
+      let job.running = 0
+      let job.error   = 1
+      let job.lines   = [jid < 0 ? argv[0].' is not executable' :
+            \ 'Invalid arguments (or job table is full)']
+    endif
+  elseif s:vim8
+    let jid = job_start(s:is_win ? join(argv, ' ') : argv, {
+    \ 'out_cb':   function('s:job_cb', ['s:job_out_cb',  job]),
+    \ 'exit_cb':  function('s:job_cb', ['s:job_exit_cb', job]),
+    \ 'out_mode': 'raw'
+    \})
+    if job_status(jid) == 'run'
+      let job.jobid = jid
+    else
+      let job.running = 0
+      let job.error   = 1
+      let job.lines   = ['Failed to start job']
+    endif
+  else
+    let job.lines = s:lines(call('s:system', [cmd]))
+    let job.error = v:shell_error != 0
+    let job.running = 0
+  endif
+endfunction
+
+function! s:reap(name)
+  let job = s:jobs[a:name]
+  if job.error
+    call add(s:update.errors, a:name)
+  elseif get(job, 'new', 0)
+    let s:update.new[a:name] = 1
+  endif
+  let s:update.bar .= job.error ? 'x' : '='
+
+  let bullet = job.error ? 'x' : '-'
+  let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines)
+  call s:log(bullet, a:name, empty(result) ? 'OK' : result)
+  call s:bar()
+
+  if has_key(job, 'batchfile') && !empty(job.batchfile)
+    call delete(job.batchfile)
+  endif
+  call remove(s:jobs, a:name)
+endfunction
+
+function! s:bar()
+  if s:switch_in()
+    let total = len(s:update.all)
+    call setline(1, (s:update.pull ? 'Updating' : 'Installing').
+          \ ' plugins ('.len(s:update.bar).'/'.total.')')
+    call s:progress_bar(2, s:update.bar, total)
+    call s:switch_out()
+  endif
+endfunction
+
+function! s:logpos(name)
+  for i in range(4, line('$'))
+    if getline(i) =~# '^[-+x*] '.a:name.':'
+      for j in range(i + 1, line('$'))
+        if getline(j) !~ '^ '
+          return [i, j - 1]
+        endif
+      endfor
+      return [i, i]
+    endif
+  endfor
+  return [0, 0]
+endfunction
+
+function! s:log(bullet, name, lines)
+  if s:switch_in()
+    let [b, e] = s:logpos(a:name)
+    if b > 0
+      silent execute printf('%d,%d d _', b, e)
+      if b > winheight('.')
+        let b = 4
+      endif
+    else
+      let b = 4
+    endif
+    " FIXME For some reason, nomodifiable is set after :d in vim8
+    setlocal modifiable
+    call append(b - 1, s:format_message(a:bullet, a:name, a:lines))
+    call s:switch_out()
+  endif
+endfunction
+
+function! s:update_vim()
+  let s:jobs = {}
+
+  call s:bar()
+  call s:tick()
+endfunction
+
+function! s:tick()
+  let pull = s:update.pull
+  let prog = s:progress_opt(s:nvim || s:vim8)
+while 1 " Without TCO, Vim stack is bound to explode
+  if empty(s:update.todo)
+    if empty(s:jobs) && !s:update.fin
+      call s:update_finish()
+      let s:update.fin = 1
+    endif
+    return
+  endif
+
+  let name = keys(s:update.todo)[0]
+  let spec = remove(s:update.todo, name)
+  let new  = !isdirectory(spec.dir)
+
+  call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...')
+  redraw
+
+  let has_tag = has_key(spec, 'tag')
+  if !new
+    let [error, _] = s:git_validate(spec, 0)
+    if empty(error)
+      if pull
+        let fetch_opt = (has_tag && !empty(globpath(spec.dir, '.git/shallow'))) ? '--depth 99999999' : ''
+        call s:spawn(name, printf('git fetch %s %s 2>&1', fetch_opt, prog), { 'dir': spec.dir })
+      else
+        let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 }
+      endif
+    else
+      let s:jobs[name] = { 'running': 0, 'lines': s:lines(error), 'error': 1 }
+    endif
+  else
+    call s:spawn(name,
+          \ printf('git clone %s %s %s %s 2>&1',
+          \ has_tag ? '' : s:clone_opt,
+          \ prog,
+          \ s:shellesc(spec.uri),
+          \ s:shellesc(s:trim(spec.dir))), { 'new': 1 })
+  endif
+
+  if !s:jobs[name].running
+    call s:reap(name)
+  endif
+  if len(s:jobs) >= s:update.threads
+    break
+  endif
+endwhile
+endfunction
+
+function! s:update_python()
+let py_exe = has('python') ? 'python' : 'python3'
+execute py_exe "<< EOF"
+import datetime
+import functools
+import os
+try:
+  import queue
+except ImportError:
+  import Queue as queue
+import random
+import re
+import shutil
+import signal
+import subprocess
+import tempfile
+import threading as thr
+import time
+import traceback
+import vim
+
+G_NVIM = vim.eval("has('nvim')") == '1'
+G_PULL = vim.eval('s:update.pull') == '1'
+G_RETRIES = int(vim.eval('get(g:, "plug_retries", 2)')) + 1
+G_TIMEOUT = int(vim.eval('get(g:, "plug_timeout", 60)'))
+G_CLONE_OPT = vim.eval('s:clone_opt')
+G_PROGRESS = vim.eval('s:progress_opt(1)')
+G_LOG_PROB = 1.0 / int(vim.eval('s:update.threads'))
+G_STOP = thr.Event()
+G_IS_WIN = vim.eval('s:is_win') == '1'
+
+class PlugError(Exception):
+  def __init__(self, msg):
+    self.msg = msg
+class CmdTimedOut(PlugError):
+  pass
+class CmdFailed(PlugError):
+  pass
+class InvalidURI(PlugError):
+  pass
+class Action(object):
+  INSTALL, UPDATE, ERROR, DONE = ['+', '*', 'x', '-']
+
+class Buffer(object):
+  def __init__(self, lock, num_plugs, is_pull):
+    self.bar = ''
+    self.event = 'Updating' if is_pull else 'Installing'
+    self.lock = lock
+    self.maxy = int(vim.eval('winheight(".")'))
+    self.num_plugs = num_plugs
+
+  def __where(self, name):
+    """ Find first line with name in current buffer. Return line num. """
+    found, lnum = False, 0
+    matcher = re.compile('^[-+x*] {0}:'.format(name))
+    for line in vim.current.buffer:
+      if matcher.search(line) is not None:
+        found = True
+        break
+      lnum += 1
+
+    if not found:
+      lnum = -1
+    return lnum
+
+  def header(self):
+    curbuf = vim.current.buffer
+    curbuf[0] = self.event + ' plugins ({0}/{1})'.format(len(self.bar), self.num_plugs)
+
+    num_spaces = self.num_plugs - len(self.bar)
+    curbuf[1] = '[{0}{1}]'.format(self.bar, num_spaces * ' ')
+
+    with self.lock:
+      vim.command('normal! 2G')
+      vim.command('redraw')
+
+  def write(self, action, name, lines):
+    first, rest = lines[0], lines[1:]
+    msg = ['{0} {1}{2}{3}'.format(action, name, ': ' if first else '', first)]
+    msg.extend(['    ' + line for line in rest])
+
+    try:
+      if action == Action.ERROR:
+        self.bar += 'x'
+        vim.command("call add(s:update.errors, '{0}')".format(name))
+      elif action == Action.DONE:
+        self.bar += '='
+
+      curbuf = vim.current.buffer
+      lnum = self.__where(name)
+      if lnum != -1: # Found matching line num
+        del curbuf[lnum]
+        if lnum > self.maxy and action in set([Action.INSTALL, Action.UPDATE]):
+          lnum = 3
+      else:
+        lnum = 3
+      curbuf.append(msg, lnum)
+
+      self.header()
+    except vim.error:
+      pass
+
+class Command(object):
+  CD = 'cd /d' if G_IS_WIN else 'cd'
+
+  def __init__(self, cmd, cmd_dir=None, timeout=60, cb=None, clean=None):
+    self.cmd = cmd
+    if cmd_dir:
+      self.cmd = '{0} {1} && {2}'.format(Command.CD, cmd_dir, self.cmd)
+    self.timeout = timeout
+    self.callback = cb if cb else (lambda msg: None)
+    self.clean = clean if clean else (lambda: None)
+    self.proc = None
+
+  @property
+  def alive(self):
+    """ Returns true only if command still running. """
+    return self.proc and self.proc.poll() is None
+
+  def execute(self, ntries=3):
+    """ Execute the command with ntries if CmdTimedOut.
+        Returns the output of the command if no Exception.
+    """
+    attempt, finished, limit = 0, False, self.timeout
+
+    while not finished:
+      try:
+        attempt += 1
+        result = self.try_command()
+        finished = True
+        return result
+      except CmdTimedOut:
+        if attempt != ntries:
+          self.notify_retry()
+          self.timeout += limit
+        else:
+          raise
+
+  def notify_retry(self):
+    """ Retry required for command, notify user. """
+    for count in range(3, 0, -1):
+      if G_STOP.is_set():
+        raise KeyboardInterrupt
+      msg = 'Timeout. Will retry in {0} second{1} ...'.format(
+            count, 's' if count != 1 else '')
+      self.callback([msg])
+      time.sleep(1)
+    self.callback(['Retrying ...'])
+
+  def try_command(self):
+    """ Execute a cmd & poll for callback. Returns list of output.
+        Raises CmdFailed   -> return code for Popen isn't 0
+        Raises CmdTimedOut -> command exceeded timeout without new output
+    """
+    first_line = True
+
+    try:
+      tfile = tempfile.NamedTemporaryFile(mode='w+b')
+      preexec_fn = not G_IS_WIN and os.setsid or None
+      self.proc = subprocess.Popen(self.cmd, stdout=tfile,
+                                   stderr=subprocess.STDOUT,
+                                   stdin=subprocess.PIPE, shell=True,
+                                   preexec_fn=preexec_fn)
+      thrd = thr.Thread(target=(lambda proc: proc.wait()), args=(self.proc,))
+      thrd.start()
+
+      thread_not_started = True
+      while thread_not_started:
+        try:
+          thrd.join(0.1)
+          thread_not_started = False
+        except RuntimeError:
+          pass
+
+      while self.alive:
+        if G_STOP.is_set():
+          raise KeyboardInterrupt
+
+        if first_line or random.random() < G_LOG_PROB:
+          first_line = False
+          line = '' if G_IS_WIN else nonblock_read(tfile.name)
+          if line:
+            self.callback([line])
+
+        time_diff = time.time() - os.path.getmtime(tfile.name)
+        if time_diff > self.timeout:
+          raise CmdTimedOut(['Timeout!'])
+
+        thrd.join(0.5)
+
+      tfile.seek(0)
+      result = [line.decode('utf-8', 'replace').rstrip() for line in tfile]
+
+      if self.proc.returncode != 0:
+        raise CmdFailed([''] + result)
+
+      return result
+    except:
+      self.terminate()
+      raise
+
+  def terminate(self):
+    """ Terminate process and cleanup. """
+    if self.alive:
+      if G_IS_WIN:
+        os.kill(self.proc.pid, signal.SIGINT)
+      else:
+        os.killpg(self.proc.pid, signal.SIGTERM)
+    self.clean()
+
+class Plugin(object):
+  def __init__(self, name, args, buf_q, lock):
+    self.name = name
+    self.args = args
+    self.buf_q = buf_q
+    self.lock = lock
+    self.tag = args.get('tag', 0)
+
+  def manage(self):
+    try:
+      if os.path.exists(self.args['dir']):
+        self.update()
+      else:
+        self.install()
+        with self.lock:
+          thread_vim_command("let s:update.new['{0}'] = 1".format(self.name))
+    except PlugError as exc:
+      self.write(Action.ERROR, self.name, exc.msg)
+    except KeyboardInterrupt:
+      G_STOP.set()
+      self.write(Action.ERROR, self.name, ['Interrupted!'])
+    except:
+      # Any exception except those above print stack trace
+      msg = 'Trace:\n{0}'.format(traceback.format_exc().rstrip())
+      self.write(Action.ERROR, self.name, msg.split('\n'))
+      raise
+
+  def install(self):
+    target = self.args['dir']
+    if target[-1] == '\\':
+      target = target[0:-1]
+
+    def clean(target):
+      def _clean():
+        try:
+          shutil.rmtree(target)
+        except OSError:
+          pass
+      return _clean
+
+    self.write(Action.INSTALL, self.name, ['Installing ...'])
+    callback = functools.partial(self.write, Action.INSTALL, self.name)
+    cmd = 'git clone {0} {1} {2} {3} 2>&1'.format(
+          '' if self.tag else G_CLONE_OPT, G_PROGRESS, self.args['uri'],
+          esc(target))
+    com = Command(cmd, None, G_TIMEOUT, callback, clean(target))
+    result = com.execute(G_RETRIES)
+    self.write(Action.DONE, self.name, result[-1:])
+
+  def repo_uri(self):
+    cmd = 'git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url'
+    command = Command(cmd, self.args['dir'], G_TIMEOUT,)
+    result = command.execute(G_RETRIES)
+    return result[-1]
+
+  def update(self):
+    actual_uri = self.repo_uri()
+    expect_uri = self.args['uri']
+    regex = re.compile(r'^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$')
+    ma = regex.match(actual_uri)
+    mb = regex.match(expect_uri)
+    if ma is None or mb is None or ma.groups() != mb.groups():
+      msg = ['',
+             'Invalid URI: {0}'.format(actual_uri),
+             'Expected     {0}'.format(expect_uri),
+             'PlugClean required.']
+      raise InvalidURI(msg)
+
+    if G_PULL:
+      self.write(Action.UPDATE, self.name, ['Updating ...'])
+      callback = functools.partial(self.write, Action.UPDATE, self.name)
+      fetch_opt = '--depth 99999999' if self.tag and os.path.isfile(os.path.join(self.args['dir'], '.git/shallow')) else ''
+      cmd = 'git fetch {0} {1} 2>&1'.format(fetch_opt, G_PROGRESS)
+      com = Command(cmd, self.args['dir'], G_TIMEOUT, callback)
+      result = com.execute(G_RETRIES)
+      self.write(Action.DONE, self.name, result[-1:])
+    else:
+      self.write(Action.DONE, self.name, ['Already installed'])
+
+  def write(self, action, name, msg):
+    self.buf_q.put((action, name, msg))
+
+class PlugThread(thr.Thread):
+  def __init__(self, tname, args):
+    super(PlugThread, self).__init__()
+    self.tname = tname
+    self.args = args
+
+  def run(self):
+    thr.current_thread().name = self.tname
+    buf_q, work_q, lock = self.args
+
+    try:
+      while not G_STOP.is_set():
+        name, args = work_q.get_nowait()
+        plug = Plugin(name, args, buf_q, lock)
+        plug.manage()
+        work_q.task_done()
+    except queue.Empty:
+      pass
+
+class RefreshThread(thr.Thread):
+  def __init__(self, lock):
+    super(RefreshThread, self).__init__()
+    self.lock = lock
+    self.running = True
+
+  def run(self):
+    while self.running:
+      with self.lock:
+        thread_vim_command('noautocmd normal! a')
+      time.sleep(0.33)
+
+  def stop(self):
+    self.running = False
+
+if G_NVIM:
+  def thread_vim_command(cmd):
+    vim.session.threadsafe_call(lambda: vim.command(cmd))
+else:
+  def thread_vim_command(cmd):
+    vim.command(cmd)
+
+def esc(name):
+  return '"' + name.replace('"', '\"') + '"'
+
+def nonblock_read(fname):
+  """ Read a file with nonblock flag. Return the last line. """
+  fread = os.open(fname, os.O_RDONLY | os.O_NONBLOCK)
+  buf = os.read(fread, 100000).decode('utf-8', 'replace')
+  os.close(fread)
+
+  line = buf.rstrip('\r\n')
+  left = max(line.rfind('\r'), line.rfind('\n'))
+  if left != -1:
+    left += 1
+    line = line[left:]
+
+  return line
+
+def main():
+  thr.current_thread().name = 'main'
+  nthreads = int(vim.eval('s:update.threads'))
+  plugs = vim.eval('s:update.todo')
+  mac_gui = vim.eval('s:mac_gui') == '1'
+
+  lock = thr.Lock()
+  buf = Buffer(lock, len(plugs), G_PULL)
+  buf_q, work_q = queue.Queue(), queue.Queue()
+  for work in plugs.items():
+    work_q.put(work)
+
+  start_cnt = thr.active_count()
+  for num in range(nthreads):
+    tname = 'PlugT-{0:02}'.format(num)
+    thread = PlugThread(tname, (buf_q, work_q, lock))
+    thread.start()
+  if mac_gui:
+    rthread = RefreshThread(lock)
+    rthread.start()
+
+  while not buf_q.empty() or thr.active_count() != start_cnt:
+    try:
+      action, name, msg = buf_q.get(True, 0.25)
+      buf.write(action, name, ['OK'] if not msg else msg)
+      buf_q.task_done()
+    except queue.Empty:
+      pass
+    except KeyboardInterrupt:
+      G_STOP.set()
+
+  if mac_gui:
+    rthread.stop()
+    rthread.join()
+
+main()
+EOF
+endfunction
+
+function! s:update_ruby()
+  ruby << EOF
+  module PlugStream
+    SEP = ["\r", "\n", nil]
+    def get_line
+      buffer = ''
+      loop do
+        char = readchar rescue return
+        if SEP.include? char.chr
+          buffer << $/
+          break
+        else
+          buffer << char
+        end
+      end
+      buffer
+    end
+  end unless defined?(PlugStream)
+
+  def esc arg
+    %["#{arg.gsub('"', '\"')}"]
+  end
+
+  def killall pid
+    pids = [pid]
+    if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM
+      pids.each { |pid| Process.kill 'INT', pid.to_i rescue nil }
+    else
+      unless `which pgrep 2> /dev/null`.empty?
+        children = pids
+        until children.empty?
+          children = children.map { |pid|
+            `pgrep -P #{pid}`.lines.map { |l| l.chomp }
+          }.flatten
+          pids += children
+        end
+      end
+      pids.each { |pid| Process.kill 'TERM', pid.to_i rescue nil }
+    end
+  end
+
+  def compare_git_uri a, b
+    regex = %r{^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$}
+    regex.match(a).to_a.drop(1) == regex.match(b).to_a.drop(1)
+  end
+
+  require 'thread'
+  require 'fileutils'
+  require 'timeout'
+  running = true
+  iswin = VIM::evaluate('s:is_win').to_i == 1
+  pull  = VIM::evaluate('s:update.pull').to_i == 1
+  base  = VIM::evaluate('g:plug_home')
+  all   = VIM::evaluate('s:update.todo')
+  limit = VIM::evaluate('get(g:, "plug_timeout", 60)')
+  tries = VIM::evaluate('get(g:, "plug_retries", 2)') + 1
+  nthr  = VIM::evaluate('s:update.threads').to_i
+  maxy  = VIM::evaluate('winheight(".")').to_i
+  vim7  = VIM::evaluate('v:version').to_i <= 703 && RUBY_PLATFORM =~ /darwin/
+  cd    = iswin ? 'cd /d' : 'cd'
+  tot   = VIM::evaluate('len(s:update.todo)') || 0
+  bar   = ''
+  skip  = 'Already installed'
+  mtx   = Mutex.new
+  take1 = proc { mtx.synchronize { running && all.shift } }
+  logh  = proc {
+    cnt = bar.length
+    $curbuf[1] = "#{pull ? 'Updating' : 'Installing'} plugins (#{cnt}/#{tot})"
+    $curbuf[2] = '[' + bar.ljust(tot) + ']'
+    VIM::command('normal! 2G')
+    VIM::command('redraw')
+  }
+  where = proc { |name| (1..($curbuf.length)).find { |l| $curbuf[l] =~ /^[-+x*] #{name}:/ } }
+  log   = proc { |name, result, type|
+    mtx.synchronize do
+      ing  = ![true, false].include?(type)
+      bar += type ? '=' : 'x' unless ing
+      b = case type
+          when :install  then '+' when :update then '*'
+          when true, nil then '-' else
+            VIM::command("call add(s:update.errors, '#{name}')")
+            'x'
+          end
+      result =
+        if type || type.nil?
+          ["#{b} #{name}: #{result.lines.to_a.last || 'OK'}"]
+        elsif result =~ /^Interrupted|^Timeout/
+          ["#{b} #{name}: #{result}"]
+        else
+          ["#{b} #{name}"] + result.lines.map { |l| "    " << l }
+        end
+      if lnum = where.call(name)
+        $curbuf.delete lnum
+        lnum = 4 if ing && lnum > maxy
+      end
+      result.each_with_index do |line, offset|
+        $curbuf.append((lnum || 4) - 1 + offset, line.gsub(/\e\[./, '').chomp)
+      end
+      logh.call
+    end
+  }
+  bt = proc { |cmd, name, type, cleanup|
+    tried = timeout = 0
+    begin
+      tried += 1
+      timeout += limit
+      fd = nil
+      data = ''
+      if iswin
+        Timeout::timeout(timeout) do
+          tmp = VIM::evaluate('tempname()')
+          system("(#{cmd}) > #{tmp}")
+          data = File.read(tmp).chomp
+          File.unlink tmp rescue nil
+        end
+      else
+        fd = IO.popen(cmd).extend(PlugStream)
+        first_line = true
+        log_prob = 1.0 / nthr
+        while line = Timeout::timeout(timeout) { fd.get_line }
+          data << line
+          log.call name, line.chomp, type if name && (first_line || rand < log_prob)
+          first_line = false
+        end
+        fd.close
+      end
+      [$? == 0, data.chomp]
+    rescue Timeout::Error, Interrupt => e
+      if fd && !fd.closed?
+        killall fd.pid
+        fd.close
+      end
+      cleanup.call if cleanup
+      if e.is_a?(Timeout::Error) && tried < tries
+        3.downto(1) do |countdown|
+          s = countdown > 1 ? 's' : ''
+          log.call name, "Timeout. Will retry in #{countdown} second#{s} ...", type
+          sleep 1
+        end
+        log.call name, 'Retrying ...', type
+        retry
+      end
+      [false, e.is_a?(Interrupt) ? "Interrupted!" : "Timeout!"]
+    end
+  }
+  main = Thread.current
+  threads = []
+  watcher = Thread.new {
+    if vim7
+      while VIM::evaluate('getchar(1)')
+        sleep 0.1
+      end
+    else
+      require 'io/console' # >= Ruby 1.9
+      nil until IO.console.getch == 3.chr
+    end
+    mtx.synchronize do
+      running = false
+      threads.each { |t| t.raise Interrupt } unless vim7
+    end
+    threads.each { |t| t.join rescue nil }
+    main.kill
+  }
+  refresh = Thread.new {
+    while true
+      mtx.synchronize do
+        break unless running
+        VIM::command('noautocmd normal! a')
+      end
+      sleep 0.2
+    end
+  } if VIM::evaluate('s:mac_gui') == 1
+
+  clone_opt = VIM::evaluate('s:clone_opt')
+  progress = VIM::evaluate('s:progress_opt(1)')
+  nthr.times do
+    mtx.synchronize do
+      threads << Thread.new {
+        while pair = take1.call
+          name = pair.first
+          dir, uri, tag = pair.last.values_at *%w[dir uri tag]
+          exists = File.directory? dir
+          ok, result =
+            if exists
+              chdir = "#{cd} #{iswin ? dir : esc(dir)}"
+              ret, data = bt.call "#{chdir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url", nil, nil, nil
+              current_uri = data.lines.to_a.last
+              if !ret
+                if data =~ /^Interrupted|^Timeout/
+                  [false, data]
+                else
+                  [false, [data.chomp, "PlugClean required."].join($/)]
+                end
+              elsif !compare_git_uri(current_uri, uri)
+                [false, ["Invalid URI: #{current_uri}",
+                         "Expected:    #{uri}",
+                         "PlugClean required."].join($/)]
+              else
+                if pull
+                  log.call name, 'Updating ...', :update
+                  fetch_opt = (tag && File.exist?(File.join(dir, '.git/shallow'))) ? '--depth 99999999' : ''
+                  bt.call "#{chdir} && git fetch #{fetch_opt} #{progress} 2>&1", name, :update, nil
+                else
+                  [true, skip]
+                end
+              end
+            else
+              d = esc dir.sub(%r{[\\/]+$}, '')
+              log.call name, 'Installing ...', :install
+              bt.call "git clone #{clone_opt unless tag} #{progress} #{uri} #{d} 2>&1", name, :install, proc {
+                FileUtils.rm_rf dir
+              }
+            end
+          mtx.synchronize { VIM::command("let s:update.new['#{name}'] = 1") } if !exists && ok
+          log.call name, result, ok
+        end
+      } if running
+    end
+  end
+  threads.each { |t| t.join rescue nil }
+  logh.call
+  refresh.kill if refresh
+  watcher.kill
+EOF
+endfunction
+
+function! s:shellesc_cmd(arg)
+  let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g')
+  let escaped = substitute(escaped, '%', '%%', 'g')
+  let escaped = substitute(escaped, '"', '\\^&', 'g')
+  let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g')
+  return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"'
+endfunction
+
+function! s:shellesc(arg)
+  if &shell =~# 'cmd.exe$'
+    return s:shellesc_cmd(a:arg)
+  endif
+  return shellescape(a:arg)
+endfunction
+
+function! s:glob_dir(path)
+  return map(filter(s:glob(a:path, '**'), 'isdirectory(v:val)'), 's:dirpath(v:val)')
+endfunction
+
+function! s:progress_bar(line, bar, total)
+  call setline(a:line, '[' . s:lpad(a:bar, a:total) . ']')
+endfunction
+
+function! s:compare_git_uri(a, b)
+  " See `git help clone'
+  " https:// [user@] github.com[:port] / junegunn/vim-plug [.git]
+  "          [git@]  github.com[:port] : junegunn/vim-plug [.git]
+  " file://                            / junegunn/vim-plug        [/]
+  "                                    / junegunn/vim-plug        [/]
+  let pat = '^\%(\w\+://\)\='.'\%([^@/]*@\)\='.'\([^:/]*\%(:[0-9]*\)\=\)'.'[:/]'.'\(.\{-}\)'.'\%(\.git\)\=/\?$'
+  let ma = matchlist(a:a, pat)
+  let mb = matchlist(a:b, pat)
+  return ma[1:2] ==# mb[1:2]
+endfunction
+
+function! s:format_message(bullet, name, message)
+  if a:bullet != 'x'
+    return [printf('%s %s: %s', a:bullet, a:name, s:lastline(a:message))]
+  else
+    let lines = map(s:lines(a:message), '"    ".v:val')
+    return extend([printf('x %s:', a:name)], lines)
+  endif
+endfunction
+
+function! s:with_cd(cmd, dir)
+  return printf('cd%s %s && %s', s:is_win ? ' /d' : '', s:shellesc(a:dir), a:cmd)
+endfunction
+
+function! s:system(cmd, ...)
+  try
+    let [sh, shellcmdflag, shrd] = s:chsh(1)
+    let cmd = a:0 > 0 ? s:with_cd(a:cmd, a:1) : a:cmd
+    if s:is_win
+      let batchfile = tempname().'.bat'
+      call writefile(['@echo off', cmd], batchfile)
+      let cmd = batchfile
+    endif
+    return system(s:is_win ? '('.cmd.')' : cmd)
+  finally
+    let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
+    if s:is_win
+      call delete(batchfile)
+    endif
+  endtry
+endfunction
+
+function! s:system_chomp(...)
+  let ret = call('s:system', a:000)
+  return v:shell_error ? '' : substitute(ret, '\n$', '', '')
+endfunction
+
+function! s:git_validate(spec, check_branch)
+  let err = ''
+  if isdirectory(a:spec.dir)
+    let result = s:lines(s:system('git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url', a:spec.dir))
+    let remote = result[-1]
+    if v:shell_error
+      let err = join([remote, 'PlugClean required.'], "\n")
+    elseif !s:compare_git_uri(remote, a:spec.uri)
+      let err = join(['Invalid URI: '.remote,
+                    \ 'Expected:    '.a:spec.uri,
+                    \ 'PlugClean required.'], "\n")
+    elseif a:check_branch && has_key(a:spec, 'commit')
+      let result = s:lines(s:system('git rev-parse HEAD 2>&1', a:spec.dir))
+      let sha = result[-1]
+      if v:shell_error
+        let err = join(add(result, 'PlugClean required.'), "\n")
+      elseif !s:hash_match(sha, a:spec.commit)
+        let err = join([printf('Invalid HEAD (expected: %s, actual: %s)',
+                              \ a:spec.commit[:6], sha[:6]),
+                      \ 'PlugUpdate required.'], "\n")
+      endif
+    elseif a:check_branch
+      let branch = result[0]
+      " Check tag
+      if has_key(a:spec, 'tag')
+        let tag = s:system_chomp('git describe --exact-match --tags HEAD 2>&1', a:spec.dir)
+        if a:spec.tag !=# tag && a:spec.tag !~ '\*'
+          let err = printf('Invalid tag: %s (expected: %s). Try PlugUpdate.',
+                \ (empty(tag) ? 'N/A' : tag), a:spec.tag)
+        endif
+      " Check branch
+      elseif a:spec.branch !=# branch
+        let err = printf('Invalid branch: %s (expected: %s). Try PlugUpdate.',
+              \ branch, a:spec.branch)
+      endif
+      if empty(err)
+        let [ahead, behind] = split(s:lastline(s:system(printf(
+              \ 'git rev-list --count --left-right HEAD...origin/%s',
+              \ a:spec.branch), a:spec.dir)), '\t')
+        if !v:shell_error && ahead
+          if behind
+            " Only mention PlugClean if diverged, otherwise it's likely to be
+            " pushable (and probably not that messed up).
+            let err = printf(
+                  \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n"
+                  \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', a:spec.branch, ahead, behind)
+          else
+            let err = printf("Ahead of origin/%s by %d commit(s).\n"
+                  \ .'Cannot update until local changes are pushed.',
+                  \ a:spec.branch, ahead)
+          endif
+        endif
+      endif
+    endif
+  else
+    let err = 'Not found'
+  endif
+  return [err, err =~# 'PlugClean']
+endfunction
+
+function! s:rm_rf(dir)
+  if isdirectory(a:dir)
+    call s:system((s:is_win ? 'rmdir /S /Q ' : 'rm -rf ') . s:shellesc(a:dir))
+  endif
+endfunction
+
+function! s:clean(force)
+  call s:prepare()
+  call append(0, 'Searching for invalid plugins in '.g:plug_home)
+  call append(1, '')
+
+  " List of valid directories
+  let dirs = []
+  let errs = {}
+  let [cnt, total] = [0, len(g:plugs)]
+  for [name, spec] in items(g:plugs)
+    if !s:is_managed(name)
+      call add(dirs, spec.dir)
+    else
+      let [err, clean] = s:git_validate(spec, 1)
+      if clean
+        let errs[spec.dir] = s:lines(err)[0]
+      else
+        call add(dirs, spec.dir)
+      endif
+    endif
+    let cnt += 1
+    call s:progress_bar(2, repeat('=', cnt), total)
+    normal! 2G
+    redraw
+  endfor
+
+  let allowed = {}
+  for dir in dirs
+    let allowed[s:dirpath(fnamemodify(dir, ':h:h'))] = 1
+    let allowed[dir] = 1
+    for child in s:glob_dir(dir)
+      let allowed[child] = 1
+    endfor
+  endfor
+
+  let todo = []
+  let found = sort(s:glob_dir(g:plug_home))
+  while !empty(found)
+    let f = remove(found, 0)
+    if !has_key(allowed, f) && isdirectory(f)
+      call add(todo, f)
+      call append(line('$'), '- ' . f)
+      if has_key(errs, f)
+        call append(line('$'), '    ' . errs[f])
+      endif
+      let found = filter(found, 'stridx(v:val, f) != 0')
+    end
+  endwhile
+
+  4
+  redraw
+  if empty(todo)
+    call append(line('$'), 'Already clean.')
+  else
+    let s:clean_count = 0
+    call append(3, ['Directories to delete:', ''])
+    redraw!
+    if a:force || s:ask_no_interrupt('Delete all directories?')
+      call s:delete([6, line('$')], 1)
+    else
+      call setline(4, 'Cancelled.')
+      nnoremap <silent> <buffer> d :set opfunc=<sid>delete_op<cr>g@
+      nmap     <silent> <buffer> dd d_
+      xnoremap <silent> <buffer> d :<c-u>call <sid>delete_op(visualmode(), 1)<cr>
+      echo 'Delete the lines (d{motion}) to delete the corresponding directories'
+    endif
+  endif
+  4
+  setlocal nomodifiable
+endfunction
+
+function! s:delete_op(type, ...)
+  call s:delete(a:0 ? [line("'<"), line("'>")] : [line("'["), line("']")], 0)
+endfunction
+
+function! s:delete(range, force)
+  let [l1, l2] = a:range
+  let force = a:force
+  while l1 <= l2
+    let line = getline(l1)
+    if line =~ '^- ' && isdirectory(line[2:])
+      execute l1
+      redraw!
+      let answer = force ? 1 : s:ask('Delete '.line[2:].'?', 1)
+      let force = force || answer > 1
+      if answer
+        call s:rm_rf(line[2:])
+        setlocal modifiable
+        call setline(l1, '~'.line[1:])
+        let s:clean_count += 1
+        call setline(4, printf('Removed %d directories.', s:clean_count))
+        setlocal nomodifiable
+      endif
+    endif
+    let l1 += 1
+  endwhile
+endfunction
+
+function! s:upgrade()
+  echo 'Downloading the latest version of vim-plug'
+  redraw
+  let tmp = tempname()
+  let new = tmp . '/plug.vim'
+
+  try
+    let out = s:system(printf('git clone --depth 1 %s %s', s:plug_src, tmp))
+    if v:shell_error
+      return s:err('Error upgrading vim-plug: '. out)
+    endif
+
+    if readfile(s:me) ==# readfile(new)
+      echo 'vim-plug is already up-to-date'
+      return 0
+    else
+      call rename(s:me, s:me . '.old')
+      call rename(new, s:me)
+      unlet g:loaded_plug
+      echo 'vim-plug has been upgraded'
+      return 1
+    endif
+  finally
+    silent! call s:rm_rf(tmp)
+  endtry
+endfunction
+
+function! s:upgrade_specs()
+  for spec in values(g:plugs)
+    let spec.frozen = get(spec, 'frozen', 0)
+  endfor
+endfunction
+
+function! s:status()
+  call s:prepare()
+  call append(0, 'Checking plugins')
+  call append(1, '')
+
+  let ecnt = 0
+  let unloaded = 0
+  let [cnt, total] = [0, len(g:plugs)]
+  for [name, spec] in items(g:plugs)
+    let is_dir = isdirectory(spec.dir)
+    if has_key(spec, 'uri')
+      if is_dir
+        let [err, _] = s:git_validate(spec, 1)
+        let [valid, msg] = [empty(err), empty(err) ? 'OK' : err]
+      else
+        let [valid, msg] = [0, 'Not found. Try PlugInstall.']
+      endif
+    else
+      if is_dir
+        let [valid, msg] = [1, 'OK']
+      else
+        let [valid, msg] = [0, 'Not found.']
+      endif
+    endif
+    let cnt += 1
+    let ecnt += !valid
+    " `s:loaded` entry can be missing if PlugUpgraded
+    if is_dir && get(s:loaded, name, -1) == 0
+      let unloaded = 1
+      let msg .= ' (not loaded)'
+    endif
+    call s:progress_bar(2, repeat('=', cnt), total)
+    call append(3, s:format_message(valid ? '-' : 'x', name, msg))
+    normal! 2G
+    redraw
+  endfor
+  call setline(1, 'Finished. '.ecnt.' error(s).')
+  normal! gg
+  setlocal nomodifiable
+  if unloaded
+    echo "Press 'L' on each line to load plugin, or 'U' to update"
+    nnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
+    xnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
+  end
+endfunction
+
+function! s:extract_name(str, prefix, suffix)
+  return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$')
+endfunction
+
+function! s:status_load(lnum)
+  let line = getline(a:lnum)
+  let name = s:extract_name(line, '-', '(not loaded)')
+  if !empty(name)
+    call plug#load(name)
+    setlocal modifiable
+    call setline(a:lnum, substitute(line, ' (not loaded)$', '', ''))
+    setlocal nomodifiable
+  endif
+endfunction
+
+function! s:status_update() range
+  let lines = getline(a:firstline, a:lastline)
+  let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)')
+  if !empty(names)
+    echo
+    execute 'PlugUpdate' join(names)
+  endif
+endfunction
+
+function! s:is_preview_window_open()
+  silent! wincmd P
+  if &previewwindow
+    wincmd p
+    return 1
+  endif
+endfunction
+
+function! s:find_name(lnum)
+  for lnum in reverse(range(1, a:lnum))
+    let line = getline(lnum)
+    if empty(line)
+      return ''
+    endif
+    let name = s:extract_name(line, '-', '')
+    if !empty(name)
+      return name
+    endif
+  endfor
+  return ''
+endfunction
+
+function! s:preview_commit()
+  if b:plug_preview < 0
+    let b:plug_preview = !s:is_preview_window_open()
+  endif
+
+  let sha = matchstr(getline('.'), '^  \X*\zs[0-9a-f]\{7,9}')
+  if empty(sha)
+    return
+  endif
+
+  let name = s:find_name(line('.'))
+  if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir)
+    return
+  endif
+
+  if exists('g:plug_pwindow') && !s:is_preview_window_open()
+    execute g:plug_pwindow
+    execute 'e' sha
+  else
+    execute 'pedit' sha
+    wincmd P
+  endif
+  setlocal previewwindow filetype=git buftype=nofile nobuflisted modifiable
+  try
+    let [sh, shellcmdflag, shrd] = s:chsh(1)
+    let cmd = 'cd '.s:shellesc(g:plugs[name].dir).' && git show --no-color --pretty=medium '.sha
+    if s:is_win
+      let batchfile = tempname().'.bat'
+      call writefile(['@echo off', cmd], batchfile)
+      let cmd = batchfile
+    endif
+    execute 'silent %!' cmd
+  finally
+    let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
+    if s:is_win
+      call delete(batchfile)
+    endif
+  endtry
+  setlocal nomodifiable
+  nnoremap <silent> <buffer> q :q<cr>
+  wincmd p
+endfunction
+
+function! s:section(flags)
+  call search('\(^[x-] \)\@<=[^:]\+:', a:flags)
+endfunction
+
+function! s:format_git_log(line)
+  let indent = '  '
+  let tokens = split(a:line, nr2char(1))
+  if len(tokens) != 5
+    return indent.substitute(a:line, '\s*$', '', '')
+  endif
+  let [graph, sha, refs, subject, date] = tokens
+  let tag = matchstr(refs, 'tag: [^,)]\+')
+  let tag = empty(tag) ? ' ' : ' ('.tag.') '
+  return printf('%s%s%s%s%s (%s)', indent, graph, sha, tag, subject, date)
+endfunction
+
+function! s:append_ul(lnum, text)
+  call append(a:lnum, ['', a:text, repeat('-', len(a:text))])
+endfunction
+
+function! s:diff()
+  call s:prepare()
+  call append(0, ['Collecting changes ...', ''])
+  let cnts = [0, 0]
+  let bar = ''
+  let total = filter(copy(g:plugs), 's:is_managed(v:key) && isdirectory(v:val.dir)')
+  call s:progress_bar(2, bar, len(total))
+  for origin in [1, 0]
+    let plugs = reverse(sort(items(filter(copy(total), (origin ? '' : '!').'(has_key(v:val, "commit") || has_key(v:val, "tag"))'))))
+    if empty(plugs)
+      continue
+    endif
+    call s:append_ul(2, origin ? 'Pending updates:' : 'Last update:')
+    for [k, v] in plugs
+      let range = origin ? '..origin/'.v.branch : 'HEAD@{1}..'
+      let diff = s:system_chomp('git log --graph --color=never '.join(map(['--pretty=format:%x01%h%x01%d%x01%s%x01%cr', range], 's:shellesc(v:val)')), v.dir)
+      if !empty(diff)
+        let ref = has_key(v, 'tag') ? (' (tag: '.v.tag.')') : has_key(v, 'commit') ? (' '.v.commit) : ''
+        call append(5, extend(['', '- '.k.':'.ref], map(s:lines(diff), 's:format_git_log(v:val)')))
+        let cnts[origin] += 1
+      endif
+      let bar .= '='
+      call s:progress_bar(2, bar, len(total))
+      normal! 2G
+      redraw
+    endfor
+    if !cnts[origin]
+      call append(5, ['', 'N/A'])
+    endif
+  endfor
+  call setline(1, printf('%d plugin(s) updated.', cnts[0])
+        \ . (cnts[1] ? printf(' %d plugin(s) have pending updates.', cnts[1]) : ''))
+
+  if cnts[0] || cnts[1]
+    nnoremap <silent> <buffer> <cr> :silent! call <SID>preview_commit()<cr>
+    nnoremap <silent> <buffer> o    :silent! call <SID>preview_commit()<cr>
+  endif
+  if cnts[0]
+    nnoremap <silent> <buffer> X :call <SID>revert()<cr>
+    echo "Press 'X' on each block to revert the update"
+  endif
+  normal! gg
+  setlocal nomodifiable
+endfunction
+
+function! s:revert()
+  if search('^Pending updates', 'bnW')
+    return
+  endif
+
+  let name = s:find_name(line('.'))
+  if empty(name) || !has_key(g:plugs, name) ||
+    \ input(printf('Revert the update of %s? (y/N) ', name)) !~? '^y'
+    return
+  endif
+
+  call s:system('git reset --hard HEAD@{1} && git checkout '.s:esc(g:plugs[name].branch).' --', g:plugs[name].dir)
+  setlocal modifiable
+  normal! "_dap
+  setlocal nomodifiable
+  echo 'Reverted'
+endfunction
+
+function! s:snapshot(force, ...) abort
+  call s:prepare()
+  setf vim
+  call append(0, ['" Generated by vim-plug',
+                \ '" '.strftime("%c"),
+                \ '" :source this file in vim to restore the snapshot',
+                \ '" or execute: vim -S snapshot.vim',
+                \ '', '', 'PlugUpdate!'])
+  1
+  let anchor = line('$') - 3
+  let names = sort(keys(filter(copy(g:plugs),
+        \'has_key(v:val, "uri") && !has_key(v:val, "commit") && isdirectory(v:val.dir)')))
+  for name in reverse(names)
+    let sha = s:system_chomp('git rev-parse --short HEAD', g:plugs[name].dir)
+    if !empty(sha)
+      call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha))
+      redraw
+    endif
+  endfor
+
+  if a:0 > 0
+    let fn = expand(a:1)
+    if filereadable(fn) && !(a:force || s:ask(a:1.' already exists. Overwrite?'))
+      return
+    endif
+    call writefile(getline(1, '$'), fn)
+    echo 'Saved as '.a:1
+    silent execute 'e' s:esc(fn)
+    setf vim
+  endif
+endfunction
+
+function! s:split_rtp()
+  return split(&rtp, '\\\@<!,')
+endfunction
+
+let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, ''))
+let s:last_rtp  = s:escrtp(get(s:split_rtp(), -1, ''))
+
+if exists('g:plugs')
+  let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs))
+  call s:upgrade_specs()
+  call s:define_commands()
+endif
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

.vim/dictionary/tex

+a4paper
+a5paper
+aa
+AA
+abbrv
+abovedisplayshortskip
+abovedisplayskip
+abstract
+abstractname
+acute
+addcontentsline
+address
+addtime
+addtocontents
+addtocounter
+addtolength
+addvspace
+ae
+AE
+aleph
+align
+alph
+Alph
+alpha
+amalg
+amsmath
+amsthm
+and
+angle
+Ankh
+appendix
+appendixname
+approx
+approxeq
+aquarius
+Aquarius
+arabic
+aries
+Aries
+array
+arraycolsep
+arrayrulewidth
+arraystretch
+article
+ascnode
+ast
+astrosun
+asymp
+ataribox
+author
+b5paper
+backepsilon
+backmatter
+backprime
+backsim
+backsimeq
+backslash
+bar
+barwedge
+baselineskip
+baselinestretch
+Bat
+batchmode
+Bbbk
+because
+begin
+bell
+belowdisplayshortskip
+belowdisplayskip
+beta
+between
+bezier
+bf
+bfseries
+bibindent
+bibitem
+bibliography
+bibliographystyle
+bibname
+big
+Big
+bigcap
+bigcirc
+bigcup
+bigg
+Bigg
+biggl
+Biggl
+biggm
+Biggm
+biggr
+Biggr
+bigl
+Bigl
+bigm
+Bigm
+bigodot
+bigoplus
+bigotimes
+bigr
+Bigr
+bigskip
+bigskipamount
+bigsqcup
+bigstar
+bigtriangledown
+bigtriangleup
+biguplus
+bigvee
+bigwedge
+binom
+blacklozenge
+blacksmiley
+blacksquare
+blacktriangle
+blacktriangledown
+blacktriangleleft
+blacktriangleright
+blg
+boldmath
+boldsymbol
+book
+bot
+botfigrule
+bottmofraction
+bottomnumber
+Bouquet
+bowtie
+Bowtie
+Box
+boxdot
+boxedminipage
+boxminus
+boxplus
+boxtimes
+bp
+breve
+brokenvert
+bullet
+bumpeq
+Bumpeq
+calc
+cancer
+Cancer
+cap
+Cap
+Capricorn
+capricornus
+caption
+caption2
+capt-of
+cases
+cc
+ccaption
+ccname
+cdot
+cdotp
+cdots
+cdotscenter
+celsius
+Celtcross
+cent
+centerdot
+centering
+cercle
+cfrac
+changebar
+chapter
+chapterbib
+chaptername
+check
+checked
+checkmark
+chi
+circ
+circeq
+circlearrowleft
+circlearrowright
+CircledA
+circledast
+circledcirc
+circleddash
+circledR
+circledS
+cite
+cleardoublepage
+clearpage
+cline
+clock
+closing
+clubsuit
+cm
+colon
+COLON
+columnsep
+columnseprule
+columnwidth
+complement
+cong
+conjunction
+contentsline
+contentsname
+coprod
+copyright
+Cross
+cup
+Cup
+curlyeqprec
+curlyeqsucc
+curlyvee
+curlywedge
+currency
+curvearrowleft
+curvearrowright
+dag
+dagger
+dashbox
+dashleftarrow
+dashrightarrow
+dashv
+date
+dbinom
+dblfigure
+dblfloatpage
+dblfloatsep
+dbltextfloatsep
+dbltopfraction
+dbltopnumber
+dcolumn
+dd
+ddag
+ddagger
+ddot
+ddots
+DeclareMathOperator
+degree
+delta
+Delta
+Denarius
+depth
+descnode
+description
+dfrac
+dh
+DH
+diagdown
+diagup
+diameter
+diamond
+Diamond
+diamondsuit
+digamma
+displaylimits
+displaymath
+displaystyle
+div
+divideontimes
+dj
+DJ
+document
+documentclass
+dot
+doteq
+doteqdot
+dotfill
+dotplus
+dots
+dotsb
+dotsc
+dotsi
+dotsint
+dotsm
+dotso
+doublebarwedge
+doublerulesep
+downarrow
+Downarrow
+DOWNarrow
+downbracefill
+downdownarrows
+downharpoonleft
+downharpoonright
+draft
+dropping
+dywiz
+earth
+Earth
+Ecommerce
+ell
+em
+Email
+Emailct
+emph
+empty
+emptyset
+encl
+enclname
+end
+endfloat
+enlargethispage
+enskip
+enspace
+ensuremath
+enumerate
+enumi
+enumii
+enumiii
+enumiv
+epsilon
+eqcirc
+eqnarray
+eqslantgtr
+eqslantless
+equation
+equiv
+errorstopmode
+eta
+eth
+eucal
+eufrak
+EUR
+EURcr
+EURdig
+EURhv
+EURtm
+evensidemargin
+everyship
+ex
+executivepaper
+exists
+expdlist
+extracolsep
+extramark
+EyesDollar
+fallingdotseq
+fancybox
+fancyhdr
+fax
+FAX
+Faxmachine
+fbox
+fboxrule
+fboxsep
+female
+FHBOlogo
+FHBOLOGO
+figure
+figurename
+file
+filecontents
+final
+fint
+Finv
+flafter
+flat
+fleqn
+floatflt
+floatpagefraction
+floatsep
+flushbottom
+flushleft
+flushright
+fn2end
+fnpara
+fnsymbol
+fontenc
+footheight
+footmisc
+footnote
+footnotemark
+footnoterule
+footnotesep
+footnotesize
+footnotetext
+footnpag
+footskip
+forall
+frac
+frame
+framebox
+frenchspacing
+frontmatter
+frown
+frownie
+Frowny
+ftnright
+FullFHBO
+fullmoon
+fussy
+Game
+gamma
+Gamma
+gather
+gemini
+Gemini
+genfrac
+geometry
+geq
+geqq
+geqslant
+gg
+ggg
+glossary
+glossaryentry
+gnapprox
+gneq
+gneqq
+gnsim
+graphicx
+graphpaper
+grave
+gtrapprox
+gtrdot
+gtreqless
+gtreqqless
+gtrless
+gtrsim
+guillemotleft
+guillemotright
+guilsinglleft
+guilsinglright
+gvertneqq
+hat
+hbar
+hbox
+headheihgt
+headings
+headsep
+Heart
+heartsuit
+height
+helvet
+hfill
+hhline
+hline
+hookleftarrow
+hookrightarrow
+hrulefill
+hslash
+hspace
+huge
+Huge
+HUGE
+hyperref
+hyphenation
+iddots
+idotsint
+ifthen
+iiiint
+iiint
+iint
+Im
+imath
+in
+include
+includeonly
+indent
+indentfirst
+index
+indexentry
+indexname
+indexspace
+infty
+inplus
+input
+inputenc
+int
+intercal
+intertext
+intextsep
+invdiameter
+invisible
+iota
+it
+item
+itemindent
+itemize
+itemsep
+itshape
+jmath
+Join
+jot
+jupiter
+Jupiter
+kappa
+kill
+kreuz
+label
+labelenumi
+labelenumii
+labelenumiii
+labelenumiv
+labelitemi
+labelitemii
+labelitemiii
+labelitemiv
+labelsep
+labelwidth
+lambda
+Lambda
+landdownint
+landscape
+landupint
+langle
+large
+Large
+LARGE
+LaTeX
+LaTeXe
+latexsym
+lbag
+Lbag
+lceil
+ldotp
+ldots
+leadsto
+left
+leftarrow
+Leftarrow
+LEFTarrow
+leftarrowfill
+leftarrowtail
+leftarrowtriangle
+lefteqn
+leftharpoondown
+leftharpoonup
+leftleftarrows
+leftmargin
+leftmargini
+leftmarginii
+leftmarginiii
+leftmarginiv
+leftmarginv
+leftmarginvi
+leftmark
+leftmoon
+leftrightarrow
+Leftrightarrow
+leftrightarroweq
+leftrightarrows
+leftrightarrowtriangle
+leftrightharpoons
+leftrightsquigarrow
+leftthreetimes
+legalpaper
+leo
+Leo
+leq
+leqno
+leqq
+leqslant
+lessapprox
+lessdot
+lesseqgtr
+lesseqqgtr
+lessgtr
+lesssim
+letter
+Letter
+letterpaper
+letterspace
+lfloor
+lhd
+LHD
+lhead
+libra
+Libra
+lightning
+Lightning
+limits
+line
+linebreak
+linethickness
+linewidth
+list
+listfigurename
+listfiles
+listoffigures
+listoftables
+listparindent
+ll
+llbracket
+llceil
+Lleftarrow
+llfloor
+lll
+llparenthesis
+lnapprox
+lneq
+lneqq
+lnsim
+location
+longleftarrow
+Longleftarrow
+longleftrightarrow
+Longleftrightarrow
+longmapsfrom
+Longmapsfrom
+longmapsto
+Longmapsto
+longrightarrow
+Longrightarrow
+longtable
+looparrowleft
+looparrowright
+lozenge
+lq
+lrbox
+lscape
+Lsh
+ltimes
+lvertneqq
+mainmatter
+makeatletter
+makeatother
+makebox
+makeglossary
+makeidx
+makeindex
+makelabel
+maketitle
+male
+maltese
+manyfoot
+mapsfrom
+Mapsfrom
+mapsto
+Mapsto
+marginpar
+marginparpush
+marginparsep
+marginparwidth
+markboth
+markleft
+markright
+mars
+Mars
+MartinVogel
+math
+mathbb
+mathbf
+mathbin
+mathcal
+mathclose
+mathdollar
+mathds
+mathellipsis
+mathfrak
+mathindent
+mathit
+mathnormal
+mathop
+mathopen
+mathord
+mathparagraph
+mathpunct
+mathrel
+mathrm
+mathscr
+mathsection
+mathsf
+mathsterling
+mathstrut
+mathtt
+mathunderscore
+mathversion
+mbox
+mdseries
+measuredangle
+medmuskip
+medskip
+medskipamount
+mercury
+Mercury
+mho
+micro
+mid
+minipage
+minitoc
+minus
+mkern
+mm
+Mobilefone
+models
+Moon
+moreverbatim
+mp
+mpfootnote
+mu
+multicol
+multicolumn
+multilanguage
+multimap
+multiput
+multirow
+Mundus
+MVAt
+MVRightarrow
+myheadings
+nabla
+name
+natural
+ncong
+nearrow
+NeedsTeXFormat
+neg
+neptune
+Neptune
+neq
+newcommand
+newcounter
+newenvironment
+newfont
+newlength
+newline
+newmoon
+newpage
+newsavebox
+newtheorem
+nexists
+ng
+NG
+ngeq
+ngeqq
+ngeqslant
+ngtr
+ni
+niplus
+nleftarrow
+nLeftarrow
+nleftrightarrow
+nLeftrightarrow
+nleq
+nleqq
+nleqslant
+nless
+nmid
+nnearrow
+nnwarrow
+nocite
+nofiles
+noindent
+nolimits
+nolinebreak
+nomathsymbols
+nonfrenchspacing
+nonumber
+nopagebreak
+normalfont
+normalsize
+not
+notag
+note
+notin
+notitlepage
+nparallel
+nprec
+npreceq
+nrightarrow
+nRightarrow
+nshortmid
+nshortparallel
+nsim
+nsubseteq
+nsucc
+nsucceq
+nsupseteq
+nsupseteqq
+ntriangleleft
+ntrianglelefteq
+ntriangleright
+ntrianglerighteq
+nu
+numberline
+numline
+numprint
+nvdash
+nvDash
+nVDash
+nwarrow
+ocircle
+oddsidemargin
+odot
+oe
+OE
+ohm
+ohorn
+OHORN
+oiint
+oint
+ointclockwise
+ointctrclockwise
+oldstyle
+omega
+Omega
+ominus
+onecolumn
+oneside
+onlynotes
+onlyslides
+openany
+openbib
+opening
+openright
+operatorname
+oplus
+opposition
+oslash
+otimes
+oval
+overbrace
+overlay
+overleftarrow
+overline
+overrightarrow
+page
+pagebreak
+pagenumbering
+pageref
+pagestyle
+paperheight
+paperwidth
+par
+paragraph
+parallel
+parbox
+parindent
+parr
+parsep
+parskip
+part
+partial
+partname
+partopsep
+pauza
+pc
+permil
+perp
+perthousand
+Pfund
+phi
+Phi
+phone
+pi
+Pi
+Pickup
+picture
+pisces
+Pisces
+pitchfork
+plain
+PLdateending
+plmath
+PLSlash
+plus
+pluto
+Pluto
+pm
+pmb
+pmod
+pointer
+polski
+poptabs
+pounds
+ppauza
+prec
+precapprox
+preccurlyeq
+preceq
+precnapprox
+precnsim
+precsim
+prefixing
+prime
+printindex
+prod
+propto
+protect
+providecommand
+ps
+psi
+Psi
+pt
+pushtabs
+put
+qbezier
+qbeziermax
+qquad
+quad
+quotation
+quote
+quotedblbase
+quotesinglbase
+ragged2e
+raggedbottom
+raggedleft
+raggedright
+raisebox
+rangle
+ratio
+rbag
+Rbag
+rceil
+Re
+real
+recorder
+ref
+refname
+refstepcounter
+relsize
+renewcommand
+renewenvironment
+report
+reversemarginpar
+rfloor
+rhd
+RHD
+rhead
+rho
+right
+rightarrow
+Rightarrow
+RIGHTarrow
+rightarrowfill
+rightarrowtail
+rightarrowtriangle
+rightharpoondown
+rightharpoonup
+rightleftarrows
+rightleftharpoons
+rightmargin
+rightmark
+rightmoon
+rightrightarrows
+rightsquigarrow
+rightthreetimes
+risingdotseq
+rm
+rmfamily
+roman
+Roman
+rotate
+rotating
+rq
+rrbracket
+rrceil
+rrfloor
+Rrightarrow
+rrparenthesis
+Rsh
+rtimes
+rule
+sagittarius
+Sagittarius
+samepage
+saturn
+Saturn
+savebox
+sb
+sbox
+sc
+scorpio
+Scorpio
+scriptscriptstyle
+scriptsize
+scriptstyle
+scrollmode
+scshape
+searrow
+secnumdepth
+section
+sectionmark
+see
+seename
+selectfont
+selectlanguage
+setcounter
+setlength
+setminus
+settime
+settodepth
+settoheight
+settowidth
+sf
+sffamily
+shadethm
+shadow
+shapepar
+sharp
+Shilling
+shortdownarrow
+shortleftarrow
+shortmid
+shortparallel
+shortrightarrow
+shortstack
+shortuparrow
+showlabels
+sidecap
+sigma
+Sigma
+signature
+sim
+simeq
+sin
+skull
+sl
+slide
+slides
+sloppy
+sloppybar
+slshape
+small
+smallfrown
+smallsetminus
+smallskip
+smallskipamount
+smallsmile
+smile
+smiley
+Smiley
+soul
+sp
+space
+spadesuit
+sphericalangle
+sqcap
+sqcup
+sqiint
+sqint
+sqrt
+sqsubset
+sqsubseteq
+sqsupset
+sqsupseteq
+square
+ss
+SS
+ssearrow
+sswarrow
+stackrel
+star
+startbreaks
+stepcounter
+stop
+stopbreaks
+stretch
+strut
+subfigure
+subitem
+subparagraph
+subsection
+subset
+Subset
+subseteq
+subseteqq
+subsetneq
+subsetneqq
+subsubitem
+subsubsection
+succ
+succapprox
+succcurlyeq
+succeq
+succnapprox
+succnsim
+succsim
+sum
+sun
+Sun
+supressfloats
+supset
+Supset
+supseteq
+supseteqq
+supsetneq
+supsetneqq
+surd
+swarrow
+symbol
+tabbing
+tabcolsep
+table
+tablename
+tableofcontents
+tabular
+tabularx
+tag
+tan
+tau
+taurus
+Taurus
+tbinom
+Telefon
+telephone
+TeX
+textaolig
+textasciicircum
+textasciitilde
+textasteriskcentered
+textbabygamma
+textbackslash
+textbaht
+textbar
+textbarb
+textbarc
+textbard
+textbardbl
+textbardotlessj
+textbarg
+textbarglotstop
+textbari
+textbarl
+textbaro
+textbarrevglotstop
+textbaru
+textbeltl
+textbenttailyogh
+textbeta
+textbf
+textbigcircle
+textbktailgamma
+textblank
+textbraceleft
+textbraceright
+textbrokenbar
+textbullet
+textbullseye
+textceltpal
+textcent
+textcentoldstyle
+textchi
+textcircled
+textcircledP
+textcloseepsilon
+textcloseomega
+textcloserevepsilon
+textcolonmonetary
+textcommatailz
+textcompwordmark
+textcopyleft
+textcopyright
+textcorner
+textcrb
+textcrd
+textcrg
+textcrh
+textcrinvglotstop
+textcrlambda
+textcrtwo
+textctc
+textctd
+textctdctzlig
+textctesh
+textctinvglotstop
+textctj
+textctjvar
+textctn
+textctstretchc
+textctstretchcvar
+textctt
+textcttctclig
+textctturnt
+textctyogh
+textctz
+textcurrency
+textdagger
+textdaggerdbl
+textdblhyphen
+textdblhyphenchar
+textdblig
+textdctzlig
+textdegree
+textdiscount
+textdiv
+textdollar
+textdollaroldstyle
+textdong
+textdoublebaresh
+textdoublebarpipe
+textdoublebarpipevar
+textdoublebarslash
+textdoublepipe
+textdoublepipevar
+textdoublevertline
+textdownarrow
+textdownfullarrow
+textdownstep
+textdyoghlig
+textdzlig
+textellipsis
+textemdash
+textendash
+textepsilon
+textesh
+textestimated
+texteuro
+textexclamdown
+textfemale
+textfishhookr
+textfloatsep
+textflorin
+textfraction
+textfractionsolidus
+textfrbarn
+textfrhookd
+textfrhookdvar
+textfrhookt
+textfrtailgamma
+textg
+textgamma
+textglobfall
+textglobrise
+textglotstop
+textglotstopvari
+textglotstopvarii
+textglotstopvariii
+textgreater
+textgrgamma
+textguarani
+texthalflength
+texthardsign
+textheight
+textheng
+texthmlig
+texthooktop
+texthtb
+texthtbardotlessj
+texthtbardotlessjvar
+texthtc
+texthtd
+texthtg
+texthth
+texththeng
+texthtk
+texthtp
+texthtq
+texthtrtaild
+texthtscg
+texthtt
+texthvlig
+textinterrobang
+textinterrobangdown
+textinvglotstop
+textinvomega
+textinvsca
+textinvscr
+textinvscripta
+textiota
+textit
+textlambda
+textlangle
+textlbrackdbl
+textleftarrow
+textlengthmark
+textless
+textlfishhookrlig
+textlhookfour
+textlhookp
+textlhookt
+textlhti
+textlhtlongi
+textlhtlongy
+textlira
+textlnot
+textlonglegr
+textlooptoprevesh
+textlptr
+textlquill
+textltailm
+textltailn
+textltilde
+textlyoghlig
+textmd
+textminus
+textmusicalnote
+textnaira
+textnormal
+textnrleg
+textnumero
+textObardotlessj
+textObullseye
+textOlyoghlig
+textomega
+textonehalf
+textonequarter
+textonesuperior
+textopenbullet
+textopencorner
+textopeno
+textordfeminine
+textordmasculine
+textpalhook
+textpalhooklong
+textpalhookvar
+textparagraph
+textperiodcenter
+textperiodcentered
+textpertenthousand
+textperthousand
+textpeso
+textphi
+textpilcrow
+textpipe
+textpipevar
+textpm
+textprimstress
+textqplig
+textquestiondown
+textquotedbl
+textquotedblleft
+textquotedblright
+textquoteleft
+textquoteright
+textquotesingle
+textquotestraightbase
+textquotestraightdblbase
+textraiseglotstop
+textraisevibyi
+textramshorns
+textrangle
+textrbrackdbl
+textrecipe
+textrectangle
+textreferencemark
+textregistered
+textretractingvar
+textrevapostrophe
+textreve
+textrevepsilon
+textrevglotstop
+textrevscl
+textrevscr
+textrevyogh
+textrhooka
+textrhooke
+textrhookepsilon
+textrhookopeno
+textrhookrevepsilon
+textrhookschwa
+textrhoticity
+textrightarrow
+textrm
+textrptr
+textrquill
+textrtaild
+textrtailhth
+textrtaill
+textrtailn
+textrtailr
+textrtails
+textrtailt
+textrtailz
+textrthook
+textrthooklong
+textsc
+textsca
+textscaolig
+textscb
+textscdelta
+textsce
+textscf
+textscg
+textsch
+textschwa
+textsci
+textscj
+textsck
+textscl
+textscm
+textscn
+textscoelig
+textscomega
+textscp
+textscq
+textscr
+textscripta
+textscriptg
+textscriptv
+textscu
+textscy
+textsecstress
+textsection
+textservicemark
+textsf
+textsl
+textsoftsign
+textspleftarrow
+textsterling
+textstretchc
+textstretchcvar
+textstyle
+textsubdoublearrow
+textsubrightarrow
+textsuperscript
+textsurd
+texttctclig
+textteshlig
+texttheta
+textthorn
+textthornvari
+textthornvarii
+textthornvariii
+textthornvariv
+textthreequarters
+textthreequartersemdash
+textthreesuperior
+texttildelow
+texttimes
+texttoneletterstem
+texttrademark
+texttslig
+texttt
+textturna
+textturncelig
+textturnglotstop
+textturnh
+textturnk
+textturnlonglegr
+textturnm
+textturnmrleg
+textturnr
+textturnrrtail
+textturnsck
+textturnscripta
+textturnscu
+textturnt
+textturnthree
+textturntwo
+textturnv
+textturnw
+textturny
+texttwelveudash
+texttwosuperior
+textuncrfemale
+textunderscore
+textup
+textuparrow
+textupfullarrow
+textupsilon
+textupstep
+textvertline
+textvibyi
+textvibyy
+textvisiblespace
+textwidth
+textwon
+textwynn
+textyen
+textyogh
+tfrac
+th
+TH
+thanks
+the
+thebibliography
+theindex
+theorem
+thepage
+therefore
+thesection
+theta
+Theta
+thickapprox
+thicklines
+thickmuskip
+thicksim
+thinlines
+thispagestyle
+threeparttable
+tilde
+time
+times
+tiny
+title
+titlepage
+tocdepth
+today
+top
+topfigrule
+topfraction
+topmargin
+topsep
+topskip
+totalheight
+totalnumber
+triangle
+triangledown
+triangleleft
+trianglelefteq
+triangleq
+triangleright
+trianglerighteq
+trivlist
+tt
+ttfamily
+twocolumn
+twoheadleftarrow
+twoheadrightarrow
+twoside
+typein
+typeout
+uhorn
+UHORN
+ulem
+unboldmath
+underbrace
+underline
+unlhd
+unrhd
+unsort
+unsrt
+upalpha
+uparrow
+Uparrow
+UParrow
+upbeta
+upbracefill
+upchi
+updelta
+Updelta
+updownarrow
+Updownarrow
+upepsilon
+upeta
+upgamma
+Upgamma
+upharpoonleft
+upharpoonright
+upiota
+upkappa
+uplambda
+Uplambda
+uplus
+upmu
+upnu
+upomega
+Upomega
+upphi
+Upphi
+uppi
+Uppi
+uppsi
+Uppsi
+uprho
+upshape
+upsigma
+Upsigma
+upsilon
+Upsilon
+uptau
+uptheta
+Uptheta
+upuparrows
+upupsilon
+Upupsilon
+upvarepsilon
+upvarphi
+upvarpi
+upvarrho
+upvarsigma
+upvartheta
+upxi
+Upxi
+upzeta
+uranus
+Uranus
+usebox
+usecounter
+usefont
+usepackage
+value
+varepsilon
+varkappa
+varnothing
+varoiint
+varointclockwise
+varointctrclockwise
+varphi
+varpi
+varpropto
+varrho
+varsigma
+varsubsetneq
+varsubsetneqq
+varsupsetneq
+varsupsetneqq
+vartheta
+vartriangle
+vartriangleleft
+vartriangleright
+vbox
+vdash
+vDash
+Vdash
+vdots
+vec
+vector
+vee
+veebar
+venus
+Venus
+verb
+verbatim
+vernal
+verse
+vfill
+virgo
+Virgo
+visible
+vline
+vmargin
+voffset
+vspace
+Vvdash
+wasylozenge
+wedge
+widehat
+widetilde
+width
+with
+Womanface
+wp
+wr
+wrapfig
+xi
+Xi
+xleftarrow
+xrightarrow
+Yinyang
+zeta

.vim/ftdetect/mine.vim

+autocmd BufNewFile,BufRead *.pro set filetype=prolog
+autocmd BufNewFile,BufRead *.md set filetype=markdown
+autocmd BufNewFile,BufRead */debian/rules.d/* set filetype=make

.vim/ftplugin/gitcommit.vim

+setlocal spell textwidth=72

.vim/ftplugin/go.vim

+let g:go_highlight_functions = 1
+let g:go_highlight_methods = 1
+let g:go_highlight_structs = 1
+let g:go_highlight_operators = 1
+let g:go_highlight_build_constraints = 1
+
+let g:go_auto_type_info = 1
+
+let g:go_fmt_command = "goimports"
+
+let g:tagbar_type_go = {
+    \ 'ctagstype' : 'go',
+    \ 'kinds'     : [
+        \ 'p:package',
+        \ 'i:imports:1',
+        \ 'c:constants',
+        \ 'v:variables',
+        \ 't:types',
+        \ 'n:interfaces',
+        \ 'w:fields',
+        \ 'e:embedded',
+        \ 'm:methods',
+        \ 'r:constructor',
+        \ 'f:functions'
+    \ ],
+    \ 'sro' : '.',
+    \ 'kind2scope' : {
+        \ 't' : 'ctype',
+        \ 'n' : 'ntype'
+    \ },
+    \ 'scope2kind' : {
+        \ 'ctype' : 't',
+        \ 'ntype' : 'n'
+    \ },
+    \ 'ctagsbin'  : 'gotags',
+    \ 'ctagsargs' : '-sort -silent'
+\ }
+
+nnoremap <buffer> <leader>r :GoRun<cr>
+nnoremap <buffer> <leader>pc :pc<cr>
+nnoremap <buffer> <leader>d :GoRun % --debug<cr>
+nnoremap <buffer> <leader>t :GoTest -v -cpu=8<cr>
+
+set completeopt-=longest
+set completeopt-=preview
+let g:echodoc_enable_at_startup = 1
+"let g:syntastic_go_checkers = ['golint', 'govet', 'errcheck']
+"let g:syntastic_mode_map = { 'mode': 'active', 'passive_filetypes': ['go'] }

.vim/ftplugin/haskell.vim

+compiler ghc

.vim/ftplugin/markdown.vim

+setlocal colorcolumn=+1
+setlocal spell spelllang=en_gb
+
+autocmd CursorHold <buffer> update
+
+highlight ColorColumn ctermbg=grey guibg=grey
+
+inoremap 1-- <!-- section -->

.vim/ftplugin/ruby.vim

+setlocal shiftwidth=2 softtabstop=2 tabstop=2
+setlocal expandtab

.vim/ftplugin/tex.vim

+inoremap <buffer> [[ \begin{}<Esc>i
+setlocal colorcolumn=+1
+setlocal spell spelllang=en_gb
+
+autocmd CursorHold <buffer> update
+
+inoremap <buffer> $ $$<left>
+inoremap <buffer> <leader>g \gls{}<left>
+inoremap <buffer> glr \gls{rsa}
+inoremap <buffer> glg \gls{gpg}
+inoremap <buffer> glf \gls{fr}
+
+highlight ColorColumn ctermbg=grey guibg=grey
+
+"let g:vimtex_latexmk_options ='-pdflatex="xelatex -shell-escape %O %S " -pdf -dvi- -ps- -synctex=1'
+let g:vimtex_latexmk_options ='-pdf'
+"let g:LatexBox_latexmk_options = ' -xelatex '
+"let g:LatexBox_latexmk_async = 1
+"let g:LatexBox_latexmk_preview_continuously = 1
+"let g:LatexBox_quickfix = 4
+let g:vimtex_view_general_viewer = 'qpdfview'
+let g:vimtex_view_general_options = '--unique @pdf\#src:@tex:@line:@col'
+" In qpdfview, use the following for source editor:
+" gvim --remote-tab-silent +%2 %1
+let g:vimtex_view_general_options_latexmk = '--unique'

.vim/ftplugin/vim.vim

+setlocal keywordprg=:help

.vim/ftplugin/yaml.vim

+setlocal shiftwidth=2 softtabstop=2 tabstop=2
+setlocal expandtab

.vim/local/debian-pc.vim

+let g:airline#extensions#tabline#enabled = 1

.vim/local/lab-laptop.vim

+if has("gui_running")
+  if has("gui_gtk2")
+   set guifont=Ubuntu\ Mono\ derivative\ Powerline\ 13
+   set guioptions-=r
+  endif
+endif
+ 
+let g:airline_powerline_fonts = 1
+set textwidth=80

.vim/local/lab-pc.vim

+if has("gui_running")
+  if has("gui_gtk2")
+    set guifont=Ubuntu\ Mono\ for\ Powerline\ 13
+  endif
+endif
+let g:airline_powerline_fonts = 1
+if !exists('g:airline_symbols')
+  let g:airline_symbols = {}
+endif
+
+set textwidth=80

.vim/local/lab.vim

+if has("gui_running")
+  if has("gui_gtk2")
+   set guifont=Ubuntu\ Mono\ for\ Powerline\ 13
+   set guioptions-=r
+  endif
+endif
+ 
+let g:airline_powerline_fonts = 1
+set textwidth=80

.vim/local/laptop.vim

+if has("gui_running")
+	if has("gui_gtk2")
+		set guifont=Ubuntu\ Mono\ derivative\ Powerline\ 13
+		set guioptions-=r
+	endif
+endif
+let g:airline_powerline_fonts = 1
+if !exists('g:airline_symbols')
+	let g:airline_symbols = {}
+endif
+let g:airline_symbols.space = "\ua0"

.vim/local/windows.vim

+if has("gui_running")
+   set guifont=Ubuntu_Mono:h13
+   set guioptions-=r
+endif

.vim/local/work.vim

+let g:airline_powerline_fonts = 1
+if !exists('g:airline_symbols')
+	let g:airline_symbols = {}
+endif
+let g:airline_symbols.space = "\ua0"
+let g:syntastic_python_python_exec = '/usr/local/bin/python3'
+let g:ycm_python_binary_path = '/usr/local/bin/python3'

.vim/spell/en.utf-8.add

+Mohanan
+Murukesh
+qubit
+cryptosystem
+cryptosystems
+SVP
+CVP
+m
+Feynman
+qubits
+Hermite
+arity
+NTRU
+cyrptosystems
+teleportation
+Guwahati
+Karuna
+Kalita
+isospectrally
+PHP
+Chennai
+IIT
+Raman
+Bhaskar
+Bodhitree
+Menezes
+Gitlab
+LDAP
+Debian
+plugin
+Django
+playlist
+Bodhitree
+CSS
+API
+foo
+Debian
+LDAP
+Ubuntu
+Roshan
+plugin
+plugins
+PPA
+PPAs
+CLI
+hostgroup
+hostgroups
+Gooner
+Facebook
+murukesh
+mohanan
+IIT
+Firefox
+Github
+URLs
+Apache2
+subdomains
+Voronoi
+MySQL
+Kalyan
+Maharashtra
+Kerala
+Malayalam
+Alexandra
+Rhett
+Gavroche
+Daneel
+Anathem
+bullwhip
+manpage
+manpages
+filetype
+QEMU
+deduplication
+ciphertext
+ciphertexts
+filesystem
+YJLinux
+Kubernetes
+JSON
+kubernetes
+YNW
+Redis
+servergroup
+RolesDB
+CKMS
+OpenStack
+MYM
+Kanseito
+syslog
+YAML
+config
+ACL
+OpenStack
+dtests
+timestamp
+perf
+Compactions
+GC
+compactions
+timeseries
+Rakuten
+IoT
+microservices

.vim/syntax/deb.vim

+" Vim syntax file for browsing debian package.
+" copyright (C) 2007, arno renevier <arenevier@fdn.fr>
+" Distributed under the GNU General Public License (version 2 or above)
+" Last Change: 2007 December 07
+"
+" Latest version of that file can be found at
+" http://www.fdn.fr/~arenevier/vim/syntax/deb.vim
+" It should also be available at
+" http://www.vim.org/scripts/script.php?script_id=1970
+
+if exists("b:current_syntax")
+ finish
+endif
+
+syn match debComment '^".*'
+syn match debInfoFilename '^\* \.\/.*'
+syn match debDataFilename '^\.\/.*[^/]$'
+syn match debDirname '^\..*\/$'
+syn match debSymlink '^\.\/.* -> .*$' contains=debSymlinkTarget,debSymlinkArrow,debSymlinkName
+syn match debSymlinkName '^\S*' contained
+syn match debSymlinkTarget '\S*$' contained
+syn match debSymlinkArrow '->' contained
+
+hi def link debComment	Comment
+hi def link debInfoFilename Type
+hi def link debDataFilename PreProc
+hi def link debSymlinkName Identifier
+hi def link debSymlinkTarget PreProc

.vim/syntax/prolog.vim

+" Vim Syntax File
+"
+" Language:    Prolog
+" Maintainers: Aleksandar Dimitrov <aleks.dimitrov@googlemail.com>
+" Created:     Jul 31st, 2008
+" Changed:     Fri Aug  1 2008
+" Remark:      This file mostly follows
+"              http://www.sics.se/sicstus/docs/3.7.1/html/sicstus_45.html
+"              but also features some SWI-specific enhancements.
+"              The BNF cannot be followed strictly, but I tried to do my best.
+"
+" TODO:        - Difference Lists
+"              - Constraint logic programming
+
+if version < 600
+   syn clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+syntax case match
+
+syntax keyword prologISOBuiltIn   var nonvar integer float number atom string 
+			\atomic compound unify_with_occurs_check fail false true repeat call once 
+			\catch throw abolish retract asserta assertz current_predicate clause open 
+			\close stream_property set_stream_position set_input set_output current_ouput 
+			\nl put_byte put_char put_code flush_output get_byte get_code get_char 
+			\peek_byte peek_code peek_char at_end_of_stream write_term write_canonical 
+			\write writeq read read_term functor arg copy_term atom_codes atom_chars 
+			\char_code number_chars number_codes atom_length sub_atom op current_op 
+			\char_conversion current_char_conversion is mod rem div round float 
+			\float_fractional_part float_integer_part truncate floor ceiling sqrt sin cos 
+			\atan log findall bagof setof sub_atom
+
+syntax keyword prologSWIBuiltIn   rational callable ground cyclic_term subsumes subsumes_chk 
+			\unifiable use_module compare apply not ignore call_with_depth_limit call_cleanup 
+			\print_message print_message_lines message_hook on_signal current_signal block exit 
+			\term_hash redefine_system_predicate retractall assert recorda recordz recorded 
+			\erase flag compile_predicates index current_atom 
+			\current_blob current_functor current_flag current_key dwim_predicate nth_clause 
+			\predicate_property open_null_stream current_stream is_stream stream_position_data 
+			\seek set_stream see tell append seeing telling seen set_prolog_IO told 
+			\wait_for_input byte_count character_count line_count line_position read_clause 
+			\put tab ttyflush get0 get skip get_single_char copy_stream_data print portray 
+			\read_history prompt setarg nb_setarg nb_linkarg duplicate_term numbervars 
+			\term_variables atom_number name term_to_atom atom_to_term atom_concat 
+			\concat_atom atom_prefix normalize_space collation_key char_type string_to_list
+			\code_type downcase_atom upcase_atom collation_key locale_sort string_to_atom 
+			\string_length string_concat sub_string between succ plus rdiv max min random 
+			\integer rationalize ceil xor tan asin acos pi e cputime eval msb lsb popcount 
+			\powm arithmetic_function current_arithmetic_function is_list memberchk length 
+			\sort msort keysort predsort merge merge_set maplist forall writeln writef 
+			\swritef format format_predicate current_format_predicate tty_get_capability 
+			\tty_goto tty_put set_tty tty_size shell win_exec win_shell win_folder 
+			\win_registry_get_value getenv setenv unsetenv setlocale unix date time 
+			\get_time stamp_date_time date_time_stamp date_time_value format_time 
+			\parse_time window_title win_window_pos win_has_menu win_insert_menu 
+			\win_insert_menu_item access_file exists_file file_directory_name file_base_name 
+			\same_file exists_directory delete_file rename_file size_file time_file 
+			\absolute_file_name is_absolute_file_name file_name_extension expand_file_name 
+			\prolog_to_os_filename read_link tmp_file make_directory working_directory chdir 
+			\garbage_collect garbage_collect_atoms trim_stacks stack_parameter dwim_match 
+			\wildcard_match sleep qcompile portray_clause acyclic_term clause_property 
+			\setup_and_call_cleanup message_to_string phrase hash with_output_to fileerrors 
+			\read_pending_input prompt1 same_term sub_string merge_set 
+
+syntax cluster prologBuiltIn      contains=prologSWIBuiltIn,prologISOBuiltIn
+
+syntax match   prologArithmetic   /\*\*\?\|+\|\/\/\?\|\/\\\|<<\|>>\|\\\/\?\|\^/ 
+			\contained containedin=prologBody
+
+syntax match   prologRelations    /=\.\.\|!\|=:=\|=\?<\|=@=\|=\\=\|>=\?\|@=\?<\|@>=\?\|\\+\|\\\?=\?=\|\\\?=@=\|=/ 
+			\contained containedin=prologBody
+
+syntax region  prologCComment     fold start=/\/\*/ end=/\*\// contains=prologTODO,@Spell
+syntax match   prologComment      /%.*/ contains=prologTODO,@Spell
+syntax region  prologCommentFold  fold start=/^\zs\s*%/ skip=/^\s*%/ end=/^\ze\s*\([^%]\|$\)/ contains=prologComment
+syntax keyword prologTODO         FIXME TODO fixme todo Fixme FixMe Todo ToDo XXX xxx contained
+syntax cluster prologComments     contains=prologCComment,prologComment,prologCommentFold
+
+syntax region  prologBody         fold start=/\(:-\|?-\)/ end=/\./ 
+			\contains=@prologAll,prologPredicateWithArity
+syntax region  prologDCGBody      fold start=/-->/ end=/\./ 
+			\contains=@prologAll,prologDCGSpecials
+
+syntax match   prologNumber       /\<\d\+\>/ contained
+syntax match   prologNumber       /\<\d\+\.\d\+\>/ contained
+syntax match   prologAtom         /\<\l\w*\>\ze\([^(]\|$\)/ contained
+syntax match   prologVariable     /\<\(_\|\u\)\w*\>/ contained
+syntax match   prologChar         /\<\0'\(\\\)\?.\>/ contained
+
+syntax match   prologHead         /\<\l\w*\>/ nextgroup=prologBody,prologDCGBody skipwhite
+syntax region  prologHeadWithArgs start=/\<\l\w*\>(/ end=/)/ nextgroup=prologBody,prologDCGBody contains=@prologAll
+
+syntax match  prologOpStatement   /indexed\|discontiguous\|dynamic\|module_transparent\|multifile\|volatile\|initialization/ 
+			\containedin=prologBody contained
+
+syntax region  prologDCGSpecials  start=/{/ end=/}/ contained contains=@prologAll
+
+syntax region  prologTuple        fold start=/\W\zs(/ end=/)/ contained containedin=prologPredicate,prologBody contains=@prologAll
+syntax region  prologPredicate    start=/\<\l\w*\>\ze(/ end=/)/ contains=@prologAll
+syntax match   prologPredicateWithArity /\<\l\w*\>\/\d\+/ contains=@prologBuiltIn,prologArity
+syntax match   prologArity        contained /\/\d\+/
+syntax cluster prologPredicates   contains=prologPredicate,prologPredicateWithArity
+
+syntax region  prologList         start=/\[/ end=/\]/ contains=prologListDelimiters,@prologAll,prologPredicateWithArity contained
+syntax match   prologListDelimiters /[,|]/ contained
+
+syntax cluster prologAll          contains=prologList,prologPredicate,prologTuple,@prologTerms,@prologComments,prologQuoted,@prologBuiltIn,prologRelations,prologArithmetic,prologDiffList
+syntax cluster prologTerms        contains=prologVariable,prologAtom,prologList,
+			\prologNumber,prologErrorTerm,prologChar
+
+syntax match   prologQuotedFormat /\~\(\d*[acd\~DeEgfGiknNpqrR@st\|+wW]\|`.t\)/ contained
+syntax region  prologQuoted       start=/'/ end=/'/ contains=prologQuotedFormat,@Spell
+
+syntax match   prologErrorVariable /\<\(_\|\u\)\w*\>/
+syntax region  prologErrorTerm    start=/\<\(_\|\u\)\w*\>(/ end=/)/
+
+"""" Highlights
+
+highlight link prologErrorVariable Error
+highlight link prologErrorTerm     Error
+
+highlight link prologOpStatement  Preproc
+highlight link prologComment      Comment
+highlight link prologCComment     Comment
+highlight link prologTODO         TODO
+
+highlight link prologAtom         Constant
+highlight link prologChar         Constant
+highlight link prologVariable     Identifier
+highlight link prologNumber       Number
+
+highlight link prologISOBuiltIn   Keyword
+highlight link prologSWIBuiltIn   Keyword
+
+highlight link prologRelations    Statement
+
+highlight link prologQuotedFormat Special
+highlight link prologQuoted       String
+
+highlight link prologPredicate    Normal
+highlight link prologPredicateWithArity Normal
+highlight link prologHead         Constant
+highlight link prologHeadWithArgs Normal
+
+highlight link prologBody         Statement
+highlight link prologDCGBody      Statement
+
+highlight link prologList         Type
+highlight link prologListDelimiters Type
+highlight link prologArity        Type
+highlight link prologDCGSpecials  Type
+highlight link prologTuple        Type
+highlight link prologDiffList     Type
+
+syn sync minlines=20 maxlines=50
+
+let b:current_syntax = "prolog"

.vim/syntax/vala.vim

+" Vim syntax file
+" Language:	Vala
+" Maintainers:	Emmanuele Bassi <ebassi@gnome.org>
+" 		Hans Vercammen <hveso3@gmail.com>
+" 		pancake <pancake@nopcode.org>
+" 		Sebastian Reichel <sre@ring0.de>
+" Last Change: 	2012-02-19
+" Filenames: 	*.vala *.vapi
+"
+" REFERENCES:
+" [1] http://live.gnome.org/Vala
+"
+" TODO: Possibly when reaching vala 1.0 release
+" 	- validate code attributes
+" 	- better error checking for known errors
+" 	- full support for valadoc
+"
+" 	add vala in /usr/share/vim/vim73/scripts.vim below ruby
+" 	to have shebang support
+
+if exists("b:current_syntax")
+  finish
+endif
+
+let s:vala_cpo_save = &cpo
+set cpo&vim
+
+" Types
+syn keyword valaType			bool char double float size_t ssize_t string unichar void
+syn keyword valaType 			int int8 int16 int32 int64 long short
+syn keyword valaType 			uint uint8 uint16 uint32 uint64 ulong ushort
+" Storage keywords
+syn keyword valaStorage			class delegate enum errordomain interface namespace struct
+" repeat / condition / label
+syn keyword valaRepeat			break continue do for foreach return while
+syn keyword valaConditional		else if switch assert
+" User Labels
+syn keyword valaLabel			case default
+
+" Modifiers
+syn keyword valaModifier		abstract const dynamic ensures extern inline internal override 
+syn keyword valaModifier 		private protected public requires signal static virtual volatile weak
+syn keyword valaModifier 		async owned unowned
+" Constants
+syn keyword valaConstant		false null true
+" Exceptions
+syn keyword valaException		try catch finally throw
+" Unspecified Statements
+syn keyword valaUnspecifiedStatement	as base construct delete get in is lock new out params ref sizeof set this throws typeof using value var yield
+
+" Comments
+syn cluster valaCommentGroup 		contains=valaTodo
+syn keyword valaTodo 			contained TODO FIXME XXX NOTE
+
+" valadoc Comments (ported from javadoc comments in java.vim)
+" TODO: need to verify valadoc syntax
+if !exists("vala_ignore_valadoc")
+  syn cluster valaDocCommentGroup	contains=valaDocTags,valaDocSeeTag
+  syn region  valaDocTags 		contained start="{@\(link\|linkplain\|inherit[Dd]oc\|doc[rR]oot\|value\)" end="}"
+  syn match   valaDocTags 		contained "@\(param\|exception\|throws\|since\)\s\+\S\+" contains=valaDocParam
+  syn match   valaDocParam 		contained "\s\S\+"
+  syn match   valaDocTags 		contained "@\(author\|brief\|version\|return\|deprecated\)\>"
+  syn region  valaDocSeeTag		contained matchgroup=valaDocTags start="@see\s\+" matchgroup=NONE end="\_."re=e-1 contains=valaDocSeeTagParam
+  syn match   valaDocSeeTagParam	contained @"\_[^"]\+"\|<a\s\+\_.\{-}</a>\|\(\k\|\.\)*\(#\k\+\((\_[^)]\+)\)\=\)\=@ extend
+endif
+
+" Comment Strings (ported from c.vim)
+if exists("vala_comment_strings")
+  syn match  	valaCommentSkip		contained "^\s*\*\($\|\s\+\)"
+  syn region 	valaCommentString	contained start=+L\=\\\@<!"+ skip=+\\\\\|\\"+ end=+"+ end=+\*/+me=s-1 contains=valaSpecialChar,valaCommentSkip
+  syn region 	valaComment2String	contained start=+L\=\\\@<!"+ skip=+\\\\\|\\"+ end=+"+ end="$" contains=valaSpecialChar
+  syn cluster 	valaCommentStringGroup 	contains=valaCommentString,valaCharacter,valaNumber
+
+  syn region 	valaCommentL		start="//" end="$" keepend contains=@valaCommentGroup,valaComment2String,valaCharacter,valaNumber,valaSpaceError,@Spell
+  syn region 	valaComment		matchgroup=valaCommentStart start="/\*" end="\*/" contains=@valaCommentGroup,@valaCommentStringGroup,valaCommentStartError,valaSpaceError,@Spell extend fold
+  if !exists("vala_ignore_valadoc")
+    syn region 	valaDocComment 		matchgroup=valaCommentStart start="/\*\*" end="\*/" keepend contains=@valaCommentGroup,@valaDocCommentGroup,@valaCommentStringGroup,valaCommentStartError,valaSpaceError,@Spell
+  endif
+else
+  syn region	valaCommentL		start="//" end="$" keepend contains=@valaCommentGroup,valaSpaceError,@Spell
+  syn region	valaComment		matchgroup=valaCommentStart start="/\*" end="\*/" contains=@valaCommentGroup,valaCommentStartError,valaSpaceError,@Spell
+  if !exists("vala_ignore_valadoc")
+    syn region 	valaDocComment 		matchgroup=valaCommentStart start="/\*\*" end="\*/" keepend contains=@valaCommentGroup,@valaDocCommentGroup,valaCommentStartError,valaSpaceError,@Spell
+  endif
+endif
+
+syn region	valaPreCondit		start="^\s*\(%:\|#\)\s*\(if\|ifdef\|ifndef\|elif\)\>" skip="\\$" end="$" end="//"me=s-1
+syn match	valaPreCondit		display "^\s*\(%:\|#\)\s*\(else\|endif\)\>"
+
+" Comment if 0 blocks (ported from c.vim)
+if !exists("vala_no_if0")
+  syn region	valaCppOut		start="^\s*\(%:\|#\)\s*if\s\+0\+\>" end=".\@=\|$" contains=valaCppOut2 fold
+  syn region	valaCppOut2		contained start="0" end="^\s*\(%:\|#\)\s*\(endif\>\|else\>\|elif\>\)" contains=valaSpaceError,valaCppSkip
+  syn region	valaCppSkip		contained start="^\s*\(%:\|#\)\s*\(if\>\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\(%:\|#\)\s*endif\>" contains=valaSpaceError,valaCppSkip
+endif
+
+" match comment errors
+syntax match valaCommentError 		display "\*/"
+syntax match valaCommentStartError 	display "/\*"me=e-1 contained
+" match the special comment /**/
+syn match   valaComment		 	"/\*\*/"
+
+" Vala Code Attributes
+syn region  valaAttribute 		start="^\s*\[" end="\]$" contains=valaComment,valaString keepend
+syn region  valaAttribute 		start="\[CCode" end="\]" contains=valaComment,valaString
+
+" Avoid escaped keyword matching
+syn match   valaUserContent 		display "@\I*"
+
+" Strings and constants
+syn match   valaSpecialError		contained "\\."
+syn match   valaSpecialCharError	contained "[^']"
+syn match   valaSpecialChar		contained +\\["\\'0abfnrtvx]+
+syn region  valaString			start=+"+  end=+"+ end=+$+ contains=valaSpecialChar,valaSpecialError,valaUnicodeNumber,@Spell
+syn region  valaVerbatimString		start=+"""+ end=+"""+ contains=@Spell
+syn match   valaUnicodeNumber		+\\\(u\x\{4}\|U\x\{8}\)+ contained contains=valaUnicodeSpecifier
+syn match   valaUnicodeSpecifier	+\\[uU]+ contained
+syn match   valaCharacter		"'[^']*'" contains=valaSpecialChar,valaSpecialCharError
+syn match   valaCharacter		"'\\''" contains=valaSpecialChar
+syn match   valaCharacter		"'[^\\]'"
+syn match   valaNumber			display "\<\(0[0-7]*\|0[xX]\x\+\|\d\+\)[lL]\=\>"
+syn match   valaNumber			display "\(\<\d\+\.\d*\|\.\d\+\)\([eE][-+]\=\d\+\)\=[fFdD]\="
+syn match   valaNumber			display "\<\d\+[eE][-+]\=\d\+[fFdD]\=\>"
+syn match   valaNumber			display "\<\d\+\([eE][-+]\=\d\+\)\=[fFdD]\>"
+
+" when wanted, highlight trailing white space
+if exists("vala_space_errors")
+  if !exists("vala_no_trail_space_error")
+    syn match valaSpaceError		display excludenl "\s\+$"
+  endif
+  if !exists("vala_no_tab_space_error")
+    syn match valaSpaceError 		display " \+\t"me=e-1
+  endif
+endif
+
+" when wanted, set minimum lines for comment syntax syncing
+if exists("vala_minlines")
+  let b:vala_minlines = vala_minlines
+else
+  let b:vala_minlines = 50
+endif
+exec "syn sync ccomment valaComment minlines=" . b:vala_minlines
+
+" code folding
+syn region valaBlock			start="{" end="}" transparent fold
+
+" The default highlighting.
+hi def link valaType			Type
+hi def link valaStorage			StorageClass
+hi def link valaRepeat			Repeat
+hi def link valaConditional		Conditional
+hi def link valaLabel			Label
+hi def link valaModifier		StorageClass
+hi def link valaConstant		Constant
+hi def link valaException		Exception
+hi def link valaUnspecifiedStatement	Statement
+hi def link valaUnspecifiedKeyword	Keyword
+hi def link valaContextualStatement	Statement
+
+hi def link valaCommentError		Error
+hi def link valaCommentStartError	Error
+hi def link valaSpecialError		Error
+hi def link valaSpecialCharError	Error
+hi def link valaSpaceError 		Error
+
+hi def link valaTodo			Todo
+hi def link valaCommentL		valaComment
+hi def link valaCommentStart		valaComment
+hi def link valaCommentSkip		valaComment
+hi def link valaComment			Comment
+hi def link valaDocComment		Comment
+hi def link valaDocTags 		Special
+hi def link valaDocParam 		Function
+hi def link valaDocSeeTagParam 		Function
+hi def link valaAttribute 		PreCondit
+
+hi def link valaCommentString		valaString
+hi def link valaComment2String		valaString
+hi def link valaString			String
+hi def link valaVerbatimString		String
+hi def link valaCharacter		Character
+hi def link valaSpecialChar		SpecialChar
+hi def link valaNumber			Number
+hi def link valaUnicodeNumber		SpecialChar
+hi def link valaUnicodeSpecifier	SpecialChar
+
+hi def link valaPreCondit		PreCondit
+
+if !exists("vala_no_if0")
+  hi def link valaCppSkip		valaCppOut
+  hi def link valaCppOut2		valaCppOut
+  hi def link valaCppOut		Comment
+endif
+
+let b:current_syntax = "vala"
+
+let &cpo = s:vala_cpo_save
+unlet s:vala_cpo_save
+
+" vim: ts=8

.vim/undo/.gitignore

+*
+!.gitignore

.vim/vimrc

+set nocompatible
+set ruler
+set number
+"set bg=dark
+
+set incsearch
+" This shows what you are typing as a command.  I love this!
+set showcmd
+" Who doesn't like autoindent?
+set autoindent
+
+" Needed for Syntax Highlighting and stuff
+filetype on
+filetype plugin on
+filetype plugin indent on
+syntax enable
+set grepprg=grep\ -nRH
+
+" Spaces are better than a tab character
+" set expandtab
+set smarttab
+
+" Who wants an 8 character tab?  Not me!
+set tabstop=4
+set shiftwidth=4
+set softtabstop=4
+
+" Cool tab completion stuff
+set wildmenu
+set wildmode=list:longest,full
+
+set ignorecase
+set smartcase
+set incsearch
+set hlsearch
+set showmatch
+
+set tags=tags;/
+set wrap
+set formatoptions=tcrql
+set scrolloff=5               " keep at least 5 lines above/below
+set sidescrolloff=5           " keep at least 5 lines left/right
+set history=200
+set backspace=indent,eol,start
+set undolevels=1000           " 1000 undos
+set updatecount=100           " switch every 100 chars
+set complete=.,w,b,u,U,t,i,d  " do lots of scanning on tab completion
+set ttyfast                   " we have a fast terminal
+set pastetoggle=<F10>
+set title
+set titlelen=20
+set laststatus=2
+set wildignore+=*.aux,*.toc,*.pdf
+set isfname-==
+set display+=lastline
+set undofile
+set undodir=$HOME/.vim/undo
+set sessionoptions-=options
+set sessionoptions+=winpos,winsize
+
+let g:tex_flavor = "latex"
+
+function! s:Help2Url (...)
+	if winheight('%') < winwidth('%')
+		exec 'silent! vert bo help ' . ( a:0 ? a:1 : '' )
+	else
+		exec 'silent! help ' . ( a:0 ? a:1 : '' )
+	endif
+	if ! a:0
+		exec "normal \<c-T>"
+	endif
+	let l:tagfile = expand ('%:t')
+	let @+ = expand ('<cword>')
+	try
+		python import urllib
+		let @+ = pyeval ('urllib.quote_plus ("' . @+ . '")')
+		let @+ = printf ('http://vimhelp.appspot.com/%s.html#%s', l:tagfile, @+)
+	catch /^Vim\%((\a\+)\)\=:E887/
+		try
+			if has('python3')
+				python3 import urllib.parse
+				let @+ = py3eval ('urllib.parse.quote ("' . @+ . '")')
+				let @+ = printf ('http://vimhelp.appspot.com/%s.html#%s', l:tagfile, @+)
+			endif
+		endtry
+	endtry
+endfunction
+
+command! -nargs=? -complete=help H call s:Help2Url (<f-args>)
+
+noremap    ;           :
+noremap    ,           ;
+nnoremap   <           :tabp<CR>
+nnoremap   >           :tabn<CR>
+noremap    <leader>,   :bp<CR>
+noremap    <leader>.   :bn<CR>
+command!   C           let @/=""
+cnoremap   w!!         w !sudo tee >/dev/null %
+noremap    <leader>P   "*p
+noremap    <leader>p   "+p
+noremap    <leader>Y   "*y
+noremap    <leader>y   "+y
+inoremap   <Down>      <C-o>gj
+inoremap   <Up>        <C-o>gk
+nnoremap   <Down>      gj
+nnoremap   <Up>        gk
+
+function! YCMInstallCmd()
+	let l:ycm_cmd = 'python2 ./install.py'
+	if executable('c++')
+		let l:ycm_cmd .= ' --clang-completer'
+	endif
+	if executable('go')
+		let l:ycm_cmd .= ' --gocode-completer'
+	endif
+	if executable('npm')
+		let l:ycm_cmd .= ' --tern-completer'
+	endif
+	return l:ycm_cmd
+endfunction
+
+"execute pathogen#infect()
+call plug#begin()
+" Common plugins
+"Plug 'vim-scripts/diffchar.vim'
+Plug 'scrooloose/nerdtree'
+Plug 'ervandew/supertab'
+Plug 'scrooloose/syntastic'
+Plug 'tpope/vim-surround'
+Plug 'bling/vim-airline'
+Plug 'tpope/vim-fugitive'
+Plug 'tomasr/molokai'
+Plug 'ctrlpvim/ctrlp.vim'
+Plug 'gabrielelana/vim-markdown', {'for': 'markdown'}
+Plug 'majutsushi/tagbar', {'for': ['cpp', 'c', 'go', 'sh', 'javascript']}
+Plug 'godlygeek/tabular'
+Plug 'dhruvasagar/vim-table-mode'
+Plug 'tpope/vim-liquid', {'for': ['html', 'markdown']}
+Plug 'Vimjas/vim-python-pep8-indent'
+Plug 'tpope/vim-obsession'
+
+if executable('cmake')
+	" YCM command lifted from vim-plug readme
+	Plug 'Valloric/YouCompleteMe', { 'do': YCMInstallCmd(), 'for': ['cpp', 'c', 'sh', 'javascript', 'vim', 'tex', 'go', 'python'] }
+	autocmd! User YouCompleteMe if !has('vim_starting') | call youcompleteme#Enable() | endif
+endif
+if executable('go')
+	Plug 'fatih/vim-go', {'for': 'go'}
+	Plug 'Shougo/neocomplete.vim', {'for': 'go'}
+	Plug 'Shougo/echodoc.vim'
+endif
+if executable('latex')
+	Plug 'lervag/vimtex', {'for': 'tex'}
+endif
+if executable('ghc')
+	Plug 'dag/vim2hs', {'for': 'hs'}
+endif
+if executable('man')
+	Plug 'murukeshm/vim-manpager'
+endif
+if executable('dpkg')
+	Plug 'vim-scripts/deb.vim'
+endif
+if executable('logrotate')
+	Plug 'moon-musick/vim-logrotate'
+endif
+call plug#end()
+
+function! EnableYCM()
+	call plug#load('YouCompleteMe')
+	call youcompleteme#Enable()
+endfunction
+
+nnoremap <leader>ycm :call EnableYCM()<cr>
+
+colorscheme molokai
+highlight Normal  ctermbg=none
+highlight NonText ctermbg=none
+highlight Visual  ctermbg=DarkGrey
+highlight NonText ctermfg=grey
+highlight Comment ctermfg=grey
+set cursorline
+
+" From http://vi.stackexchange.com/questions/258/
+autocmd BufWritePre  *.sh,*.py if !filereadable(expand('%')) | let b:is_new = 1 | endif
+autocmd BufWritePost *.sh,*.py if get(b:, 'is_new', 0) | silent execute '!chmod +x %' | endif
+
+let g:SuperTabDefaultCompletionType = "context"
+let g:SuperTabClosePreviewOnPopupClose = 1
+set omnifunc=syntaxcomplete#Complete
+set foldmethod=indent
+set foldlevel=10
+let g:syntastic_cpp_compiler_options = ' -std=c++14'
+let g:syntastic_python_python_exec = '/usr/bin/python3'
+let g:syntastic_python_checkers = ['flake8']
+let g:syntastic_python_flake8_args = ['--ignore', 'E501']
+let g:syntastic_check_on_open = 0
+let g:syntastic_check_on_wq = 1
+let g:airline#extensions#tabline#enabled = 0
+let g:ctrlp_prompt_mappings = {
+			\ 'AcceptSelection("e")': ['<c-t>'],
+			\ 'AcceptSelection("t")': ['<cr>', '<2-LeftMouse>'],
+			\ }
+let g:ctrlp_max_depth = 40
+let g:ctrlp_max_files = 10000
+let g:ctrlp_custom_ignore = {
+			\ 'dir': '\v[\/](plugged|undo|view|\.git|_site)$'
+			\ }
+let g:DiffColors = 100
+let g:DiffUnit = "Word3"
+let g:DiffUpdate = 1
+let g:ycm_autoclose_preview_window_after_insertion = 1
+let g:ycm_collect_identifiers_from_tags_files = 1
+let g:ycm_seed_identifiers_with_syntax = 1
+let g:ycm_python_binary_path = '/usr/bin/python3'
+let g:neocomplete#enable_at_startup = 1
+" Use smartcase.
+let g:neocomplete#enable_smart_case = 1
+" Set minimum syntax keyword length.
+let g:neocomplete#sources#syntax#min_keyword_length = 3
+
+if empty($MAN_PN) && @% == "" && getcwd() == "/tmp"
+	" From http://vi.stackexchange.com/questions/239/
+	" with exception for reading manpages
+	try
+		silent find test.*
+	catch /^Vim\%((\a\+)\)\=:E345/
+		silent edit test.sh
+	endtry
+endif
+
+" From http://vi.stackexchange.com/questions/2009/
+function! FindInPath(name)
+	" Force creation of new file for paths beginning with ./
+	if expand('%') !~ '^[.~]\?/'
+		try
+			let path=&path
+			" Add any extra directories to the normal search path
+			set path+=~,~/.vim,/etc
+			" If :find finds a file, then wipeout the buffer that was created for the "new" file
+			setlocal bufhidden=wipe
+			exe 'silent keepalt find! '. fnameescape(expand('<afile>'))
+			" Restore 'path' and 'bufhidden' to their normal values
+			let &path=path
+			set bufhidden<
+		catch /^Vim\%((\a\+)\)\=:E345/
+			return 0
+		endtry
+	endif
+endfunction
+autocmd BufNewFile * nested call FindInPath(expand('<afile>'))
+
+"au VimEnter * tab all | tabfirst
+
+" From http://vi.stackexchange.com/questions/2358/
+autocmd FileType * exec("setlocal dictionary+=".$HOME."/.vim/dictionary/".expand('<amatch>'))
+set completeopt+=menuone
+if has('patch-7.4-775')
+	set completeopt+=noinsert
+endif
+set complete+=k
+
+runtime local/$CONFLOCAL.vim