scriptencoding utf-8
" Vim settings
"
" Maintainer:   DeaR <nayuri@kuonn.mydns.jp>
" Last Change:  08-Jun-2015.
" License:      MIT License {{{
"     Copyright (c) 2013 DeaR <nayuri@kuonn.mydns.jp>
"
"     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.
" }}}

"==============================================================================
" Pre Init: {{{
" Encoding
if has('multi_byte')
  set encoding=utf-8
  if &term == 'win32' && !has('gui_running')
    set termencoding=cp932
  endif
  scriptencoding utf-8
endif

if has('win32')
  " Language
  if has('multi_lang')
    language japanese
    language time C
  endif

  " Shell
  let s:default_shell =
    \ [&shell, &shellslash, &shellcmdflag, &shellquote, &shellxquote]
  " set shell=sh
  " set shellslash

  " Unix like runtime
  set runtimepath^=~/.vim
  set runtimepath+=~/.vim/after
endif

" Local runtime
set runtimepath^=~/.local/.vim
set runtimepath+=~/.local/.vim/after

" Singleton
if isdirectory($HOME . '/.local/bundle/singleton')
  set runtimepath+=~/.local/bundle/singleton
  let g:singleton#opener = 'drop'
  call singleton#enable()
endif

"------------------------------------------------------------------------------
" Variable: {{{
" <Leader> <LocalLeader>
let g:mapleader      = ';'
let g:maplocalleader = ','

" Gips
let s:gips_enable = 0

" Command line window
let s:cmdwin_enable = 0

" Ignore pattern
let s:ignore_ext = [
  \ 'git', 'hg', 'bzr', 'svn', 'drive.r',
  \ 'o', 'obj', 'a', 'lib', 'so', 'dll', 'dylib', 'exe', 'bin',
  \ 'swp', 'swo', 'bak', 'lc', 'elc', 'fas', 'pyc', 'luac', 'zwc']
let s:ignore_ft = [
  \ 'gitcommit', 'gitrebase', 'hgcommit']

" AlterCommand
let s:altercmd_define = {}

" NeoComplete and NeoComplCache
let s:neocompl_dictionary_filetype_lists = {
  \ 'default' : ''}
let s:neocompl_vim_completefuncs = {
  \ 'SQLSetType' : 'SQL_GetList'}
let s:neocompl_omni_patterns = {
  \ 'CucumberComplete'              : '\h\w*',
  \ 'adacomplete#Complete'          : '\h\w*',
  \ 'clojurecomplete#Complete'      : '\h\w*',
  \ 'csscomplete#CompleteCSS'       : '\h\w*\|[@!]',
  \ 'sqlcomplete#Complete'          : '\h\w*'}
let s:neocompl_force_omni_patterns = {
  \ 'ccomplete#Complete'            : '\%(\.\|->\|::\)\h\w*',
  \ 'htmlcomplete#CompleteTags'     : '<[^>]*',
  \ 'javascriptcomplete#CompleteJS' : '\.\h\w*',
  \ 'phpcomplete#CompletePHP'       : '\%(->\|::\)\h\w*',
  \ 'xmlcomplete#CompleteTags'      : '<[^>]*'}
if has('python3')
  call extend(s:neocompl_force_omni_patterns, {
    \ 'python3complete#Complete' : '\.\h\w*'})
endif
if has('python')
  call extend(s:neocompl_force_omni_patterns, {
    \ 'pythoncomplete#Complete' : '\.\h\w*'})
endif
if has('ruby')
  call extend(s:neocompl_force_omni_patterns, {
    \ 'rubycomplete#Complete' : '\%(\.\|::\)\h\w*'})
endif

" VCvarsall.bat
if has('win32') && !exists('$VCVARSALL')
  let s:save_ssl = &shellslash
  set noshellslash
  if exists('$VS120COMNTOOLS')
    let $VCVARSALL = shellescape($VS120COMNTOOLS . '..\..\VC\vcvarsall.bat')
  elseif exists('$VS110COMNTOOLS')
    let $VCVARSALL = shellescape($VS110COMNTOOLS . '..\..\VC\vcvarsall.bat')
  elseif exists('$VS100COMNTOOLS')
    let $VCVARSALL = shellescape($VS100COMNTOOLS . '..\..\VC\vcvarsall.bat')
  elseif exists('$VS90COMNTOOLS')
    let $VCVARSALL = shellescape($VS90COMNTOOLS  . '..\..\VC\vcvarsall.bat')
  elseif exists('$VS80COMNTOOLS')
    let $VCVARSALL = shellescape($VS80COMNTOOLS  . '..\..\VC\vcvarsall.bat')
  endif
  let &shellslash = s:save_ssl
  unlet s:save_ssl

  let s:save_isi = &isident
  set isident+=(,)
  let s:programfiles = expand(exists('$PROGRAMFILES(X86)') ?
    \ '$PROGRAMFILES(X86)' : '$PROGRAMFILES')
  if isdirectory(s:programfiles . '\Microsoft SDKs\Windows\v7.1A\Include')
    let $SDK_INCLUDE_DIR = s:programfiles . '\Microsoft SDKs\Windows\v7.1A\Include'
  elseif isdirectory(s:programfiles . '\Microsoft SDKs\Windows\v7.1\Include')
    let $SDK_INCLUDE_DIR = s:programfiles . '\Microsoft SDKs\Windows\v7.1\Include'
  endif
  let &isident = s:save_isi
  unlet s:save_isi
endif
"}}}

"------------------------------------------------------------------------------
" Common: {{{
" Vimrc autocmd group
augroup MyVimrc
  autocmd!
augroup END

" Script ID
function! s:SID_PREFIX()
  let s:_SID_PREFIX = get(s:, '_SID_PREFIX',
    \ matchstr(expand('<sfile>'), '<SNR>\d\+_\zeSID_PREFIX$'))
  return s:_SID_PREFIX
endfunction

" Check Vim version
function! s:has_patch(major, minor, patch)
  let l:version = (a:major * 100 + a:minor)
  return has('patch-' . a:major . '.' . a:minor . '.' . a:patch) ||
    \ (v:version > l:version) ||
    \ (v:version == l:version && 'patch' . a:patch)
endfunction

" Check vimproc
function! s:has_vimproc()
  if !exists('s:exists_vimproc')
    try
      call vimproc#version()
      let s:exists_vimproc = 1
    catch
      let s:exists_vimproc = 0
    endtry
  endif
  return s:exists_vimproc
endfunction

" Cached executable
let s:_executable = {}
function! s:executable(expr)
  let s:_executable[a:expr] = get(s:_executable, a:expr, executable(a:expr))
  return s:_executable[a:expr]
endfunction

" Check Android OS
let s:is_android = has('unix') &&
  \ ($HOSTNAME ==? 'android' || $VIM =~? 'net\.momodalo\.app\.vimtouch')

" Check japanese
let s:is_lang_ja = has('multi_lang') && v:lang =~? '^ja'

" Check NeoBundle
let s:has_neobundle = isdirectory($HOME . '/.local/bundle/neobundle')
"}}}

"------------------------------------------------------------------------------
" NeoBundle: {{{
if s:has_neobundle
  set runtimepath+=~/.local/bundle/neobundle
  let g:neobundle#enable_name_conversion = 1
  let g:neobundle#enable_tail_path       = 1
  let g:neobundle#install_max_processes  =
    \ exists('$NUMBER_OF_PROCESSORS') ? str2nr($NUMBER_OF_PROCESSORS) : 1
  if s:is_android
    let g:neobundle#types#git#default_protocol = 'ssh'
    let g:neobundle#types#hg#default_protocol  = 'ssh'
  endif
  call neobundle#begin($HOME . '/.local/bundle')

  NeoBundleLazy 'h1mesuke/vim-alignta', {
    \ 'autoload' : {
    \   'commands' : ['Align', 'Alignta'],
    \   'mappings' : [['nvo', '<Plug>(operator-alignta)']],
    \   'unite_sources' : 'alignta'}}

  NeoBundleLazy 'tyru/vim-altercmd', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'AlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'NAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'VAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'XAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'SAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'OAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'IAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'CAlterCommand',
    \      'complete' : 'command'},
    \     {'name' : 'LAlterCommand',
    \      'complete' : 'command'}]}}
  autocmd MyVimrc User CmdlineEnter
    \ NeoBundleSource altercmd

  NeoBundleLazy 'kana/vim-altr', {
    \ 'autoload' : {
    \   'mappings' : [['nvoi', '<Plug>(altr-']]}}
  autocmd MyVimrc User CmdlineEnter
    \ NeoBundleSource altr

  NeoBundleLazy 'osyo-manga/vim-anzu', {
    \ 'autoload' : {
    \   'commands' : [
    \     'AnzuClearSearchStatus',  'AnzuClearSearchCache',
    \     'AnzuUpdateSearchStatus', 'AnzuUpdateSearchStatusOutput',
    \     'AnzuSignMatchLine',      'AnzuClearSignMatchLine'],
    \   'mappings' : [
    \     ['n',
    \      '<Plug>(anzu-',
    \      '<Plug>(anzu-jump-n)<Plug>(anzu-',
    \      '<Plug>(anzu-jump-N)<Plug>(anzu-']]}}

  NeoBundleLazy 'gist:iori-yja/1615430', {
    \ 'name' : 'arm',
    \ 'script_type' : 'syntax',
    \ 'autoload' : {
    \   'filetypes' : 'arm'}}

  NeoBundleLazy 'autodate.vim', {
    \ 'autoload' : {
    \   'commands' : ['Autodate', 'AutodateON', 'AutodateOFF']}}
  autocmd MyVimrc BufNewFile,BufRead *
    \ NeoBundleSource autodate

  NeoBundleLazy 'vim-jp/autofmt'

  NeoBundleLazy 'h1mesuke/vim-benchmark'

  NeoBundleLazy 'mattn/benchvimrc-vim', {
    \ 'autoload' : {
    \   'commands' : 'BenchVimrc'}}

  if s:executable('clang-format')
    NeoBundleLazy 'rhysd/vim-clang-format', {
      \ 'autoload' : {
      \   'commands' : ['ClangFormat', 'ClangFormatEchoFormattedCode'],
      \   'mappings' : [['nvo', '<Plug>(operator-clang-format)']]}}
  endif

  NeoBundleLazy 'rhysd/clever-f.vim', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(clever-f-']],
    \   'insert' : 1}}

  NeoBundleLazy 'deris/columnjump', {
    \ 'autoload' : {
    \   'commands' : ['ColumnJumpForward', 'ColumnJumpBackward'],
    \   'mappings' : [['nvo', '<Plug>(columnjump-']],
    \   'insert' : 1}}

  NeoBundleLazy 'Shougo/context_filetype.vim'

  NeoBundleLazy 'vim-jp/cpp-vim', {
    \ 'autoload' : {
    \   'filetypes' : [
    \     'c', 'ch', 'cpp', 'cuda', 'cynlib', 'cynpp', 'dtrace', 'esqlc',
    \     'kwt', 'objc', 'objcpp', 'rpcgen', 'splint', 'xs']}}

  NeoBundleLazy 'hail2u/vim-css3-syntax', {
    \ 'autoload' : {
    \   'filetypes' : [
    \     'aspperl', 'aspvbs', 'cf', 'css', 'dtml', 'groovy', 'gsp', 'haml',
    \     'html', 'htmlcheetah', 'htmldjango', 'htmlm4', 'htmlos', 'jsp',
    \     'markdown', 'mason', 'msql', 'php', 'plp', 'phtml', 'sass', 'scss',
    \     'smarty', 'spyce', 'tt2html', 'webmacro', 'wml', 'xhtml']}}

  NeoBundleLazy 'pekepeke/vim-csvutil'

  NeoBundleLazy 'JesseKPhillips/d.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'd'}}

  NeoBundleLazy 'tpope/vim-dispatch', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'Dispatch',
    \      'complete' : 'custom,dispatch#command_complete'},
    \     {'name' : 'FocusDispatch',
    \      'complete' : 'custom,dispatch#command_complete'},
    \     {'name' : 'Start',
    \      'complete' : 'custom,dispatch#command_complete'},
    \     {'name' : 'Make',
    \      'complete' : 'file'},
    \     'Copen']}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'Dispatch'      : 'dispatch#command_complete',
    \ 'FocusDispatch' : 'dispatch#command_complete',
    \ 'Start'         : 'dispatch#command_complete'})

  NeoBundleLazy 'Shougo/echodoc.vim', {
    \ 'autoload' : {
    \   'commands' : ['EchoDocEnable', 'EchoDocDisable'],
    \   'insert' : 1}}

  NeoBundleLazy 'mattn/emmet-vim', {
    \ 'autoload' : {
    \   'commands' : 'Emmet',
    \   'mappings' : [['nvi', '<M-y>']]}}

  NeoBundleLazy 'tyru/eskk.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'skkdict',
    \   'commands' : [
    \     'EskkMap', 'EskkForgetRegisteredWords',
    \     'EskkReload', 'EskkUpdateDictionary',
    \     {'name' : 'EskkFixDictionary',
    \      'complete' : 'file'}],
    \   'mappings' : [['i', '<Plug>(eskk:']]}}
  autocmd MyVimrc User CmdlineEnter
    \ NeoBundleSource eskk

  if s:executable('go')
    NeoBundleFetch 'mattn/files', {
      \ 'build' : {
      \   'others' : 'go get -u github.com/mattn/files'}}
  endif

  NeoBundleLazy 'kana/vim-filetype-haskell', {
    \ 'autoload' : {
    \   'filetypes' : 'haskell'}}

  NeoBundleLazy 'thinca/vim-ft-clojure', {
    \ 'autoload' : {
    \   'filetypes' : 'clojure'}}

  NeoBundleLazy 'thinca/vim-ft-diff_fold', {
    \ 'autoload' : {
    \   'filetypes' : 'diff'}}

  NeoBundleLazy 'google/vim-ft-go', {
    \ 'autoload' : {
    \   'filetypes' : 'go'}}

  NeoBundleLazy 'thinca/vim-ft-help_fold', {
    \ 'autoload' : {
    \   'filetypes' : 'help'}}

  NeoBundleLazy 'thinca/vim-ft-markdown_fold', {
    \ 'autoload' : {
    \   'filetypes' : 'markdown'}}

  NeoBundleLazy 'thinca/vim-ft-vim_fold', {
    \ 'autoload' : {
    \   'filetypes' : 'vim'}}

  if has('lua') || s:executable('lua')
    NeoBundleLazy 'xolox/vim-lua-ftplugin', {
      \ 'name' : 'ft_lua',
      \ 'autoload' : {
      \   'filetypes' : 'lua',
      \   'commands' : ['LuaCheckSyntax', 'LuaCheckGlobals']},
      \ 'depends' : 'xolox/vim-misc'}
  endif

  NeoBundleLazy 'tpope/vim-fugitive', {
    \ 'autoload' : {
    \   'commands' : [
    \     'Git', 'Gcd', 'Glcd', 'Gstatus', 'Gcommit', 'Ggrep', 'Glgrep',
    \     'Glog', 'Gllog', 'Ge', 'Gedit', 'Gpedit', 'Gsplit', 'Gvsplit',
    \     'Gtabedit', 'Gread', 'Gwrite', 'Gw', 'Gwq',
    \     'Gdiff', 'Gvdiff', 'Gsdiff', 'Gbrowse']}}

  NeoBundleLazy 'kana/vim-gf-user', {
    \ 'autoload' : {
    \   'commands' : 'GfUserDefaultKeyMappings',
    \   'mappings' : [['nv', '<Plug>(gf-user-']]},
    \ 'depends' : [
    \   'sgur/vim-gf-autoload',
    \   'kana/vim-gf-diff']}

  NeoBundleLazy 'eagletmt/ghcmod-vim', {
    \ 'autoload' : {
    \   'filetypes' : 'haskell'}}

  NeoBundleLazy 'yomi322/vim-gitcomplete'

  NeoBundleLazy 'gregsexton/gitv', {
    \ 'autoload' : {
    \   'commands' : 'Gitv'},
    \ 'depends' : 'tpope/vim-fugitive'}

  NeoBundleLazy 'vim-jp/vim-go-extra', {
    \ 'autoload' : {
    \   'filetypes' : 'go'}}

  if s:executable('go')
    NeoBundleFetch 'nsf/gocode', {
      \ 'build' : {
      \   'others' : 'go get -u github.com/nsf/gocode'}}
  endif

  if s:executable('go')
    NeoBundleFetch 'golang/lint', {
      \ 'name' : 'golint',
      \ 'build' : {
      \   'others' : 'go get -u github.com/golang/lint/golint'}}
  endif

  NeoBundleLazy 'kana/vim-grex', {
    \ 'autoload' : {
    \   'commands' : ['Gred', 'Grey'],
    \   'mappings' : [['nvo', '<Plug>(operator-grex-']]}}

  " NeoBundleLazy 'rbtnn/hexript.vim', {
  "   \ 'autoload' : {
  "   \   'commands' : [
  "   \     {'name' : 'HexriptToBinaryFile',
  "   \      'complete' : 'file'}]}}

  NeoBundleLazy 'cohama/vim-hier', {
    \ 'autoload' : {
    \   'filetypes' : 'qf',
    \   'commands' : ['HierUpdate', 'HierClear', 'HierStart', 'HierStop']}}

  NeoBundleLazy 'othree/html5.vim', {
    \ 'autoload' : {
    \   'filetypes' : [
    \     'aspperl', 'aspvbs', 'cf', 'dtml', 'eruby',  'groovy', 'gsp',
    \     'haml', 'html', 'htmlcheetah', 'htmldjango', 'htmlm4', 'htmlos',
    \     'javascript', 'jsp', 'liquid', 'markdown', 'mason', 'msql',
    \     'php', 'phtml', 'plp', 'smarty', 'spyce', 'tt2html', 'tt2js',
    \     'webmacro', 'wml', 'xhtml']}}

  NeoBundleLazy 'HybridText', {
    \ 'autoload' : {
    \   'filetypes' : ['hybrid', 'text']}}

  NeoBundleLazy 'kamichidu/vim-javaclasspath'

  NeoBundleLazy 'kamichidu/vim-javalang'

  NeoBundleLazy 'basyura/J6uil.vim', {
    \ 'autoload' : {
    \   'commands' : [
    \     'J6uilReconnect', 'J6uilDisconnect',
    \     {'name' : 'J6uil',
    \      'complete' : 'custom,J6uil#complete#room'}],
    \   'mappings' : [['n', '<Plug>(J6uil_']],
    \   'function_prefix' : 'J6uil',
    \   'unite_sources' : ['J6uil/rooms', 'J6uil/members']}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'J6uil' : 'J6uil#complete#room'})

  NeoBundleLazy 'jelera/vim-javascript-syntax', {
    \ 'autoload' : {
    \   'filetypes' : ['javascript', 'tt2js']}}

  if has('python') || has('python3')
    NeoBundleLazy 'davidhalter/jedi-vim', {
      \ 'autoload' : {
      \   'filetypes' : ['pyrex', 'python'],
      \   'commands' : [
      \     {'name' : 'Pyimport',
      \      'complete' : 'custom,jedi#py_import_completions'}]}}
    call extend(s:neocompl_vim_completefuncs, {
      \ 'Pyimport' : 'jedi#py_import_completions'})
  endif

  NeoBundleLazy 'elzr/vim-json', {
    \ 'autoload' : {
    \   'filetypes' : 'json'}}

  if s:executable('go')
    NeoBundleFetch 'mattn/jvgrep', {
      \ 'build' : {
      \   'others' : 'go get -u github.com/mattn/jvgrep'}}
  endif

  NeoBundleLazy 'kwbdi.vim', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>Kwbd']],
    \   'commands' : 'Kwbd'}}

  NeoBundleLazy 'dbakker/vim-lint'

  NeoBundle 'thinca/vim-localrc'

  NeoBundleLazy 'https://raw.githubusercontent.com/januswel/dotfiles/master/.vim/syntax/mayu.vim', {
    \ 'name' : 'mayu',
    \ 'script_type' : 'syntax',
    \ 'autoload' : {
    \   'filetypes' : 'mayu'}}

  if has('unix') && !has('gui_running')
    NeoBundle 'gist:DeaR/5560785', {
      \ 'name' : 'map-alt-keys',
      \ 'script_type' : 'plugin'}
  endif

  NeoBundleLazy 'gist:DeaR/5558981', {
    \ 'name' : 'maplist',
    \ 'script_type' : 'plugin',
    \ 'autoload' : {
    \   'commands' : [
    \     'MapList',  'NMapList', 'OMapList',
    \     'VMapList', 'XMapList', 'SMapList',
    \     'IMapList', 'CMapList', 'LMapList']}}

  if s:executable('clang')
    NeoBundleLazy 'osyo-manga/vim-marching', {
      \ 'autoload' : {
      \   'filetypes' : ['c', 'cpp'],
      \   'commands' : [
      \     'MarchingBufferClearCache', 'MarchingDebugLog'],
      \   'mappings' : [['i', '<Plug>(marching_']]}}
  endif

  if !has('win32') && s:executable('go')
    NeoBundleFetch 'laurent22/massren', {
      \ 'build' : {
      \   'other' : 'go get -u github.com/laurent22/massren'}}
  endif

  if s:executable('go')
    NeoBundleLazy 'peco/migemogrep', {
      \ 'rtp' : 'misc/vim',
      \ 'autoload' : {
      \   'commands' : ['MigemoGrep']},
      \ 'build' : {
      \   'others' : 'go get -u github.com/peco/migemogrep'}}
  endif

  NeoBundleLazy 'xolox/vim-misc', {
    \ 'autoload' : {
    \   'function_prefix' : 'xolox'}}

  NeoBundle 'tomasr/molokai'

  NeoBundleLazy 'kana/vim-narrow', {
    \ 'autoload' : {
    \   'commands' : ['Narrow', 'Widen'],
    \   'mappings' : [['nvo', '<Plug>(operator-narrow)']]}}

  NeoBundleFetch 'Shougo/neobundle.vim'
  call extend(s:neocompl_vim_completefuncs, {
    \ 'NeoBundleSource'    : 'neobundle#complete_lazy_bundles',
    \ 'NeoBundleDisable'   : 'neobundle#complete_bundles',
    \ 'NeoBundleInstall'   : 'neobundle#complete_bundles',
    \ 'NeoBundleUpdate'    : 'neobundle#complete_bundles',
    \ 'NeoBundleClean'     : 'neobundle#complete_deleted_bundles',
    \ 'NeoBundleReinstall' : 'neobundle#complete_bundles'})

  if has('lua') && s:has_patch(7, 3, 885)
    NeoBundleLazy 'Shougo/neocomplete.vim', {
      \ 'autoload' : {
      \   'commands' : [
      \     'NeoCompleteEnable', 'NeoCompleteDisable',
      \     'NeoCompleteLock',   'NeoCompleteUnlock',
      \     'NeoCompleteToggle', 'NeoCompleteClean',
      \     'NeoCompleteTagMakeCache',
      \     {'name' : 'NeoCompleteSetFileType',
      \      'complete' : 'filetype'},
      \     {'name' : 'NeoCompleteBufferMakeCache',
      \      'complete' : 'file'},
      \     {'name' : 'NeoCompleteDictionaryMakeCache',
      \      'complete' : 'customlist,neocomplete#filetype_complete'},
      \     {'name' : 'NeoCompleteIncludeMakeCache',
      \      'complete' : 'buffer'},
      \     {'name' : 'NeoCompleteSyntaxMakeCache',
      \      'complete' : 'customlist,neocomplete#filetype_complete'}],
      \   'unite_sources' : ['file_include', 'neocomplete'],
      \   'insert' : 1},
      \ 'depends' : [
      \   'Shougo/echodoc',
      \   'hrsh7th/vim-neco-calc',
      \   'eagletmt/neco-ghc',
      \   'ujihisa/neco-look',
      \   'Shougo/neosnippet.vim']}
    call extend(s:neocompl_vim_completefuncs, {
      \ 'NeoCompleteDictionaryMakeCache' : 'neocomplete#filetype_complete',
      \ 'NeoCompleteSyntaxMakeCache'     : 'neocomplete#filetype_complete'})
  else
    NeoBundleLazy 'Shougo/neocomplcache.vim', {
      \ 'autoload' : {
      \   'commands' : [
      \     'NeoComplCacheEnable', 'NeoComplCacheDisable',
      \     'NeoComplCacheLock',   'NeoComplCacheLockSource',
      \     'NeoComplCacheUnlock', 'NeoComplCacheUnlockSource',
      \     'NeoComplCacheToggle', 'NeoComplCacheClean',
      \     'NeoComplCacheCachingTags',
      \     {'name' : 'NeoComplCacheSetFileType',
      \      'complete' : 'filetype'},
      \     {'name' : 'NeoComplCacheCachingBuffer',
      \      'complete' : 'file'},
      \     {'name' : 'NeoComplCachePrintSource',
      \      'complete' : 'buffer'},
      \     {'name' : 'NeoComplCacheOutputKeyword',
      \      'complete' : 'buffer'},
      \     {'name' : 'NeoComplCacheDisableCaching',
      \      'complete' : 'buffer'},
      \     {'name' : 'NeoComplCacheEnableCaching',
      \      'complete' : 'buffer'},
      \     {'name' : 'NeoComplCacheCachingDictionary',
      \      'complete' : 'customlist,neocomplcache#filetype_complete'},
      \     {'name' : 'NeoComplCacheCachingInclude',
      \      'complete' : 'buffer'},
      \     {'name' : 'NeoComplCacheCachingSyntax',
      \      'complete' : 'customlist,neocomplcache#filetype_complete'}],
      \   'unite_sources' : ['file_include', 'neocomplcache'],
      \   'insert' : 1},
      \ 'depends' : [
      \   'Shougo/echodoc',
      \   'hrsh7th/vim-neco-calc',
      \   'eagletmt/neco-ghc',
      \   'ujihisa/neco-look',
      \   'Shougo/neosnippet.vim']}
    call extend(s:neocompl_vim_completefuncs, {
      \ 'NeoComplCacheCachingDictionary' : 'neocomplcache#filetype_complete',
      \ 'NeoComplCacheCachingSyntax'     : 'neocomplcache#filetype_complete'})
  endif

  NeoBundle 'Shougo/neomru.vim'

  NeoBundleLazy 'Shougo/neosnippet.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'snippet',
    \   'commands' : [
    \     {'name' : 'NeoSnippetEdit',
    \      'complete' : 'customlist,neosnippet#edit_complete'},
    \     {'name' : 'NeoSnippetMakeCache',
    \      'complete' : 'customlist,neosnippet#filetype_complete'},
    \     {'name' : 'NeoSnippetSource',
    \      'complete' : 'file'},
    \     'NeoSnippetClearMarkers'],
    \   'mappings' : [['vi', '<Plug>(neosnippet_']],
    \   'unite_sources' : [
    \     'snippet', 'snippet/target',
    \     'neosnippet/user', 'neosnippet/runtime']}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'NeoSnippetEdit'      : 'neosnippet#edit_complete',
    \ 'NeoSnippetMakeCache' : 'neosnippet#filetype_complete'})

  NeoBundleLazy 'evanmiller/nginx-vim-syntax', {
    \ 'autoload' : {
    \   'filetypes' : 'nginx'}}

  NeoBundleLazy 'Shougo/vim-nyaos', {
    \ 'autoload' : {
    \   'filetypes' : 'nyaos'}}

  if has('python') && (exists('$VCVARSALL') || s:executable('xbuild'))
    NeoBundleLazy 'nosami/Omnisharp', {
      \ 'autoload' : {
      \   'filetypes' : 'cs'},
      \ 'build' : {
      \   'windows' :
      \     $VCVARSALL . ' ' . $PROCESSOR_ARCHITECTURE . ' & ' .
      \     'msbuild server/OmniSharp.sln /p:Platform="Any CPU"',
      \   'others'  :
      \     'xbuild server/OmniSharp.sln /p:Platform="Any CPU"'}}
  endif

  NeoBundleLazy 'tyru/open-browser.vim', {
    \ 'autoload' : {
    \   'commands' : [
    \     'OpenBrowser',
    \     {'name' : 'OpenBrowserSearch',
    \      'complete' : 'customlist,openbrowser#_cmd_complete'},
    \     {'name' : 'OpenBrowserSmartSearch',
    \      'complete' : 'customlist,openbrowser#_cmd_complete'}],
    \   'mappings' : [['nv', '<Plug>(openbrowser-']]}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'OpenBrowserSearch'      : 'openbrowser#_cmd_complete',
    \ 'OpenBrowserSmartSearch' : 'openbrowser#_cmd_complete'})

  NeoBundleLazy 'thinca/vim-openbuf'

  NeoBundleLazy 'tyru/operator-camelize.vim', {
    \ 'autoload' : {
    \   'mappings' : [
    \     ['nvo',
    \      '<Plug>(operator-camelize)', '<Plug>(operator-decamelize)',
    \      '<Plug>(operator-camelize-toggle)']]}}

  NeoBundleLazy 'tyru/operator-html-escape.vim', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-html-']]}}

  NeoBundleLazy 'rhysd/vim-operator-filled-with-blank', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-filled-with-blank)']]}}

  NeoBundleLazy 'sgur/vim-operator-openbrowser', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-openbrowser)']]},
    \ 'depends' : 'tyru/open-browser.vim'}

  NeoBundleLazy 'kana/vim-operator-replace', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-replace)']]}}

  NeoBundleLazy 'tyru/operator-reverse.vim', {
    \ 'autoload' : {
    \   'commands' : 'OperatorReverseLines',
    \   'mappings' : [['nvo', '<Plug>(operator-reverse-']]}}

  NeoBundleLazy 'osyo-manga/vim-operator-search', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-search)']]}}

  NeoBundleLazy 'thinca/vim-operator-sequence', {
    \ 'autoload' : {
    \   'functions' : 'operator#sequence#map'},
    \ 'depends' : 'tyru/operator-camelize.vim'}

  NeoBundleLazy 'pekepeke/vim-operator-shuffle', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-shuffle)']]}}

  NeoBundleLazy 'emonkak/vim-operator-sort', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-sort)']]}}

  NeoBundleLazy 'tyru/operator-star.vim', {
    \ 'autoload' : {
    \   'mappings' : [
    \     ['nvo',
    \      '<Plug>(operator-*)', '<Plug>(operator-g*)',
    \      '<Plug>(operator-#)', '<Plug>(operator-g#)']]},
    \ 'depends' : 'thinca/vim-visualstar'}

  NeoBundleLazy 'yomi322/vim-operator-suddendeath', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-suddendeath)']]}}

  NeoBundleLazy 'rhysd/vim-operator-surround', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-surround-']]},
    \ 'depends' : 'osyo-manga/vim-textobj-multiblock'}

  NeoBundleLazy 'pekepeke/vim-operator-tabular', {
    \ 'autoload' : {
    \   'mappings' : [
    \     ['nvo',
    \      '<Plug>(operator-tabular-',
    \      '<Plug>(operator-tabularize)', '<Plug>(operator-untabularize)']]}}

  NeoBundleLazy 'rhysd/vim-operator-trailingspace-killer', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(operator-trailingspace-killer)']]}}

  NeoBundleLazy 'kana/vim-operator-user', {
    \ 'autoload' : {
    \   'mappings' : [
    \     ['nvo', '<Plug>(operator-grep)', '<Plug>(operator-justify)']],
    \   'function_prefix' : 'operator'}}

  NeoBundleLazy 'deris/parajump', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(parajump-']],
    \   'insert' : 1}}

  NeoBundleLazy 'thinca/vim-partedit', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'Partedit',
    \      'complete' : 'customlist,partedit#complete'}]}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'Partedit' : 'partedit#complete'})

  NeoBundleLazy 'vim-perl/vim-perl', {
    \ 'autoload' : {
    \   'filetypes' : [
    \     'perl', 'perl6', 'pod', 'tt2', 'tt2html', 'tt2js', 'xs']}}

  NeoBundleLazy 'y-uuki/perl-local-lib-path.vim', {
    \ 'autoload' : {
    \   'commands' : 'PerlLocalLibPath'}}

  if s:executable('perl')
    NeoBundleLazy 'c9s/perlomni.vim', {
      \ 'autoload' : {
      \   'filetypes' : 'perl'}}
  endif

  NeoBundleLazy 'shawncplus/phpcomplete.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'php'}}

  NeoBundleLazy '2072/PHP-Indenting-for-VIm', {
    \ 'name' : 'PHPIndent',
    \ 'autoload' : {
    \   'filetypes' : 'php'}}

  NeoBundle 'osyo-manga/vim-precious'

  NeoBundleLazy 'thinca/vim-prettyprint', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'PrettyPrint',
    \      'complete' : 'expression'},
    \     {'name' : 'PP',
    \      'complete' : 'expression'}],
    \   'functions': ['PrettyPrint', 'PP']}}

  NeoBundleLazy 'kannokanno/previm', {
    \ 'autoload' : {
    \   'filetypes' : 'markdown'},
    \ 'depends' : 'tyru/open-browser.vim'}

  NeoBundleLazy 'thinca/vim-qfreplace', {
    \ 'autoload' : {
    \   'filetypes' : ['qf', 'unite']}}

  NeoBundleLazy 'dannyob/quickfixstatus', {
    \ 'autoload' : {
    \   'filetypes' : 'qf',
    \   'commands' : ['QuickfixStatusEnable', 'QuickfixStatusDisable']}}

  NeoBundleLazy 't9md/vim-quickhl', {
    \ 'autoload' : {
    \   'commands' : [
    \     'QuickhlManualEnable', 'QuickhlManualDisable',
    \     'QuickhlManualList',   'QuickhlManualColors',
    \     'QuickhlManualAdd',    'QuickhlManualDelete',
    \     'QuickhlManualLock',   'QuickhlManualLockWindow',
    \     'QuickhlManualUnlock', 'QuickhlManualLockToggle',
    \     'QuickhlManualReset',  'QuickhlManualLockWindowToggle',
    \     'QuickhlCwordEnable',  'QuickhlTagEnable',
    \     'QuickhlCwordDisable', 'QuickhlTagDisable',
    \     'QuickhlCwordToggle',  'QuickhlTagToggle'],
    \   'mappings' : [
    \     ['nv', '<Plug>(quickhl-'],
    \     ['nvo', '<Plug>(operator-quickhl-']]}}

  NeoBundleLazy 'thinca/vim-quickrun', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'QuickRun',
    \      'complete' : 'customlist,quickrun#complete'}],
    \   'mappings' : [
    \     ['nv', '<Plug>(quickrun)'],
    \     ['n',  '<Plug>(quickrun-op)']]},
    \ 'depends' : [
    \   'osyo-manga/quickrun-hook-vcvarsall',
    \   'osyo-manga/shabadou.vim',
    \   'osyo-manga/vim-watchdogs']}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'QuickRun' : 'quickrun#complete'})

  NeoBundleLazy 'osyo-manga/vim-reanimate', {
    \ 'autoload' : {
    \   'commands' : [
    \     'ReanimateSave', 'ReanimateSaveInput', 'ReanimateSaveCursorHold',
    \     'ReanimateLoad', 'ReanimateLoadInput', 'ReanimateLoadLatest',
    \     'ReanimateSwitch', 'ReanimateUnload', 'ReanimateEditVimrcLocal'],
    \   'unite_sources' : 'reanimate'}}

  NeoBundleLazy 'thinca/vim-ref', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'Ref',
    \      'complete' : 'customlist,ref#complete'}],
    \   'mappings' : [['nv', '<Plug>(ref-keyword)']],
    \   'unite_sources' : 'ref'},
    \ 'depends' : 'ujihisa/ref-hoogle'}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'Ref' : 'ref#complete'})

  NeoBundleLazy 'deris/vim-rengbang', {
    \ 'autoload' : {
    \   'commands' : ['RengBang', 'RengBangUsePrev', 'RengBangConfirm'],
    \   'mappings' : [
    \     ['nvo', '<Plug>(operator-rengbang)', '<Plug>(operator-rengbang-']]}}

  NeoBundleLazy 'tpope/vim-repeat'

  NeoBundleLazy 'osyo-manga/vim-reunions'

  NeoBundleLazy 'vim-ruby/vim-ruby', {
    \ 'autoload' : {
    \   'filetypes' : ['eruby', 'haml', 'ruby']}}

  NeoBundleLazy 'thinca/vim-scouter', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'Scouter',
    \      'complete' : 'file'}]}}

  NeoBundleLazy 'DeaR/vim-scratch', {
    \ 'autoload' : {
    \   'commands' : ['ScratchOpen', 'ScratchClose', 'ScratchEvaluate'],
    \   'mappings' : [['nvo', '<Plug>(scratch-']]}}

  NeoBundleLazy 'jiangmiao/simple-javascript-indenter', {
    \ 'autoload' : {
    \   'filetypes' : 'javascript'}}

  if has('clientserver')
    NeoBundleFetch 'thinca/vim-singleton'
  endif

  NeoBundleLazy 'kana/vim-smartword', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(smartword-']],
    \   'insert' : 1}}

  if s:executable('clang') && has('python')
    NeoBundleLazy 'osyo-manga/vim-snowdrop', {
      \ 'autoload' : {
      \   'filetypes' : ['c', 'cpp'],
      \   'commands' : [
      \     'SnowdropVerify', 'SnowdropEchoClangVersion'],
      \   'unite_sources' : ['snowdrop/includes', 'snowdrop/outline']}}
  endif

  NeoBundleLazy 'AndrewRadev/switch.vim', {
    \ 'autoload' : {
    \   'commands' : ['Switch', 'SwitchIncrement', 'SwitchDecrement']}}

  if has('python') && s:executable('node')
    NeoBundleLazy 'marijnh/tern_for_vim', {
      \ 'name' : 'tern',
      \ 'autoload' : {
      \   'filetypes' : 'javascript'},
      \ 'build' : {
      \   'others' : 'npm install'}}
  endif

  NeoBundleLazy 'tomtom/tcomment_vim', {
    \ 'name' : 'tcomment',
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'TComment',
    \      'complete' : 'customlist,tcomment#CompleteArgs'},
    \     {'name' : 'TCommentAs',
    \      'complete' : 'customlist,tcomment#Complete'},
    \     {'name' : 'TCommentRight',
    \      'complete' : 'customlist,tcomment#CompleteArgs'},
    \     {'name' : 'TCommentBlock',
    \      'complete' : 'customlist,tcomment#CompleteArgs'},
    \     {'name' : 'TCommentInline',
    \      'complete' : 'customlist,tcomment#CompleteArgs'},
    \     {'name' : 'TCommentMaybeInline',
    \      'complete' : 'customlist,tcomment#CompleteArgs'}],
    \   'mappings' : [
    \     ['nvo', '<Plug>(operator-tcomment)', '<Plug>(operator-tcomment-']]}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'TComment'            : 'tcomment#CompleteArgs',
    \ 'TCommentAs'          : 'tcomment#Complete',
    \ 'TCommentRight'       : 'tcomment#CompleteArgs',
    \ 'TCommentBlock'       : 'tcomment#CompleteArgs',
    \ 'TCommentInline'      : 'tcomment#CompleteArgs',
    \ 'TCommentMaybeInline' : 'tcomment#CompleteArgs'})

  NeoBundleLazy 't9md/vim-textmanip', {
    \ 'autoload' : {
    \   'mappings' : [
    \     ['nv',  '<Plug>(textmanip-'],
    \     ['nvo', '<Plug>(operator-textmanip-']]}}

  NeoBundleLazy 'thinca/vim-textobj-between', {
    \ 'autoload' : {
    \   'commands' : 'TextobjBetweenDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-between-']]}}

  NeoBundleLazy 'thinca/vim-textobj-comment', {
    \ 'autoload' : {
    \   'commands' : 'TextobjCommentDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-comment-']]}}

  NeoBundleLazy 'rhysd/vim-textobj-continuous-line', {
    \ 'autoload' : {
    \   'commands' : 'TextobjContinuousDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-continuous-']]}}

  NeoBundleLazy 'kana/vim-textobj-datetime', {
    \ 'autoload' : {
    \   'commands' : 'TextobjDatetimeDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-datetime-']]}}

  NeoBundleLazy 'kana/vim-textobj-diff', {
    \ 'autoload' : {
    \   'commands' : 'TextobjDiffDefaultKeyMappings',
    \   'mappings' : [['nvo', '<Plug>(textobj-diff-']]}}

  NeoBundleLazy 'deris/vim-textobj-enclosedsyntax', {
    \ 'autoload' : {
    \   'commands' : 'TextobjEnclosedsyntaxDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-enclosedsyntax-']]}}

  NeoBundleLazy 'kana/vim-textobj-entire', {
    \ 'autoload' : {
    \   'commands' : 'TextobjEntireDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-entire-']]}}

  NeoBundleLazy 'kana/vim-textobj-fold', {
    \ 'autoload' : {
    \   'commands' : 'TextobjFoldDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-fold-']]}}

  NeoBundleLazy 'kana/vim-textobj-function', {
    \ 'autoload' : {
    \   'commands' : 'TextobjFunctionDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-function-']]},
    \ 'depends' : [
    \   'thinca/vim-textobj-function-javascript',
    \   'thinca/vim-textobj-function-perl',
    \   't9md/vim-textobj-function-ruby']}

  NeoBundleLazy 'anyakichi/vim-textobj-ifdef', {
    \ 'autoload' : {
    \   'commands' : 'TextobjIfdefDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-ifdef-']]}}

  NeoBundleLazy 'glts/vim-textobj-indblock', {
    \ 'autoload' : {
    \   'commands' : 'TextobjIndblockDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-indblock-']]}}

  NeoBundleLazy 'kana/vim-textobj-indent', {
    \ 'autoload' : {
    \   'commands' : 'TextobjIndentDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-indent-']]}}

  NeoBundleLazy 'kana/vim-textobj-jabraces', {
    \ 'autoload' : {
    \   'commands' : 'TextobjJabracesDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-jabraces-']]}}

  NeoBundleLazy 'kana/vim-textobj-line', {
    \ 'autoload' : {
    \   'commands' : 'TextobjLineDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-line-']]}}

  NeoBundleLazy 'hchbaw/textobj-motionmotion.vim', {
    \ 'autoload' : {
    \   'commands' : 'TextobjMotionmotionDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-motionmotion-']]}}

  NeoBundleLazy 'osyo-manga/vim-textobj-multiblock', {
    \ 'autoload' : {
    \   'commands' : 'TextobjMultiblockDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-multiblock-']]}}

  NeoBundleLazy 'osyo-manga/vim-textobj-multitextobj', {
    \ 'autoload' : {
    \   'commands' : 'TextobjMultitextobjDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-multitextobj-']],
    \   'functions' : [
    \     'textobj#multitextobj#mapexpr_a',
    \     'textobj#multitextobj#mapexpr_i']},
    \ 'depends' : 'kana/vim-textobj-jabraces'}

  NeoBundleLazy 'sgur/vim-textobj-parameter', {
    \ 'autoload' : {
    \   'commands' : 'TextobjParameterDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-parameter-']]}}

  NeoBundleLazy 'akiyan/vim-textobj-php', {
    \ 'autoload' : {
    \   'commands' : 'TextobjPhpDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-php-']]}}

  NeoBundleLazy 'bps/vim-textobj-python', {
    \ 'autoload' : {
    \   'commands' : 'TextobjPythonDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-python-']]}}

  NeoBundleLazy 'rhysd/vim-textobj-ruby', {
    \ 'autoload' : {
    \   'commands' : 'TextobjRubyDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-ruby-']]}}

  NeoBundleLazy 'vimtaku/vim-textobj-sigil', {
    \ 'autoload' : {
    \   'commands' : 'TextobjSigilDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-sigil-']]}}

  NeoBundleLazy 'saihoooooooo/vim-textobj-space', {
    \ 'autoload' : {
    \   'commands' : 'TextobjSpaceDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-space-']]}}

  NeoBundleLazy 'kana/vim-textobj-syntax', {
    \ 'autoload' : {
    \   'commands' : 'TextobjSyntaxDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-syntax-']]}}

  NeoBundleLazy 'mattn/vim-textobj-url', {
    \ 'autoload' : {
    \   'commands' : 'TextobjUrlDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-url-']]}}

  NeoBundleLazy 'kana/vim-textobj-user', {
    \ 'autoload' : {
    \   'function_prefix' : 'textobj'}}

  NeoBundleLazy 'DeaR/vim-textobj-wiw', {
    \ 'autoload' : {
    \   'commands' : 'TextobjWiwDefaultKeyMappings',
    \   'mappings' : [['nvo', '<Plug>(textobj-wiw-']]}}

  NeoBundleLazy 'rhysd/textobj-word-column.vim', {
    \ 'autoload' : {
    \   'commands' : 'TextobjWordcolumnDefaultKeyMappings',
    \   'mappings' : [['nvo', '<Plug>(textobj-wordcolumn-']]}}

  NeoBundleLazy 'akiyan/vim-textobj-xml-attribute', {
    \ 'autoload' : {
    \   'commands' : 'TextobjXmlattributeDefaultKeyMappings',
    \   'mappings' : [['vo', '<Plug>(textobj-xmlattribute-']]}}

  if has('win32') || s:executable('aclocal')
    NeoBundleFetch 'ggreer/the_silver_searcher', {
      \ 'build' : {
      \   'windows' :
      \     'mingw32-make -f ~/.vim/tools/the_silver_searcher/Makefile.w32',
      \   'others'  :
      \     './build.sh && sudo make install'}}
  endif

  NeoBundleLazy 'zaiste/tmux.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'tmux'}}

  NeoBundleLazy 'mbbill/undotree', {
    \ 'autoload' : {
    \   'commands' : 'UndotreeToggle',
    \   'functions' : 'UndotreeToggle'}}

  NeoBundle 'Shougo/unite.vim'
  call extend(s:neocompl_vim_completefuncs, {
    \ 'Unite'                   : 'unite#complete_source',
    \ 'UniteWithCurrentDir'     : 'unite#complete_source',
    \ 'UniteWithBufferDir'      : 'unite#complete_source',
    \ 'UniteWithCursorWord'     : 'unite#complete_source',
    \ 'UniteWithInput'          : 'unite#complete_source',
    \ 'UniteWithInputDirectory' : 'unite#complete_source',
    \ 'UniteResume'             : 'unite#complete_buffer_name'})

  NeoBundleLazy 'Shougo/unite-build', {
    \ 'autoload' : {
    \   'unite_sources' : 'build'}}

  NeoBundleLazy 'osyo-manga/unite-filetype', {
    \ 'autoload' : {
    \   'unite_sources' : 'filetype'}}

  NeoBundleLazy 'osyo-manga/unite-fold', {
    \ 'autoload' : {
    \   'unite_sources' : 'fold'}}

  NeoBundleLazy 'ujihisa/unite-haskellimport', {
    \ 'autoload' : {
    \   'commands' : 'Haskellimport',
    \   'unite_sources' : 'haskellimport'}}

  NeoBundleLazy 'tsukkee/unite-help', {
    \ 'autoload' : {
    \   'unite_sources' : 'help'}}

  NeoBundleLazy 'thinca/vim-unite-history', {
    \ 'autoload' : {
    \   'unite_sources' : ['history/command', 'history/search']}}

  NeoBundleLazy 'KamunagiChiduru/unite-javaimport', {
    \ 'autoload' : {
    \   'unite_sources' : 'javaimport'}}

  NeoBundleLazy 'ujihisa/unite-locate', {
    \ 'autoload' : {
    \   'unite_sources' : 'locate'}}

  NeoBundleLazy 'tacroe/unite-mark', {
    \ 'autoload' : {
    \   'unite_sources' : 'mark'}}

  NeoBundleLazy 'Shougo/unite-outline', {
    \ 'autoload' : {
    \   'unite_sources' : 'outline'}}

  NeoBundleLazy 'y-uuki/unite-perl-module.vim', {
    \ 'autoload' : {
    \   'unite_sources' : ['perl/global', 'perl/local']}}

  NeoBundleLazy 'osyo-manga/unite-quickfix', {
    \ 'autoload' : {
    \   'unite_sources' : ['location_list', 'quickfix']}}

  NeoBundleLazy 'osyo-manga/unite-quickrun_config', {
    \ 'autoload' : {
    \   'unite_sources' : 'quickrun_config'},
    \ 'depends' : 'thinca/vim-quickrun'}

  if has('clientserver')
    NeoBundleLazy 'mattn/unite-remotefile', {
      \ 'autoload' : {
      \   'unite_sources' : 'remotefile'}}
  endif

  NeoBundleLazy 'rhysd/unite-ruby-require.vim', {
    \ 'autoload' : {
    \   'unite_sources' : 'ruby/require'}}

  NeoBundleLazy 'Shougo/unite-ssh', {
    \ 'autoload' : {
    \   'unite_sources' : 'ssh'},
    \ 'depends' : 'Shougo/vimfiler.vim'}
  autocmd MyVimrc User VimrcPost
    \ if has('vim_starting') && filter(argv(), 'v:val =~# "^ssh:"') != [] |
    \   NeoBundleSource unite-ssh |
    \ endif

  NeoBundleLazy 'Shougo/unite-sudo', {
    \ 'autoload' : {
    \   'unite_sources' : 'sudo'},
    \ 'depends' : 'Shougo/vimfiler.vim'}
  autocmd MyVimrc User VimrcPost
    \ if has('vim_starting') && filter(argv(), 'v:val =~# "^sudo:"') != [] |
    \   NeoBundleSource unite-sudo |
    \ endif

  NeoBundleLazy 'tsukkee/unite-tag', {
    \ 'autoload' : {
    \   'unite_sources' : 'tag'}}

  NeoBundleLazy 'pasela/unite-webcolorname', {
    \ 'autoload' : {
    \   'unite_sources' : 'webcolorname'}}

  NeoBundleLazy 'vbnet.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'vbnet'}}

  if has('iconv')
    NeoBundleLazy 'koron/verifyenc-vim', {
      \ 'autoload' : {
      \   'commands' : 'VerifyEnc'}}
    autocmd MyVimrc BufReadPre *
      \ NeoBundleSource verifyenc
  endif

  NeoBundleLazy 'Shougo/vim-vcs', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'Vcs',
    \      'complete' : 'customlist,vcs#complete'}]}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'Vcs' : 'vcs#complete'})

  NeoBundleLazy 'rbtnn/vimconsole.vim', {
    \ 'autoload' : {
    \   'commands' : [
    \     'VimConsoleOpen', 'VimConsoleClose', 'VimConsoleToggle',
    \     'VimConsoleTest', 'VimConsoleClear', 'VimConsoleRedraw',
    \     'VimConsoleDump',
    \     {'name' : 'VimConsole',
    \      'complete' : 'expression'},
    \     {'name' : 'VimConsoleLog',
    \      'complete' : 'expression'},
    \     {'name' : 'VimConsoleWarn',
    \      'complete' : 'expression'},
    \     {'name' : 'VimConsoleError',
    \      'complete' : 'expression'}]}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'VimConsoleLog'   : 'expression',
    \ 'VimConsoleWarn'  : 'expression',
    \ 'VimConsoleError' : 'expression'})

  if has('multi_lang')
    NeoBundleLazy 'vim-jp/vimdoc-ja', {
      \ 'autoload' : {
      \   'filetypes' : 'help'}}
  endif

  NeoBundleLazy 'Shougo/vimfiler.vim', {
    \ 'autoload' : {
    \   'commands' : [
    \     'VimFilerDetectDrives', 'VimFilerClose',
    \     {'name' : 'VimFiler',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerDouble',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerCurrentDir',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerBufferDir',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerCreate',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerSimple',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerSplit',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerTab',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'VimFilerExplorer',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'Edit',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'Read',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'Source',
    \      'complete' : 'customlist,vimfiler#complete'},
    \     {'name' : 'Write',
    \      'complete' : 'customlist,vimfiler#complete'}],
    \   'unite_sources' : [
    \     'vimfiler/drive', 'vimfiler/execute', 'vimfiler/history',
    \     'vimfiler/mask',  'vimfiler/popd',    'vimfiler/sort'],
    \   'explorer' : 1}}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'VimFiler'           : 'vimfiler#complete',
    \ 'VimFilerDouble'     : 'vimfiler#complete',
    \ 'VimFilerCurrentDir' : 'vimfiler#complete',
    \ 'VimFilerBufferDir'  : 'vimfiler#complete',
    \ 'VimFilerCreate'     : 'vimfiler#complete',
    \ 'VimFilerSimple'     : 'vimfiler#complete',
    \ 'VimFilerSplit'      : 'vimfiler#complete',
    \ 'VimFilerTab'        : 'vimfiler#complete',
    \ 'VimFilerExplorer'   : 'vimfiler#complete',
    \ 'Edit'               : 'vimfiler#complete',
    \ 'Read'               : 'vimfiler#complete',
    \ 'Source'             : 'vimfiler#complete',
    \ 'Write'              : 'vimfiler#complete'})

  NeoBundleLazy 'syngan/vim-vimlint'

  NeoBundleLazy 'ynkdir/vim-vimlparser'

  NeoBundleLazy 'Shougo/vimproc.vim', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'VimProcBang',
    \      'complete' : 'shellcmd'},
    \     {'name' : 'VimProcRead',
    \      'complete' : 'shellcmd'}]},
    \ 'build' : {
    \   'windows' : $VCVARSALL . ' ' . $PROCESSOR_ARCHITECTURE . ' & ' .
    \     'nmake -f Make_msvc.mak nodebug=1',
    \   'others'  : 'make'}}

  NeoBundleLazy 'Shougo/vimshell.vim', {
    \ 'autoload' : {
    \   'filetypes' : 'vimshrc',
    \   'commands' : [
    \     'VimShellSendString', 'VimShellSendBuffer',
    \     {'name' : 'VimShell',
    \      'complete' : 'customlist,vimshell#complete'},
    \     {'name' : 'VimShellCreate',
    \      'complete' : 'customlist,vimshell#complete'},
    \     {'name' : 'VimShellTab',
    \      'complete' : 'customlist,vimshell#complete'},
    \     {'name' : 'VimShellPop',
    \      'complete' : 'customlist,vimshell#complete'},
    \     {'name' : 'VimShellCurrentDir',
    \      'complete' : 'customlist,vimshell#complete'},
    \     {'name' : 'VimShellBufferDir',
    \      'complete' : 'customlist,vimshell#complete'},
    \     {'name' : 'VimShellExecute',
    \      'complete' : 'customlist,vimshell#vimshell_execute_complete'},
    \     {'name' : 'VimShellInteractive',
    \      'complete' : 'customlist,vimshell#vimshell_execute_complete'},
    \     {'name' : 'VimShellTerminal',
    \      'complete' : 'customlist,vimshell#vimshell_execute_complete'}],
    \   'unite_sources' : ['vimshell/external_history', 'vimshell/history']},
    \ 'depends' : [
    \   'yomi322/vim-gitcomplete',
    \   'ujihisa/vimshell-ssh']}
  call extend(s:neocompl_vim_completefuncs, {
    \ 'VimShell'            : 'vimshell#complete',
    \ 'VimShellCreate'      : 'vimshell#complete',
    \ 'VimShellPop'         : 'vimshell#complete',
    \ 'VimShellTab'         : 'vimshell#complete',
    \ 'VimShellCurrentDir'  : 'vimshell#complete',
    \ 'VimShellBufferDir'   : 'vimshell#complete',
    \ 'VimShellExecute'     : 'vimshell#vimshell_execute_complete',
    \ 'VimShellInteractive' : 'vimshell#vimshell_execute_complete',
    \ 'VimShellTerminal'    : 'vimshell#vimshell_execute_complete'})

  if has('python') || has('python3')
    " NeoBundleLazy 'Shougo/vinarise.vim', {
    "   \ 'autoload' : {
    "   \   'commands' : [
    "   \     {'name' : 'Vinarise',
    "   \      'complete' : 'customlist,vinarise#complete'},
    "   \     {'name' : 'VinariseDump',
    "   \      'complete' : 'customlist,vinarise#complete'},
    "   \     {'name' : 'VinariseScript2Hex',
    "   \      'complete' : 'customlist,vinarise#complete'}],
    "   \   'unite_sources' : 'vinarise/analysis'},
    "   \ 'depends' : 'rbtnn/hexript.vim'}
    " call extend(s:neocompl_vim_completefuncs, {
    "   \ 'Vinarise'           : 'vinarise#complete',
    "   \ 'VinariseDump'       : 'vinarise#complete',
    "   \ 'VinariseScript2Hex' : 'vinarise#complete'})
    NeoBundleLazy 'Shougo/vinarise.vim', {
      \ 'autoload' : {
      \   'commands' : [
      \     {'name' : 'Vinarise',
      \      'complete' : 'customlist,vinarise#complete'},
      \     {'name' : 'VinariseDump',
      \      'complete' : 'customlist,vinarise#complete'}],
      \   'unite_sources' : 'vinarise/analysis'}}
    call extend(s:neocompl_vim_completefuncs, {
      \ 'Vinarise'     : 'vinarise#complete',
      \ 'VinariseDump' : 'vinarise#complete'})
  endif

  NeoBundleLazy 'thinca/vim-visualstar', {
    \ 'autoload' : {
    \   'mappings' : [['nvo', '<Plug>(visualstar-']]}}

  NeoBundleLazy 'taku25/vim-visualstudio', {
    \ 'autoload' : {
    \   'commands' : [
    \     'VSFindResult1', 'VSFindResult2',
    \     'VSBuild',       'VSBuildNoWait',
    \     'VSReBuild',     'VSReBuildNoWait',
    \     'VSClean',       'VSCleanNoWait',
    \     'VSCompile',     'VSCompileNoWait',
    \     'VSOpenFile',    'VSGetFile',
    \     'VSOutput',      'VSErorrList',
    \     'VSAddBreakPoint']}}

  NeoBundleFetch 'taku25/VisualStudioController'

  NeoBundle 'vim-jp/vital.vim'

  NeoBundleLazy 'osyo-manga/vim-watchdogs', {
    \ 'autoload' : {
    \   'commands' : [
    \     {'name' : 'WatchdogsRun',
    \      'complete' : 'customlist,quickrun#complete'},
    \     {'name' : 'WatchdogsRunSilent',
    \      'complete' : 'customlist,quickrun#complete'},
    \     'WatchdogsRunSweep']},
    \ 'depends' : [
    \   'dbakker/vim-lint',
    \   'thinca/vim-quickrun',
    \   'syngan/vim-vimlint',
    \   'ynkdir/vim-vimlparser']}
  autocmd MyVimrc BufNewFile,BufRead *
    \ NeoBundleSource watchdogs
  call extend(s:neocompl_vim_completefuncs, {
    \ 'WatchdogsRun'       : 'quickrun#complete',
    \ 'WatchdogsRunSilent' : 'quickrun#complete'})

  NeoBundleLazy 'mattn/webapi-vim'

  call neobundle#end()
  execute 'set runtimepath+=' .
    \ join(map(filter(split(glob($HOME . '/.vim/bundle-settings/*'), '\n'),
    \                 'neobundle#is_installed(fnamemodify(v:val, ":t"))'),
    \          'escape(v:val, " ,")'), ',')
  autocmd MyVimrc User VimrcPost
    \ call neobundle#call_hook('on_source')
endif
"}}}
"}}}

"==============================================================================
" General Settings: {{{

"------------------------------------------------------------------------------
" System: {{{
" GUI options
if has('gui_running')
  set guioptions+=M
endif

" Message
set shortmess+=a
set title
set confirm

" Use beep
set errorbells
set novisualbell
set t_vb=

" VimInfo
if s:is_android
  set viminfo+=n/data/data/net.momodalo.app.vimtouch/files/vim/.viminfo
elseif isdirectory($HOME . '/.local')
  set viminfo+=n~/.local/.viminfo
endif
set history=100

" Backup
set nobackup
set swapfile
set undofile
set undodir^=~/.local/.vimundo
autocmd MyVimrc BufNewFile,BufRead *
  \ let &l:undofile = (index(copy(s:ignore_ft), &filetype) < 0)

" ClipBoard
set clipboard=unnamed

" Timeout
set timeout
set timeoutlen=3000
set ttimeoutlen=10
set updatetime=1000

" Hidden buffer
set hidden

" Multi byte charactor width
set ambiwidth=double

" Wild menu
set wildmenu
execute 'set wildignore+=' .
  \ join(map(copy(s:ignore_ext), '''*.'' . escape(v:val, ''\,'')'), ',')

" Mouse
set mouse=a
set nomousefocus
set nomousehide
"}}}

"------------------------------------------------------------------------------
" Display: {{{
" Don't redraw which macro executing
set lazyredraw

" Line number, Ruler, Wrap
set number
set ruler
set wrap
set display=lastline
set scrolloff=5

" Match
set showmatch
set matchtime=1

" Command line
set cmdheight=2
set laststatus=2
set showcmd

" Display NonText
set list
set listchars=eol:$,tab:>-,extends:>,precedes:<
set fillchars=vert:\|

" Help
set helpheight=999

" Conceal
if has('conceal')
  set conceallevel=2
  set concealcursor=nc
endif
"}}}

"------------------------------------------------------------------------------
" Search: {{{
" Options
set ignorecase
set smartcase
set incsearch
set wrapscan

" Highlight
if &t_Co > 2
  set hlsearch
endif

" Grep
if (s:has_neobundle && neobundle#is_installed('jvgrep')) ||
  \ s:executable('jvgrep')
  set grepprg=jvgrep\ -n
elseif (s:has_neobundle && neobundle#is_installed('the_silver_searcher')) ||
  \ s:executable('ag')
  set grepprg=ag\ --line-numbers\ --nocolor\ --nogroup\ --hidden
elseif s:executable('grep')
  set grepprg=grep\ -Hn
else
  set grepprg=internal
endif
"}}}

"------------------------------------------------------------------------------
" Editing: {{{
" Complete
set completeopt=menu,menuone
silent! set completeopt+=noselect

" Format
set nrformats=hex
set formatoptions+=m
set formatoptions+=B

" Free cursor
set virtualedit=block

" Cursor can move to bol & eol
set backspace=indent,eol,start

" Ctags
set showfulltag

" Default file format
set fileformat=unix
set fileformats=unix,dos,mac

" Indent
set shiftwidth=2
set softtabstop=2
set expandtab
set autoindent
set smartindent
set copyindent
set cinoptions=:0,l1,g0,(0,U1,Ws,j1,J1,)20

" Folding
set foldenable
set foldmethod=marker
set foldcolumn=2
set foldlevelstart=99
"}}}

"------------------------------------------------------------------------------
" Status Line: {{{
set statusline=%<%f\ %m%r[
if has('multi_byte')
  set statusline+=%{&fenc!=''?&fenc:&enc}:
endif
set statusline+=%{&ff}]%y%=

if has('multi_byte')
  set statusline+=\ [U+%04B]
endif
set statusline+=\ (%v,%l)/%L

if s:is_lang_ja
  set statusline+=\ %4P
else
  set statusline+=\ %3P
endif
"}}}

"------------------------------------------------------------------------------
" File Encodings: {{{
if has('multi_byte')
  let s:enc_jisx0213 = has('iconv') &&
    \ iconv("\x87\x64\x87\x6a", 'cp932', 'euc-jisx0213') ==# "\xad\xc5\xad\xcb"

  let &fileencodings =
    \ (has('guess_encode') ? 'guess,' : '') .
    \ (s:enc_jisx0213 ? 'iso-2022-jp-3,' : 'iso-2022-jp,') .
    \ 'cp932,' .
    \ (s:enc_jisx0213 ? 'euc-jisx0213,' : '') .
    \ 'euc-jp,ucs-bom'

  let s:last_enc = &encoding
  augroup MyVimrc
    autocmd EncodingChanged *
      \ if s:last_enc !=# &encoding |
      \   let &runtimepath = iconv(&runtimepath, s:last_enc, &encoding) |
      \   let s:last_enc = &encoding |
      \ endif
    autocmd BufReadPost *
      \ if &modifiable && !search('[^\x00-\x7F]', 'cnw') |
      \   setlocal fileencoding= |
      \ endif
  augroup END
endif
"}}}

"------------------------------------------------------------------------------
" Colors: {{{
" Cursor line & column
if has('gui_running') || &t_Co > 255
  set cursorline
  set cursorcolumn

  " No cursor line & column at other window
  augroup MyVimrc
    autocmd BufWinEnter,WinEnter *
      \ let [&l:cursorline, &l:cursorcolumn] =
      \   [!get(b:, 'nocursorline'), !get(b:, 'nocursorcolumn')]
    autocmd BufWinLeave,WinLeave *
      \ setlocal nocursorline nocursorcolumn
  augroup END
endif

" Enable plugin
filetype plugin indent on

" Syntax highlight
syntax on

" Colorscheme
if &t_Co > 255
  silent! colorscheme molokai
endif
"}}}
"}}}

"==============================================================================
" Mappings: {{{

"------------------------------------------------------------------------------
" Multi Mode Mapping: {{{
command! -complete=mapping -nargs=*
  \ NVmap
  \ nmap <args>| vmap <args>
command! -complete=mapping -nargs=*
  \ NXmap
  \ nmap <args>| xmap <args>
command! -complete=mapping -nargs=*
  \ NSmap
  \ nmap <args>| smap <args>
command! -complete=mapping -nargs=*
  \ NOmap
  \ nmap <args>| omap <args>
command! -complete=mapping -nargs=*
  \ VOmap
  \ vmap <args>| omap <args>
command! -complete=mapping -nargs=*
  \ XOmap
  \ xmap <args>| omap <args>
command! -complete=mapping -nargs=*
  \ SOmap
  \ smap <args>| omap <args>
command! -complete=mapping -nargs=*
  \ NXOmap
  \ nmap <args>| xmap <args>| omap <args>
command! -complete=mapping -nargs=*
  \ NSOmap
  \ nmap <args>| smap <args>| omap <args>

command! -complete=mapping -nargs=*
  \ NVnoremap
  \ nnoremap <args>| vnoremap <args>
command! -complete=mapping -nargs=*
  \ NXnoremap
  \ nnoremap <args>| xnoremap <args>
command! -complete=mapping -nargs=*
  \ NSnoremap
  \ nnoremap <args>| snoremap <args>
command! -complete=mapping -nargs=*
  \ NOnoremap
  \ nnoremap <args>| onoremap <args>
command! -complete=mapping -nargs=*
  \ VOnoremap
  \ vnoremap <args>| onoremap <args>
command! -complete=mapping -nargs=*
  \ XOnoremap
  \ xnoremap <args>| onoremap <args>
command! -complete=mapping -nargs=*
  \ SOnoremap
  \ snoremap <args>| onoremap <args>
command! -complete=mapping -nargs=*
  \ NXOnoremap
  \ nnoremap <args>| xnoremap <args>| onoremap <args>
command! -complete=mapping -nargs=*
  \ NSOnoremap
  \ nnoremap <args>| snoremap <args>| onoremap <args>
"}}}

"------------------------------------------------------------------------------
" Common: {{{
" <Leader> <LocalLeader>
NXOnoremap <Leader>      <Nop>
NXOnoremap <LocalLeader> <Nop>

" Prefix
NXOnoremap ;     <Nop>
NXOnoremap ,     <Nop>
NXOnoremap s     <Nop>
NXOnoremap S     <Nop>
NXOnoremap m     <Nop>
NXOnoremap M     <Nop>
NOnoremap  <C-G> <Nop>
cnoremap   <C-G> <Nop>

" Split Nicely
NXnoremap <expr> <SID>(split-nicely)
  \ myvimrc#split_nicely_expr() ? '<C-W>s' : '<C-W>v'
"}}}

"------------------------------------------------------------------------------
" Command Line: {{{
if s:cmdwin_enable
  noremap <SID>: q:
  noremap <SID>/ q/
  noremap <SID>? q?
else
  noremap <expr> <SID>: myvimrc#cmdline_enter(':')
  noremap <expr> <SID>/ myvimrc#cmdline_enter('/')
  noremap <expr> <SID>? myvimrc#cmdline_enter('?')
endif

NXmap ;; <SID>:
NXmap :  <SID>:
NXmap /  <SID>/
NXmap ?  <SID>?

NXnoremap <expr> ;: myvimrc#cmdline_enter(':')
NXnoremap <expr> ;/ myvimrc#cmdline_enter('/')
NXnoremap <expr> ;? myvimrc#cmdline_enter('?')

cnoremap <expr> / getcmdtype() == '/' ? '\/' : '/'
cnoremap <expr> ? getcmdtype() == '?' ? '\?' : '?'

augroup MyVimrc
  autocmd CmdwinEnter *
    \ call myvimrc#cmdwin_enter()
  autocmd CmdwinLeave *
    \ call myvimrc#cmdwin_leave()
  autocmd CmdwinEnter /
    \ inoremap <buffer> / \/
  autocmd CmdwinEnter ?
    \ inoremap <buffer> ? \?
augroup END
"}}}

"------------------------------------------------------------------------------
" Escape Key: {{{
nnoremap <expr> <Esc><Esc> myvimrc#escape_key()
"}}}

"------------------------------------------------------------------------------
" Gips: {{{
if s:gips_enable
  noremap <Up>       <Nop>
  noremap <Down>     <Nop>
  noremap <Right>    <Nop>
  noremap <Left>     <Nop>
  noremap <Home>     <Nop>
  noremap <End>      <Nop>
  noremap <PageUp>   <Nop>
  noremap <PageDown> <Nop>
endif
"}}}

"------------------------------------------------------------------------------
" Moving: {{{
" Insert-mode & Command-line-mode
noremap! <M-j> <Down>
noremap! <M-k> <Up>
noremap! <M-h> <Left>
noremap! <M-l> <Right>

" Insert-mode
inoremap <M-w>      <C-O>w
inoremap <M-b>      <C-O>b
inoremap <M-e>      <C-O>e
inoremap <M-g><M-e> <C-O>ge
inoremap <M-W>      <C-O>W
inoremap <M-B>      <C-O>B
inoremap <M-E>      <C-O>E
inoremap <M-g><M-E> <C-O>gE
inoremap <M-f>      <C-O>f
inoremap <M-F>      <C-O>F
inoremap <M-t>      <C-O>t
inoremap <M-T>      <C-O>T
inoremap <M-;>      <C-O>;
inoremap <M-,>      <C-O>,
inoremap <M-(>      <C-O>(
inoremap <M-)>      <C-O>)
inoremap <M-{>      <C-O>{
inoremap <M-}>      <C-O>}

" Command-line-mode
cnoremap <M-H> <Home>
cnoremap <M-L> <End>
cnoremap <M-w> <S-Right>
cnoremap <M-b> <S-Left>

" Jump
NXOnoremap ' `
NXOnoremap ` '
nnoremap <S-Tab> <C-O>

" Mark
NXOnoremap mj ]`
NXOnoremap mk [`

" Diff
NXOnoremap <C-J> ]c
NXOnoremap <C-K> [c

" Command-line
cnoremap <expr> <C-H>
  \ getcmdtype() == '@' && getcmdpos() == 1 && getcmdline() == '' ?
  \   '<Esc>' : '<C-H>'
cnoremap <expr> <BS>
  \ getcmdtype() == '@' && getcmdpos() == 1 && getcmdline() == '' ?
  \   '<Esc>' : '<BS>'
"}}}

"------------------------------------------------------------------------------
" Window Control: {{{
NXnoremap <M-s>   <C-W>s
NXnoremap <M-v>   <C-W>v
NXnoremap <M-j>   <C-W>j
NXnoremap <M-k>   <C-W>k
NXnoremap <M-h>   <C-W>h
NXnoremap <M-l>   <C-W>l
NXnoremap <M-J>   <C-W>J
NXnoremap <M-K>   <C-W>K
NXnoremap <M-H>   <C-W>H
NXnoremap <M-L>   <C-W>L
NXnoremap <M-=>   <C-W>=
NXnoremap <M-->   <C-W>-
NXnoremap <M-+>   <C-W>+
NXnoremap <M-_>   <C-W>_
NXnoremap <M-<>   <C-W><
NXnoremap <M->>   <C-W>>
NXnoremap <M-Bar> <C-W><Bar>
"}}}

"------------------------------------------------------------------------------
" Leader Prefix: {{{
NXnoremap <Leader>c     :<C-U>close<CR>
NXnoremap <Leader>C     :<C-U>only<CR>
NXnoremap <Leader><M-c> :<C-U>tabclose<CR>
NXnoremap <Leader><M-C> :<C-U>tabonly<CR>
NXnoremap <Leader>w     :<C-U>update<CR>
NXnoremap <Leader>W     :<C-U>wall<CR>
NXnoremap <Leader>q     :<C-U>bdelete<CR>
NXnoremap <Leader>!     :<C-U>shell<CR>
NXnoremap <Leader>B     :<C-U>buffers<CR>
NXnoremap <Leader>E     :<C-U>Explorer<CR>
NXnoremap <Leader>T     :<C-U>tabs<CR>
NXnoremap <Leader>j     :<C-U>jumps<CR>
NXnoremap <Leader>J     :<C-U>changes<CR>
NXnoremap <Leader><C-D> :<C-U>pwd<CR>
NXnoremap <script> <Leader>e <SID>:<C-U>edit<Space>
NXnoremap <script> <Leader>b <SID>:<C-U>buffer<Space>
NXnoremap <script> <Leader>t <SID>:<C-U>tabm<Space>
NXnoremap <script> <Leader>d <SID>:<C-U>lcd<Space>
NXnoremap <script> <Leader>D <SID>:<C-U>cd<Space>
NXnoremap <expr> <Leader>Q
  \ ':<C-U>1,' . bufnr('$') . 'bdelete<CR>'
NXnoremap <script><expr> <Leader><M-d>
  \ '<SID>:<C-U>lcd ' .
  \ expand('%:p:h' . (has('win32') ? ':gs?\\?/?' : '')) .
  \ '/'
NXnoremap <script><expr> <Leader><M-D>
  \ '<SID>:<C-U>cd ' .
  \ expand('%:p:h' . (has('win32') ? ':gs?\\?/?' : '')) .
  \ '/'
"}}}

"------------------------------------------------------------------------------
" Search: {{{
NXOmap g/ *
NXOmap g? #

NXnoremap <script> <C-W>/  <SID>(split-nicely)<SID>/
NXnoremap <script> <C-W>?  <SID>(split-nicely)<SID>?
NXnoremap <script> <C-W>*  <SID>(split-nicely)*
NXnoremap <script> <C-W>#  <SID>(split-nicely)#
NXnoremap <script> <C-W>g* <SID>(split-nicely)g*
NXnoremap <script> <C-W>g# <SID>(split-nicely)g#
NXmap <C-W>g/ <C-W>*
NXmap <C-W>g? <C-W>#

NXOnoremap <expr> n
  \ myvimrc#search_forward_expr() ? 'n' : 'N'
NXOnoremap <expr> N
  \ myvimrc#search_forward_expr() ? 'N' : 'n'
"}}}

"------------------------------------------------------------------------------
" Help: {{{
inoremap <expr> <F1>
  \ myvimrc#split_nicely_expr() ?
  \   '<Esc>:<C-U>help<Space>' :
  \   '<Esc>:<C-U>vertical help<Space>'
nnoremap <expr> <F1>
  \ myvimrc#split_nicely_expr() ?
  \   ':<C-U>help<Space>' :
  \   ':<C-U>vertical help<Space>'
nnoremap <expr> <F2>
  \ myvimrc#split_nicely_expr() ?
  \   ':<C-U>help ' . expand('<cword>') . '<CR>' :
  \   ':<C-U>vertical help ' . expand('<cword>') . '<CR>'
"}}}

"------------------------------------------------------------------------------
" Auto Mark: {{{
nnoremap <expr> mm myvimrc#auto_mark()
nnoremap <expr> mc myvimrc#clear_marks()
nnoremap <expr> mM myvimrc#auto_file_mark()
nnoremap <expr> mC myvimrc#clear_file_marks()
nnoremap <expr> ml myvimrc#marks()
"}}}

"------------------------------------------------------------------------------
" Smart BOL: {{{
NXOnoremap <expr> H myvimrc#smart_bol()
NXOnoremap <expr> L myvimrc#smart_eol()
inoremap <expr> <M-H> '<C-O>' . myvimrc#smart_bol()
inoremap <expr> <M-L> '<C-O>' . myvimrc#smart_eol()
"}}}

"------------------------------------------------------------------------------
" Smart Close: {{{
autocmd MyVimrc FileType *
  \ if (&readonly || !&modifiable) && maparg('q', 'n') == '' |
  \   nnoremap <buffer><expr> q
  \     winnr('$') != 1 ? ':<C-U>close<CR>' : ''|
  \ endif
"}}}

"------------------------------------------------------------------------------
" Line Number: {{{
nnoremap <F12> :<C-U>call myvimrc#toggle_line_number_style()<CR>
"}}}

"------------------------------------------------------------------------------
" Insert One Character: {{{
nnoremap  <expr> <M-a> myvimrc#insert_one_char('a')
NXnoremap <expr> <M-A> myvimrc#insert_one_char('A')
nnoremap  <expr> <M-i> myvimrc#insert_one_char('i')
NXnoremap <expr> <M-I> myvimrc#insert_one_char('I')
"}}}

"------------------------------------------------------------------------------
" Others: {{{
" Paste
set pastetoggle=<F11>
nnoremap  <F11> :<C-U>set paste! paste?<CR>
NXnoremap <C-P> :<C-U>registers<CR>
inoremap  <C-P> <C-O>:<C-U>registers<CR>
noremap!  <M-p> <C-R>"

" BackSpace
nnoremap <BS> X

" Yank to end of line
nnoremap Y y$

" Tabs
NXnoremap g<M-t> :<C-U>tabmove +1<CR>
NXnoremap g<M-T> :<C-U>tabmove -1<CR>

" Undo branch
nnoremap <M-u> :<C-U>undolist<CR>

" New line
nnoremap <M-o>
  \ :<C-U>call append(line('.'), repeat([''], v:count1))<CR>
nnoremap <M-O>
  \ :<C-U>call append(line('.') - 1, repeat([''], v:count1))<CR>

" The precious area text object
onoremap gv :<C-U>normal! gv<CR>

" The last changed area text object
nnoremap  g[ `[v`]
XOnoremap g[ :<C-U>normal g[<CR>

" Delete at Insert-mode
inoremap <C-W> <C-G>u<C-W>
inoremap <C-U> <C-G>u<C-U>
"}}}

"------------------------------------------------------------------------------
" Evacuation: {{{
" Mark
nnoremap <M-m> m

" Repeat find
NXOnoremap <M-;> ;
NXOnoremap <M-,> ,

" Jump
NXOnoremap gH H
NXOnoremap gM M
NXOnoremap gL L

" FileInfo
nnoremap <C-G><C-G> <C-G>

" To Select-mode
nnoremap <C-G>h     gh
nnoremap <C-G>H     gH
nnoremap <C-G><C-H> g<C-H>

" Macro
NXnoremap <M-q> q
NXnoremap Q     @
NXnoremap Q;    @:
NXnoremap QQ    @@

" Dangerous key
nnoremap ZQ    <Nop>
nnoremap ZZ    <Nop>
nnoremap gQ    gq
inoremap <C-C> <Esc>

" Insert Tab
inoremap <C-T> <C-V><Tab>

" Rot13
NXOnoremap s?  g?
nnoremap   s?? g??
"}}}
"}}}

"==============================================================================
" Commands: {{{

"------------------------------------------------------------------------------
" Change File Format Option: {{{
command! -bar
  \ FfUnix
  \ setlocal fileformat=unix
command! -bar
  \ FfDos
  \ setlocal fileformat=dos
command! -bar
  \ FfMac
  \ setlocal fileformat=mac
"}}}

"------------------------------------------------------------------------------
" Change File Encoding Option: {{{
if has('multi_byte')
  command! -bar
    \ FencUtf8
    \ setlocal fileencoding=utf-8
  command! -bar
    \ FencUtf16le
    \ setlocal fileencoding=utf-16le
  command! -bar
    \ FencUtf16
    \ setlocal fileencoding=utf-16
  command! -bar
    \ FencCp932
    \ setlocal fileencoding=cp932
  command! -bar
    \ FencEucjp
    \ setlocal fileencoding=euc-jp
  if s:enc_jisx0213
    command! -bar
      \ FencEucJisx0213
      \ setlocal fileencoding=euc-jisx0213
    command! -bar
      \ FencIso2022jp
      \ setlocal fileencoding=iso-2022-jp-3
  else
    command! -bar
      \ FencIso2022jp
      \ setlocal fileencoding=iso-2022-jp
  endif
endif
"}}}

"------------------------------------------------------------------------------
" Open With A Specific Character Code Again: {{{
if has('multi_byte')
  command! -bang -bar -complete=file -nargs=?
    \ EditUtf8
    \ edit<bang> ++enc=utf-8 <args>
  command! -bang -bar -complete=file -nargs=?
    \ EditUtf16le
    \ edit<bang> ++enc=utf-16le <args>
  command! -bang -bar -complete=file -nargs=?
    \ EditUtf16
    \ edit<bang> ++enc=utf-16 <args>
  command! -bang -bar -complete=file -nargs=?
    \ EditCp932
    \ edit<bang> ++enc=cp932 <args>
  command! -bang -bar -complete=file -nargs=?
    \ EditEucjp
    \ edit<bang> ++enc=euc-jp <args>
  if s:enc_jisx0213
    command! -bang -bar -complete=file -nargs=?
      \ EditEucJisx0213
      \ edit<bang> ++enc=euc-jisx0213 <args>
    command! -bang -bar -complete=file -nargs=?
      \ EditIso2022jp
      \ edit<bang> ++enc=iso-2022-jp-3 <args>
  else
    command! -bang -bar -complete=file -nargs=?
      \ EditIso2022jp
      \ edit<bang> ++enc=iso-2022-jp <args>
  endif
endif
"}}}

"------------------------------------------------------------------------------
" Shell Setting: {{{
if has('win32')
  command! -bar
    \ ShellCmd
    \ call myvimrc#set_shell(s:default_shell)
  command! -bar -nargs=?
    \ ShellSh
    \ call myvimrc#set_shell([<q-args> != '' ? <q-args> : 'sh', 1, '-c', '', '"'])
endif
"}}}

"------------------------------------------------------------------------------
" VC Vars: {{{
if exists('$VCVARSALL')
  command! -bar
    \ VCVars32
    \ call myvimrc#vcvarsall('x86')

  if exists('$PROGRAMFILES(X86)')
    command! -bar
      \ VCVars64
      \ call myvimrc#vcvarsall(exists('PROCESSOR_ARCHITEW6432') ?
      \   $PROCESSOR_ARCHITEW6432 : $PROCESSOR_ARCHITECTURE)
  endif
endif
"}}}

"------------------------------------------------------------------------------
" QuickFix Toggle: {{{
command! -bar -nargs=?
  \ CToggle
  \ call myvimrc#toggle_quickfix('c', <q-args>)
command! -bar -nargs=?
  \ LToggle
  \ call myvimrc#toggle_quickfix('l', <q-args>)

NXnoremap <C-W>, :<C-U>CToggle<CR>
NXnoremap <C-W>. :<C-U>LToggle<CR>

augroup MyVimrc
  autocmd QuickFixCmdPost [^l]*
    \ cwindow
  autocmd QuickFixCmdPost l*
    \ lwindow
augroup END
"}}}

"------------------------------------------------------------------------------
" From CmdEx: {{{
command! -bar -nargs=1 -complete=file
  \ Diff
  \ vertical diffsplit <args>
command! -bar
  \ Undiff
  \ diffoff |
  \ setlocal scrollbind< cursorbind< wrap< foldmethod< foldcolumn< |
  \ execute 'doautocmd' (s:has_patch(7, 3, 438) ? '<nomodeline>' : '')
  \ 'FileType'

nnoremap <F8> :<C-U>Undiff<CR>
"}}}

"------------------------------------------------------------------------------
" From Example: {{{
command! -bar
  \ DiffOrig
  \ let s:save_ft = &l:filetype | vertical new | setlocal buftype=nofile |
  \ read # | 0d_ | let &l:filetype = s:save_ft | unlet s:save_ft |
  \ diffthis | wincmd p | diffthis

nnoremap <F6> :<C-U>DiffOrig<CR>
"}}}
"}}}

"==============================================================================
" Vim Script: {{{

"------------------------------------------------------------------------------
" Auto MkDir: {{{
autocmd MyVimrc BufWritePre *
  \ call myvimrc#auto_mkdir(expand('<afile>:p:h'), v:cmdbang)
"}}}

"------------------------------------------------------------------------------
" Functions Of Highlight: {{{
function! s:get_highlight(hi)
  redir => hl
  silent execute 'highlight' a:hi
  redir END
  let hl = substitute(hl, '[\r\n]', ' ', 'g')
  return matchstr(hl, 'xxx\zs.*$')
endfunction

function! s:_reverse_highlight(hl, name)
  let s = matchstr(a:hl, a:name . '=\zs\S\+')
  if s =~ '\%(re\|in\)verse'
    return substitute(
      \ s, '\%(\%(re\|in\)verse,\?\|,\%(re\|in\)verse\)', '', 'g')
  elseif s != '' && s != 'NONE'
    return s . ',reverse'
  else
    return 'reverse'
  endif
endfunction

function! s:reverse_highlight(hl)
  return a:hl .
    \ ' term='  . s:_reverse_highlight(a:hl, 'term') .
    \ ' cterm=' . s:_reverse_highlight(a:hl, 'cterm') .
    \ ' gui='   . s:_reverse_highlight(a:hl, 'gui')
endfunction
"}}}

"------------------------------------------------------------------------------
" Reverse Status Line Color At Insert Mode: {{{
function! s:set_status_line_color(is_enter, force)
  if !exists('s:hi_status_line') || !exists('s:hi_status_line_i') || a:force
    silent! let s:hi_status_line   = s:get_highlight('StatusLine')
    silent! let s:hi_status_line_i = s:reverse_highlight(s:hi_status_line)
  endif

  if exists('s:hi_status_line') && exists('s:hi_status_line_i')
    highlight clear StatusLine
    if a:is_enter
      execute 'highlight StatusLine' s:hi_status_line_i
    else
      execute 'highlight StatusLine' s:hi_status_line
    endif
  endif
endfunction

augroup MyVimrc
  autocmd ColorScheme *
    \ call s:set_status_line_color(mode() =~# '[iR]', 1)
  autocmd InsertEnter *
    \ call s:set_status_line_color(1, 0)
  autocmd InsertLeave *
    \ call s:set_status_line_color(0, 0)
augroup END
"}}}

"------------------------------------------------------------------------------
" Highlight Ideographic Space: {{{
if has('multi_byte')
  function! s:set_ideographic_space(force)
    if !exists('s:hi_ideographic_space') || a:force
      silent! let s:hi_ideographic_space =
        \ s:get_highlight('SpecialKey') .
        \ ' term=underline cterm=underline gui=underline'
    endif

    if exists('s:hi_ideographic_space')
      execute 'highlight IdeographicSpace' s:hi_ideographic_space
      syntax match IdeographicSpace "　" display containedin=ALL
    endif
  endfunction

  augroup MyVimrc
    autocmd ColorScheme *
      \ call s:set_ideographic_space(1)
    autocmd Syntax *
      \ call s:set_ideographic_space(0)
  augroup END
endif
"}}}

"------------------------------------------------------------------------------
" From Example: {{{
autocmd MyVimrc BufRead *
  \ if line('.') == 1 && line("'\"") > 1 && line("'\"") <= line('$') &&
  \     index(copy(s:ignore_ft), &filetype) < 0 |
  \   execute 'normal! g`"' |
  \ endif
"}}}
"}}}

"==============================================================================
" Plugins: {{{

"------------------------------------------------------------------------------
" Built In: {{{
" Assembler
let g:asmsyntax = 'masm'
" let g:asmsyntax = 'z80'
" let g:asmsyntax = 'arm'

" Shell Script
let g:is_bash = 1

" Indent
let g:vim_indent_cont = 2

" Folding
let g:c_no_comment_fold   = 1
let g:c_no_block_fold     = 1
let g:javaScript_fold     = 1
let g:perl_fold           = 1
let g:php_folding         = 1
let g:ruby_fold           = 1
let g:sh_fold_enabled     = 1
let g:vbnet_no_code_folds = 1
let g:vimsyn_folding      = 'af'
let g:xml_syntax_folding  = 1
"}}}

"------------------------------------------------------------------------------
" Justify: {{{
source $VIMRUNTIME/macros/justify.vim
silent! nunmap _j
silent! vunmap _j
silent! nunmap ,gq
silent! vunmap ,gq
"}}}

"------------------------------------------------------------------------------
" MatchIt: {{{
source $VIMRUNTIME/macros/matchit.vim
silent! sunmap %
silent! sunmap g%
silent! sunmap [%
silent! sunmap ]%
silent! sunmap a%

xmap <SID>[% [%
xmap <SID>]% ]%

xnoremap <script> [% <Esc><SID>[%m'gv``
xnoremap <script> ]% <Esc><SID>]%m'gv``
xnoremap <script> a% <Esc><SID>[%v<SID>]%

NXOmap <Space>   %
NXOmap <S-Space> g%
"}}}

"------------------------------------------------------------------------------
" Alignta: {{{
if s:has_neobundle && neobundle#tap('alignta')
  function! neobundle#tapped.hooks.on_source(bundle)
    call operator#user#define(
      \ 'alignta',
      \ 'myvimrc#operator_alignta')
  endfunction

  NXOmap s= <Plug>(operator-alignta)

  nmap s== s=s=
endif
"}}}

"------------------------------------------------------------------------------
" AlterCommand: {{{
if s:has_neobundle && neobundle#tap('altercmd')
  function! neobundle#tapped.hooks.on_post_source(bundle)
    for [key, value] in items(s:altercmd_define)
      execute 'CAlterCommand' key value
    endfor
  endfunction

  autocmd MyVimrc CmdwinEnter :
    \ call myvimrc#cmdwin_enter_altercmd(s:altercmd_define)
endif
"}}}

"------------------------------------------------------------------------------
" Altr: {{{
if s:has_neobundle && neobundle#tap('altr')
  nmap g<M-f>     <Plug>(altr-forward)
  nmap g<M-F>     <Plug>(altr-back)
  nmap <C-W><M-f> <SID>(split-nicely)<Plug>(altr-forward)
  nmap <C-W><M-F> <SID>(split-nicely)<Plug>(altr-back)
endif
"}}}

"------------------------------------------------------------------------------
" Anzu: {{{
if s:has_neobundle && neobundle#tap('anzu')
  set shortmess+=s

  nmap <expr> n
    \ myvimrc#search_forward_expr() ?
    \   '<Plug>(anzu-jump-n)<Plug>(anzu-echo-search-status)' :
    \   '<Plug>(anzu-jump-N)<Plug>(anzu-echo-search-status)'
  nmap <expr> N
    \ myvimrc#search_forward_expr() ?
    \   '<Plug>(anzu-jump-N)<Plug>(anzu-echo-search-status)' :
    \   '<Plug>(anzu-jump-n)<Plug>(anzu-echo-search-status)'
endif
"}}}

"------------------------------------------------------------------------------
" AutoDate: {{{
if s:has_neobundle && neobundle#tap('autodate')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:autodate_lines = 10
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" AutoFmt: {{{
if s:has_neobundle && neobundle#tap('autofmt')
  set formatexpr=autofmt#japanese#formatexpr()
endif
"}}}

"------------------------------------------------------------------------------
" Clever F: {{{
if s:has_neobundle && neobundle#tap('clever-f')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:clever_f_not_overwrites_standard_mappings = 1
    let g:clever_f_fix_key_direction                = 1
    let g:clever_f_use_migemo                       = 1

    nmap <SID>(clever-f-f)              <Plug>(clever-f-f)
    nmap <SID>(clever-f-F)              <Plug>(clever-f-F)
    nmap <SID>(clever-f-t)              <Plug>(clever-f-t)
    nmap <SID>(clever-f-T)              <Plug>(clever-f-T)
    nmap <SID>(clever-f-reset)          <Plug>(clever-f-reset)
    nmap <SID>(clever-f-repeat-forward) <Plug>(clever-f-repeat-forward)
    nmap <SID>(clever-f-repeat-back)    <Plug>(clever-f-repeat-back)

    inoremap <script> <M-f> <C-O><SID>(clever-f-f)
    inoremap <script> <M-F> <C-O><SID>(clever-f-F)
    inoremap <script> <M-t> <C-O><SID>(clever-f-t)
    inoremap <script> <M-T> <C-O><SID>(clever-f-T)
    inoremap <script> <M-.> <C-O><SID>(clever-f-reset)
    inoremap <script> <M-;> <C-O><SID>(clever-f-repeat-forward)
    inoremap <script> <M-,> <C-O><SID>(clever-f-repeat-back)
  endfunction

  NXOmap f     <Plug>(clever-f-f)
  NXOmap F     <Plug>(clever-f-F)
  NXOmap t     <Plug>(clever-f-t)
  NXOmap T     <Plug>(clever-f-T)
  NXOmap <M-.> <Plug>(clever-f-reset)
  NXOmap <M-;> <Plug>(clever-f-repeat-forward)
  NXOmap <M-,> <Plug>(clever-f-repeat-back)
endif
"}}}

"------------------------------------------------------------------------------
" ColumnJump: {{{
if s:has_neobundle && neobundle#tap('columnjump')
  function! neobundle#tapped.hooks.on_source(bundle)
    nmap <SID>(columnjump-backward) <Plug>(columnjump-backward)
    nmap <SID>(columnjump-forward)  <Plug>(columnjump-forward)

    inoremap <script> <M-(> <C-O><SID>(columnjump-backward)
    inoremap <script> <M-)> <C-O><SID>(columnjump-forward)
  endfunction

  NXOmap ( <Plug>(columnjump-backward)
  NXOmap ) <Plug>(columnjump-forward)
endif
"}}}

"------------------------------------------------------------------------------
" EchoDoc: {{{
if s:has_neobundle && neobundle#tap('echodoc')
  function! neobundle#tapped.hooks.on_source(bundle)
    call echodoc#enable()
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" Emmet: {{{
if s:has_neobundle && neobundle#tap('emmet')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:user_emmet_leader_key = '<M-y>'
    let g:user_emmet_settings   = {
      \ 'lang' : 'ja',
      \ 'indentation' : '  ',
      \ 'xml' : {'extends' : 'html'}}
  endfunction

  call extend(s:neocompl_omni_patterns, {
    \ 'emmet#CompleteTag' : '\h\w*'})
endif
"}}}
"}}}

"------------------------------------------------------------------------------
" Eskk: {{{
if s:has_neobundle && neobundle#tap('eskk')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:eskk#directory               = $HOME . '/.local/.eskk'
    let g:eskk#no_default_mappings     = 1
    let g:eskk#start_completion_length = 1
    let g:eskk#dictionary              = {
      \ 'path' : $HOME . '/.skk/jisyo',
      \ 'sorted' : 0,
      \ 'encoding' : 'utf-8'}
    let g:eskk#large_dictionary        = {
      \ 'path' : $HOME . '/.skk/SKK-JISYO.L',
      \ 'sorted' : 1,
      \ 'encoding' : 'euc-jp'}
    let g:eskk#mapped_keys             =
      \ filter(eskk#get_default_mapped_keys(), 'v:val !=? "<Tab>"')
  endfunction

  map! <C-J> <Plug>(eskk:toggle)
  lmap <C-J> <Plug>(eskk:toggle)
endif
"}}}
"}}}

"------------------------------------------------------------------------------
" FT_Lua: {{{
if s:has_neobundle && neobundle#tap('ft_lua')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:lua_complete_omni = 1
    let g:lua_check_syntax  = 0
    let g:lua_check_globals = 0
  endfunction

  call extend(s:neocompl_force_omni_patterns, {
    \ 'xolox#lua#omnifunc' : '\%(\.\|:\)\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" Fugitive: {{{
if s:has_neobundle && neobundle#tap('fugitive')
  function! neobundle#tapped.hooks.on_post_source(bundle)
    call fugitive#detect(expand('%') == '' ? getcwd() : expand('%:p'))
  endfunction

  NXnoremap <Leader>g <Nop>
  NXnoremap <Leader>gd :<C-U>Gdiff<CR>
  NXnoremap <Leader>gs :<C-U>Gstatus<CR>
  NXnoremap <Leader>ga :<C-U>Gwrite<CR>
  NXnoremap <Leader>gc :<C-U>Gcommit<CR>
  NXnoremap <Leader>gC :<C-U>Gcommit --amend<CR>
  NXnoremap <Leader>gb :<C-U>Gblame<CR>
  NXnoremap <expr> <Leader>gl
    \ exists(':Gitv') ? ':<C-U>Gitv<CR>' : ':<C-U>Glog<CR>'

  NXnoremap <script> <Leader>gg <SID>:<C-U>Git<Space>
endif
"}}}

"------------------------------------------------------------------------------
" Goto File: {{{
if s:has_neobundle && neobundle#tap('gf-user')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:gf_user_no_default_key_mappings = 1
  endfunction

  NXmap gf         <Plug>(gf-user-gf)
  NXmap gF         <Plug>(gf-user-gF)
  NXmap <C-W>f     <Plug>(gf-user-<C-w>f)
  NXmap <C-W>F     <Plug>(gf-user-<C-w>F)
  NXmap <C-W>gf    <Plug>(gf-user-<C-w>gf)
  NXmap <C-W>gF    <Plug>(gf-user-<C-w>gF)
  NXmap <C-W><C-F> <Plug>(gf-user-<C-w><C-f>)
endif
"}}}

"------------------------------------------------------------------------------
" Go: {{{
if s:has_neobundle && neobundle#tap('go')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:go_bin_path            = $HOME . '/.local/.vim-go'
    let g:go_disable_autoinstall = 1
  endfunction

  call extend(s:neocompl_force_omni_patterns, {
    \ 'go#complete#Complete' : '\.\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" Grex: {{{
if s:has_neobundle && neobundle#tap('grex')
  NXOmap sD <Plug>(operator-grex-delete)
  NXOmap sY <Plug>(operator-grex-yank)

  nmap sDD sDsD
  nmap sYY sYsY
endif
"}}}

"------------------------------------------------------------------------------
" Hier: {{{
if s:has_neobundle && neobundle#tap('hier')
  autocmd MyVimrc User EscapeKey
    \ HierClear
endif
"}}}

"------------------------------------------------------------------------------
" J6uil: {{{
if s:has_neobundle && neobundle#tap('J6uil')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:J6uil_config_dir             = $HOME . '/.local/.J6uil'
    let g:J6uil_echo_presence          = 0
    let g:J6uil_open_buffer_cmd        = 'tabedit'
    let g:J6uil_no_default_keymappings = 1
    let g:J6uil_user                   = 'DeaR'

    if (has('win32')  && isdirectory($PROGRAMFILES . '/ImageMagick-6.9.0-Q16')) ||
      \ (!has('win32') && s:executable('convert'))
      let g:J6uil_display_icon = 1
    endif
  endfunction

  call extend(s:altercmd_define, {
    \ 'j[6uil]' : 'J6uil'})
endif
"}}}

"------------------------------------------------------------------------------
" Jedi: {{{
if s:has_neobundle && neobundle#tap('jedi')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:jedi#auto_initialization    = 0
    let g:jedi#auto_vim_configuration = 0
    let g:jedi#popup_on_dot           = 0
    let g:jedi#auto_close_doc         = 0
  endfunction

  call extend(s:neocompl_force_omni_patterns, {
    \ 'jedi#completions' : '\.\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" Jvgrep: {{{
if s:has_neobundle && neobundle#tap('jvgrep')
  let $JVGREP_EXCLUDE =
    \ join(map(
    \   copy(s:ignore_ext),
    \   '''\.'' . escape(v:val, ''\*+.?{}()[]^$-|/'') . ''$'''), '|')
endif

"------------------------------------------------------------------------------
" Kwbdi: {{{
if s:has_neobundle && neobundle#tap('kwbdi')
  function! neobundle#tapped.hooks.on_source(bundle)
    command! -bar
      \ Kwbd
      \ call myvimrc#kwbd()
  endfunction

  NXnoremap <Leader>q :<C-U>Kwbd<CR>
  map <SID>Kwbd <Plug>Kwbd

  call extend(s:altercmd_define, {
    \ 'bd[elete]' : 'Kwbd',
    \
    \ '_bd[elete]' : 'bdelete'})
endif
"}}}

"------------------------------------------------------------------------------
" Localrc: {{{
if s:has_neobundle && neobundle#tap('localrc')
  augroup MyVimrc
    autocmd BufNewFile,BufRead *
      \ if exists("b:undo_localrc") |
      \   execute b:undo_localrc |
      \   unlet! b:undo_localrc |
      \ endif
    autocmd FileType *
      \ if exists("b:undo_ftlocalrc") |
      \   execute b:undo_ftlocalrc |
      \   unlet! b:undo_ftlocalrc |
      \ endif
  augroup END
endif
"}}}

"------------------------------------------------------------------------------
" MapList: {{{
if s:has_neobundle && neobundle#tap('maplist')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:maplist_mode_length  = 4
    let g:maplist_lhs_length   = 50
    let g:maplist_local_length = 2
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" Marching: {{{
if s:has_neobundle && neobundle#tap('marching')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:marching_enable_neocomplete = 1
    let g:marching_backend            =
      \ neobundle#is_installed('snowdrop') ?
      \   "snowdrop" : "sync_clang_command"
  endfunction

  call extend(s:neocompl_force_omni_patterns, {
    \ 'marching#complete' : '\%(\.\|->\|::\)\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" Narrow: {{{
if s:has_neobundle && neobundle#tap('narrow')
  function! neobundle#tapped.hooks.on_source(bundle)
    call operator#user#define_ex_command(
      \ 'narrow',
      \ 'Narrow')

    NXnoremap sN :<C-U>Widen<CR>
  endfunction

  NXOmap sn <Plug>(operator-narrow)

  nmap snn snsn
endif
"}}}

"------------------------------------------------------------------------------
" NeoComplCache: {{{
if s:has_neobundle && neobundle#tap('neocomplcache')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:neocomplcache_enable_at_startup            = 1
    let g:neocomplcache_enable_auto_select           = 0
    let g:neocomplcache_enable_auto_delimiter        = 1
    " let g:neocomplcache_enable_insert_char_pre       = 1
    let g:neocomplcache_enable_camel_case_completion = 0
    let g:neocomplcache_enable_underbar_completion   = 0
    let g:neocomplcache_enable_fuzzy_completion      = 0
    let g:neocomplcache_force_overwrite_completefunc = 1
    let g:neocomplcache_temporary_dir                =
      \ $HOME . '/.local/.cache/neocomplcache'

    let g:neocomplcache_dictionary_filetype_lists =
      \ s:neocompl_dictionary_filetype_lists
    let g:neocomplcache_vim_completefuncs         =
      \ s:neocompl_vim_completefuncs
    " let g:neocomplcache_omni_patterns             =
    "   \ s:neocompl_omni_patterns
    " let g:neocomplcache_force_omni_patterns       =
    "   \ s:neocompl_force_omni_patterns
    let g:neocomplcache_omni_patterns             = {}
    let g:neocomplcache_force_omni_patterns       = {}

    call neocomplcache#custom_source('syntax_complete',   'rank',  9)
    call neocomplcache#custom_source('snippets_complete', 'rank', 80)

    inoremap <expr> <C-Y>
      \ neocomplcache#close_popup()
    inoremap <expr> <C-G>
      \ neocomplcache#undo_completion()
    inoremap <expr> <C-C>
      \ pumvisible() ?
      \   neocomplcache#cancel_popup() :
      \   '<C-C>'
    inoremap <expr> <C-L>
      \ pumvisible() ?
      \   neocomplcache#complete_common_string() :
      \   '<C-L>'
    inoremap <expr> <Tab>
      \ pumvisible() ?
      \   '<C-N>' :
      \   myvimrc#check_back_space() ?
      \     '<Tab>' :
      \     neocomplcache#start_manual_complete()
    inoremap <expr> <S-Tab>
      \ pumvisible() ?
      \   '<C-P>' :
      \   neocomplcache#start_manual_complete()

    inoremap <expr> <CR>
      \ neocomplcache#close_popup() . '<CR>'
    inoremap <expr> <C-H>
      \ neocomplcache#smart_close_popup() . '<C-H>'
    inoremap <expr> <BS>
      \ neocomplcache#smart_close_popup() . '<BS>'
  endfunction

  augroup MyVimrc
    autocmd CmdwinEnter *
      \ call myvimrc#cmdwin_enter_neocomplcache()
    autocmd CmdwinEnter :
      \ let b:neocomplcache_sources_list = ['file_complete', 'vim_complete']
  augroup END
endif
"}}}

"------------------------------------------------------------------------------
" NeoComplete: {{{
if s:has_neobundle && neobundle#tap('neocomplete')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:neocomplete#enable_at_startup            = 1
    let g:neocomplete#enable_auto_select           = 0
    let g:neocomplete#enable_auto_delimiter        = 1
    " let g:neocomplete#enable_insert_char_pre       = 1
    let g:neocomplete#force_overwrite_completefunc = 1
    let g:neocomplete#data_directory               =
      \ $HOME . '/.local/.cache/neocomplete'

    let g:neocomplete#sources#dictionary#dictionaryies =
      \ s:neocompl_dictionary_filetype_lists
    let g:neocomplete#sources#vim#complete_functions   =
      \ s:neocompl_vim_completefuncs
    " let g:neocomplete#sources#omni#input_patterns      =
    "   \ s:neocompl_omni_patterns
    " let g:neocomplete#force_omni_input_patterns        =
    "   \ s:neocompl_force_omni_patterns
    let g:neocomplete#sources#omni#input_patterns      = {}
    let g:neocomplete#force_omni_input_patterns        = {}

    call neocomplete#custom#source('_', 'matchers', ['matcher_head'])
    call neocomplete#custom#source('syntax_complete',   'rank',  9)
    call neocomplete#custom#source('snippets_complete', 'rank', 80)

    inoremap <expr> <C-Y>
      \ neocomplete#close_popup()
    inoremap <expr> <C-G>
      \ neocomplete#undo_completion()
    inoremap <expr> <C-C>
      \ pumvisible() ?
      \   neocomplete#cancel_popup() :
      \   '<C-C>'
    inoremap <expr> <C-L>
      \ pumvisible() ?
      \   neocomplete#complete_common_string() :
      \   '<C-L>'
    inoremap <expr> <Tab>
      \ pumvisible() ?
      \   '<C-N>' :
      \   myvimrc#check_back_space() ?
      \     '<Tab>' :
      \     neocomplete#start_manual_complete()
    inoremap <expr> <S-Tab>
      \ pumvisible() ?
      \   '<C-P>' :
      \   neocomplete#start_manual_complete()

    inoremap <expr> <CR>
      \ neocomplete#close_popup() . '<CR>'
    inoremap <expr> <C-H>
      \ neocomplete#smart_close_popup() . '<C-H>'
    inoremap <expr> <BS>
      \ neocomplete#smart_close_popup() . '<BS>'
  endfunction

  augroup MyVimrc
    autocmd CmdwinEnter *
      \ call myvimrc#cmdwin_enter_neocomplete()
    autocmd CmdwinEnter :
      \ let b:neocomplete_sources = ['file', 'vim']
  augroup END
endif
"}}}

"------------------------------------------------------------------------------
" NeoMru: {{{
if s:has_neobundle && neobundle#tap('neomru')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:neomru#file_mru_path       = $HOME . '/.local/.cache/neomru/file'
    let g:neomru#directory_mru_path  = $HOME . '/.local/.cache/neomru/directory'
    let g:neomru#file_mru_limit      = 50
    let g:neomru#directory_mru_limit = 50
    let g:neomru#do_validate         = 0

    let g:neomru#file_mru_ignore_pattern =
      \ '[/\\]doc[/\\][^/\\]\+\.\%(txt\|\a\ax\)$\|' .
      \ join(map(
      \   copy(s:ignore_ext),
      \   '''\.'' . escape(v:val, ''\*.^$'') . ''$'''), '\|')
  endfunction

  NXnoremap <Leader>e
    \ :<C-U>Unite neomru/file file file/new
    \ -buffer-name=files -no-split<CR>
  NXnoremap <Leader>d
    \ :<C-U>Unite
    \ menu:directory_current neomru/directory directory directory/new
    \ -buffer-name=files -no-split -default-action=lcd<CR>
  NXnoremap <Leader>D
    \ :<C-U>Unite
    \ menu:directory_current neomru/directory directory directory/new
    \ -buffer-name=files -no-split -default-action=cd<CR>
  NXnoremap <Leader><M-d>
    \ :<C-U>UniteWithBufferDir
    \ menu:directory_file neomru/directory directory directory/new
    \ -buffer-name=files -no-split -default-action=lcd<CR>
  NXnoremap <Leader><M-D>
    \ :<C-U>UniteWithBufferDir
    \ menu:directory_file neomru/directory directory directory/new
    \ -buffer-name=files -no-split -default-action=cd<CR>
endif
"}}}

"------------------------------------------------------------------------------
" NeoSnippet: {{{
if s:has_neobundle && neobundle#tap('neosnippet')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:neosnippet#snippets_directory           = $HOME . '/.vim/snippets'
    let g:neosnippet#data_directory               = $HOME . '/.local/.cache/neosnippet'
    let g:neosnippet#disable_select_mode_mappings = 0

    let g:neosnippet#disable_runtime_snippets =
      \ get(g:, 'neosnippet#disable_runtime_snippets', {})
    let g:neosnippet#disable_runtime_snippets._ = 1

    imap <C-E> <Plug>(neosnippet_expand_or_jump)
  endfunction

  smap <C-E> <Plug>(neosnippet_expand_or_jump)
  xmap <C-E> <Plug>(neosnippet_expand_target)

  autocmd MyVimrc InsertLeave *
    \ NeoSnippetClearMarkers
endif
"}}}

"------------------------------------------------------------------------------
" OmniSharp: {{{
if s:has_neobundle && neobundle#tap('Omnisharp')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:OmniSharp_typeLookupInPreview    = 0
    let g:OmniSharp_timeout                = 5
    let g:OmniSharp_BufWritePreSyntaxCheck = 1
    let g:Omnisharp_stop_server            = 2
  endfunction

  call extend(s:neocompl_force_omni_patterns, {
    \ 'OmniSharp#Complete' : '\.\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" Open Browser: {{{
if s:has_neobundle && neobundle#tap('open-browser')
  nmap gxgx <Plug>(openbrowser-smart-search)
  nmap gxx gxgx
endif
"}}}

"------------------------------------------------------------------------------
" Operator Camelize: {{{
if s:has_neobundle && neobundle#tap('operator-camelize')
  NXOmap sU <Plug>(operator-camelize)
  NXOmap su <Plug>(operator-decamelize)
  NXOmap s~ <Plug>(operator-camelize-toggle)

  nmap sUU sUsU
  nmap suu susu
  nmap s~~ s~s~
endif
"}}}

"------------------------------------------------------------------------------
" Operator Filled With Blank: {{{
if s:has_neobundle && neobundle#tap('operator-filled-with-blank')
  NXOmap s<Space> <Plug>(operator-filled-with-blank)

  nmap s<Space><Space> s<Space>s<Space>
endif
"}}}

"------------------------------------------------------------------------------
" Operator HTML Escape: {{{
if s:has_neobundle && neobundle#tap('operator-html-escape')
  NXOmap se <Plug>(operator-html-escape)
  NXOmap sE <Plug>(operator-html-unescape)

  nmap see sese
  nmap sEE sEsE
endif
"}}}

"------------------------------------------------------------------------------
" Operator Open Browser: {{{
if s:has_neobundle && neobundle#tap('operator-openbrowser')
  NXOmap gx <Plug>(operator-openbrowser)
endif
"}}}

"------------------------------------------------------------------------------
" Operator Replace: {{{
if s:has_neobundle && neobundle#tap('operator-replace')
  NXOmap p <Plug>(operator-replace)

  nnoremap pp p
endif
"}}}

"------------------------------------------------------------------------------
" Operator Reverse: {{{
if s:has_neobundle && neobundle#tap('operator-reverse')
  NXOmap sv <Plug>(operator-reverse-text)
  NXOmap sV <Plug>(operator-reverse-lines)

  nmap svv svsv
  nmap sVV sVsV
endif
"}}}

"------------------------------------------------------------------------------
" Operator Search: {{{
if s:has_neobundle && neobundle#tap('operator-search')
  NXOmap s/ <Plug>(operator-search)

  nmap s// s/s/
endif
"}}}

"------------------------------------------------------------------------------
" Operator Sequence: {{{
if s:has_neobundle && neobundle#tap('operator-sequence')
  NXOmap <expr> s<C-U>
    \ operator#sequence#map("\<Plug>(operator-decamelize)", 'gU')

  nmap s<C-U><C-U> s<C-U>s<C-U>
endif
"}}}

"------------------------------------------------------------------------------
" Operator Shuffle: {{{
if s:has_neobundle && neobundle#tap('operator-shuffle')
  NXOmap sS <Plug>(operator-shuffle)

  nmap sSS sSsS
endif
"}}}

"------------------------------------------------------------------------------
" Operator Sort: {{{
if s:has_neobundle && neobundle#tap('operator-sort')
  NXOmap ss <Plug>(operator-sort)

  nmap sss ssss
endif
"}}}

"------------------------------------------------------------------------------
" Operator Star: {{{
if s:has_neobundle && neobundle#tap('operator-star')
  NOmap *  <Plug>(operator-*)
  NOmap #  <Plug>(operator-#)
  NOmap g* <Plug>(operator-g*)
  NOmap g# <Plug>(operator-g#)

  NOnoremap **   *
  NOnoremap ##   #
  NOnoremap g*g* g*
  NOnoremap g#g# g#

  NOmap g/g/ **
  NOmap g?g? ##
  NOmap g//  **
  NOmap g??  ##
  NOmap g**  g*g*
  NOmap g##  g#g#

  nmap <C-W>*  <SID>(split-nicely)<Plug>(operator-*)
  nmap <C-W>#  <SID>(split-nicely)<Plug>(operator-#)
  nmap <C-W>g* <SID>(split-nicely)<Plug>(operator-g*)
  nmap <C-W>g# <SID>(split-nicely)<Plug>(operator-g#)

  nnoremap <script> <C-W>**   <SID>(split-nicely)*
  nnoremap <script> <C-W>##   <SID>(split-nicely)#
  nnoremap <script> <C-W>g*g* <SID>(split-nicely)g*
  nnoremap <script> <C-W>g#g# <SID>(split-nicely)g#

  nmap <C-W>g/g/ <C-W>**
  nmap <C-W>g?g? <C-W>##
  nmap <C-W>g//  <C-W>**
  nmap <C-W>g??  <C-W>##
  nmap <C-W>g**  <C-W>g*g*
  nmap <C-W>g##  <C-W>g#g#
endif
"}}}

"------------------------------------------------------------------------------
" Operator Suddendeath: {{{
if s:has_neobundle && neobundle#tap('operator-suddendeath')
  NXOmap s! <Plug>(operator-suddendeath)

  nmap s!! s!s!
endif
"}}}

"------------------------------------------------------------------------------
" Operator Surround: {{{
if s:has_neobundle && neobundle#tap('operator-surround')
  NXOmap sa <Plug>(operator-surround-append)
  NXOmap sd <Plug>(operator-surround-delete)
  NXOmap sc <Plug>(operator-surround-replace)

  nmap sdsd <Plug>(operator-surround-delete)<Plug>(textobj-multiblock-a)
  nmap scsc <Plug>(operator-surround-replace)<Plug>(textobj-multiblock-a)

  nmap saa sasa
  nmap sdd sdsd
  nmap scc scsc
endif
"}}}

"------------------------------------------------------------------------------
" Operator Tabular: {{{
if s:has_neobundle && neobundle#tap('operator-tabular')
  function! neobundle#tapped.hooks.on_source(bundle)
    call operator#user#define(
      \ 'tabularize',
      \ 'myvimrc#operator_tabularize')
    call operator#user#define(
      \ 'untabularize',
      \ 'myvimrc#operator_untabularize')
  endfunction

  NXOmap st <Plug>(operator-tabularize)
  NXOmap sT <Plug>(operator-untabularize)

  nmap stt stst
  nmap sTT sTsT
endif
"}}}

"------------------------------------------------------------------------------
" Operator Trailingspace Killer: {{{
if s:has_neobundle && neobundle#tap('operator-trailingspace-killer')
  NXOmap s$ <Plug>(operator-trailingspace-killer)

  nmap s$$ s$s$
endif
"}}}

"------------------------------------------------------------------------------
" Operator User: {{{
if s:has_neobundle && neobundle#tap('operator-user')
  function! neobundle#tapped.hooks.on_source(bundle)
    call operator#user#define(
      \ 'grep',
      \ 'myvimrc#operator_grep')
    call operator#user#define(
      \ 'justify',
      \ 'myvimrc#operator_justify')
  endfunction

  NXOmap sg <Plug>(operator-grep)
  NXOmap sJ <Plug>(operator-justify)

  nmap sgg sgsg
  nmap sJJ sJsJ

  if neobundle#is_installed('unite')
    nnoremap sgsg :<C-U>execute input(':', 'grep ')<CR>
  endif
endif
"}}}

"------------------------------------------------------------------------------
" ParaJump: {{{
if s:has_neobundle && neobundle#tap('parajump')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:parajump_no_default_key_mappings = 1

    nmap <SID>(parajump-backward) <Plug>(parajump-backward)
    nmap <SID>(parajump-forward)  <Plug>(parajump-forward)

    inoremap <script> <M-{> <C-O><SID>(parajump-backward)
    inoremap <script> <M-}> <C-O><SID>(parajump-forward)
  endfunction

  NXOmap { <Plug>(parajump-backward)
  NXOmap } <Plug>(parajump-forward)
endif
"}}}

"------------------------------------------------------------------------------
" PerlOmni: {{{
if s:has_neobundle && neobundle#tap('perlomni')
  function! neobundle#tapped.hooks.on_source(bundle)
    if has('win32')
      let $PATH = substitute(a:bundle.path, '/', '\\', 'g') . '\bin;' . $PATH
    else
      let $PATH = a:bundle.path . '/bin:' . $PATH
    endif
  endfunction

  call extend(s:neocompl_force_omni_patterns, {
    \ 'PerlComplete' : '\%(->\|::\)\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" Precious: {{{
if s:has_neobundle && neobundle#tap('precious')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_precious_no_default_key_mappings = 1
    let g:precious_enable_switchers                = {
      \ 'help' : {'setfiletype' : 0}}
  endfunction

  function! neobundle#tapped.hooks.on_post_source(bundle)
    let &statusline = substitute(&statusline, '%y', '%{StatusLine_y()}', '')
  endfunction

  function! StatusLine_y()
    if &l:filetype == ''
      return ''
    endif

    let context = precious#context_filetype()
    return '[' . &l:filetype .
      \ (&l:filetype != context ? (':' . context) : '') . ']'
  endfunction

  XOmap ax <Plug>(textobj-precious-i)
  XOmap ix <Plug>(textobj-precious-i)
endif
"}}}

"------------------------------------------------------------------------------
" Quickhl: {{{
if s:has_neobundle && neobundle#tap('quickhl')
  NXmap  sM <Plug>(quickhl-manual-reset)
  NXOmap sm <Plug>(operator-quickhl-manual-this-motion)

  nmap smm smsm
endif
"}}}

"------------------------------------------------------------------------------
" QuickRun: {{{
if s:has_neobundle && neobundle#tap('quickrun')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:quickrun_no_default_key_mappings = 1

    let g:quickrun_config =
      \ get(g:, 'quickrun_config', {})

    call extend(g:quickrun_config, {
      \ '_' : {
      \   'runner' : s:has_vimproc() ? 'vimproc' : 'system',
      \   'runner/vimproc/updatetime' : 100},
      \
      \ 'c' : {
      \   'type' :
      \     s:executable('clang') ? 'c/clang' :
      \     s:executable('gcc')   ? 'c/gcc' :
      \     exists('$VCVARSALL')  ? 'c/vc' :
      \     s:executable('cl')    ? 'c/vc' : ''},
      \ 'c/vc' : {
      \   'hook/output_encode/encoding' : has('win32') ? 'cp932' : &encoding,
      \   'hook/vcvarsall/enable' : exists('$VCVARSALL'),
      \   'hook/vcvarsall/bat' : $VCVARSALL},
      \
      \ 'cpp' : {
      \   'type' :
      \     s:executable('clang++') ? 'cpp/clang++' :
      \     s:executable('g++')     ? 'cpp/g++' :
      \     exists('$VCVARSALL')    ? 'cpp/vc' :
      \     s:executable('cl')      ? 'cpp/vc' : ''},
      \ 'cpp/vc' : {
      \   'hook/output_encode/encoding' : has('win32') ? 'cp932' : &encoding,
      \   'hook/vcvarsall/enable' : exists('$VCVARSALL'),
      \   'hook/vcvarsall/bat' : $VCVARSALL},
      \
      \ 'cs' : {
      \   'type' :
      \     exists('$VCVARSALL') ? 'cs/csc' :
      \     s:executable('csc')  ? 'cs/csc' :
      \     s:executable('dmcs') ? 'cs/dmcs' :
      \     s:executable('smcs') ? 'cs/smcs' :
      \     s:executable('gmcs') ? 'cs/gmcs' :
      \     s:executable('mcs')  ? 'cs/mcs' : ''},
      \ 'cs/csc' : {
      \   'hook/output_encode/encoding' : has('win32') ? 'cp932' : &encoding,
      \   'hook/vcvarsall/enable' : exists('$VCVARSALL'),
      \   'hook/vcvarsall/bat' : $VCVARSALL},
      \
      \ 'vbnet' : {
      \   'type' :
      \     exists('$VCVARSALL') ? 'vbnet/vbc' :
      \     s:executable('vbc')  ? 'vbnet/vbc' : ''},
      \ 'vbnet/vbc' : {
      \   'command' : 'vbc',
      \   'exec' : [
      \     '%c /nologo /out:%s:p:r.exe %s',
      \     '%s:p:r.exe %a'],
      \   'tempfile' : '%{tempname()}.vb',
      \   'hook/sweep/files' : ['%s:p:r.exe'],
      \   'hook/output_encode/encoding' : has('win32') ? 'cp932' : &encoding,
      \   'hook/vcvarsall/enable' : exists('$VCVARSALL'),
      \   'hook/vcvarsall/bat' : $VCVARSALL}})

    nnoremap <expr> <C-C>
      \ quickrun#is_running() ? quickrun#sweep_sessions() : '<C-C>'
  endfunction

  nmap <expr> sr
    \ neobundle#is_installed('precious') ?
    \   '<Plug>(precious-quickrun-op)' : '<Plug>(quickrun-op)'
  xmap sr  <Plug>(quickrun)
  omap sr  g@
  nmap srr srsr

  NXmap <Leader>r <Plug>(quickrun)
  NXmap <F5>      <Plug>(quickrun)
endif
"}}}

"------------------------------------------------------------------------------
" Reanimate: {{{
if s:has_neobundle && neobundle#tap('reanimate')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:reanimate_save_dir = $HOME . '/.local/reanimate'
  endfunction

  NXnoremap <Leader>us  <Nop>
  NXnoremap <Leader>usl :<C-U>Unite reanimate
    \ -buffer-name=files -no-split -default-action=reanimate_load<CR>
  NXnoremap <Leader>uss :<C-U>Unite reanimate
    \ -buffer-name=files -no-split -default-action=reanimate_save<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Ref: {{{
if s:has_neobundle && neobundle#tap('ref')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:ref_no_default_key_mappings = 1
    let g:ref_cache_dir               = $HOME . '/.local/.vim_ref_cache'
  endfunction

  NXmap K <Plug>(ref-keyword)
endif
"}}}

"------------------------------------------------------------------------------
" RengBang: {{{
if s:has_neobundle && neobundle#tap('rengbang')
  function! neobundle#tapped.hooks.on_source(bundle)
    call operator#user#define_ex_command(
      \ 'rengbang-confirm',
      \ 'RengBangConfirm')
  endfunction

  NXOmap s+ <Plug>(operator-rengbang-confirm)

  nmap s++ s+s+
endif
"}}}

"------------------------------------------------------------------------------
" Repeat: {{{
if s:has_neobundle && neobundle#tap('repeat')
  nnoremap <M-o>
    \ :<C-U>call append(line('.'), repeat([''], v:count1))<Bar>
    \ call repeat#set('<M-o>', v:count1)<CR>
  nnoremap <M-O>
    \ :<C-U>call append(line('.') - 1, repeat([''], v:count1))<Bar>
    \ call repeat#set('<M-O>', v:count1)<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Scratch: {{{
if s:has_neobundle && neobundle#tap('scratch')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:scratch_buffer_name = '[scratch]'

    call operator#user#define_ex_command(
      \ 'scratch-evaluate',
      \ 'ScrachEvaluate')
    call operator#user#define_ex_command(
      \ 'scratch-evaluate!',
      \ 'ScrachEvaluate!')
  endfunction

  autocmd MyVimrc User PluginScratchInitializeAfter
    \ nmap <buffer> sr <Plug>(operator-scratch-evaluate)
endif
"}}}

"------------------------------------------------------------------------------
" SmartWord: {{{
if s:has_neobundle && neobundle#tap('smartword')
  function! neobundle#tapped.hooks.on_source(bundle)
    nmap <SID>(smartword-w)  <Plug>(smartword-w)
    nmap <SID>(smartword-b)  <Plug>(smartword-b)
    nmap <SID>(smartword-e)  <Plug>(smartword-e)
    nmap <SID>(smartword-ge) <Plug>(smartword-ge)

    inoremap <script> <M-w>      <C-O><SID>(smartword-w)
    inoremap <script> <M-b>      <C-O><SID>(smartword-b)
    inoremap <script> <M-e>      <C-O><SID>(smartword-e)
    inoremap <script> <M-g><M-e> <C-O><SID>(smartword-ge)
  endfunction

  NXOmap w  <Plug>(smartword-w)
  NXOmap b  <Plug>(smartword-b)
  NXOmap e  <Plug>(smartword-e)
  NXOmap ge <Plug>(smartword-ge)
endif
"}}}

"------------------------------------------------------------------------------
" Snowdrop: {{{
if s:has_neobundle && neobundle#tap('snowdrop')
  function! neobundle#tapped.hooks.on_source(bundle)
    if has('win64')
      let g:snowdrop#libclang_directory = $HOME . '/bin64'
      let g:snowdrop#libclang_file      = 'libclang.dll'
    elseif has('win32')
      let g:snowdrop#libclang_directory = $HOME . '/bin'
      let g:snowdrop#libclang_file      = 'libclang.dll'
    elseif filereadable($HOME . '/lib/libclang.so')
      let g:snowdrop#libclang_directory = $HOME . '/lib'
      let g:snowdrop#libclang_file      = 'libclang.so'
    elseif filereadable(expand('/usr/local/lib/libclang.so'))
      let g:snowdrop#libclang_directory = '/usr/local/lib'
      let g:snowdrop#libclang_file      = 'libclang.so'
    elseif filereadable(expand('/usr/lib/libclang.so'))
      let g:snowdrop#libclang_directory = '/usr/lib'
      let g:snowdrop#libclang_file      = 'libclang.so'
    endif
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" Switch: {{{
if s:has_neobundle && neobundle#tap('switch')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:switch_no_builtins        = 1
    let g:switch_custom_definitions = [
      \ ['TRUE', 'FALSE'], ['True', 'False'], ['true', 'false'],
      \ ['ENABLE', 'DISABLE'], ['Enable', 'Disable'], ['enable', 'disable']]

    let g:switch_increment_definitions = []
    let g:switch_decrement_definitions = []

    for l in [
      \ ['SUNDAY', 'MONDAY', 'TUESDAY', 'WEDNESDAY',
      \  'THURSDAY', 'FRIDAY', 'SATURDAY'],
      \ ['Sunday', 'Monday', 'Tuesday', 'Wednesday',
      \  'Thursday', 'Friday', 'Saturday'],
      \ ['sunday', 'monday', 'tuesday', 'wednesday',
      \  'thursday', 'friday', 'saturday'],
      \ ['JANUARY', 'FEBRUARY', 'MARCH', 'APRIL', 'MAY', 'JUNE', 'JULY',
      \  'AUGUST', 'SEPTEMBER', 'OCTOBER', 'NOVEMBER', 'DECEMBER'],
      \ ['January', 'February', 'March', 'April', 'May', 'June', 'July',
      \  'August', 'September', 'October', 'November', 'December'],
      \ ['january', 'february', 'march', 'april', 'may', 'june', 'july',
      \  'august', 'september', 'october', 'november', 'december']]
      let inc = {}
      let dec = {}
      for i in range(len(l))
        let s1 = l[i]
        let s2 = get(l, i + 1, l[0])
        if len(s1) > 3
          call extend(inc, {'\C' . s1[0:3] . '\@!' : s2[:2]})
        endif
        if len(s2) > 3
          call extend(dec, {'\C' . s2[0:3] . '\@!' : s1[:2]})
        endif
      endfor
      call add(g:switch_increment_definitions, inc)
      call add(g:switch_decrement_definitions, dec)
      call add(g:switch_increment_definitions, l)
      call add(g:switch_decrement_definitions, reverse(copy(l)))
    endfor

    for l in [
      \ ['ZEROTH', 'FIRST', 'SECOND',  'THIRD',  'FOURTH',
      \  'FIFTH',  'SIXTH', 'SEVENTH', 'EIGHTH', 'NINTH',
      \  'TENTH',      'ELEVENTH',   'TWELFTH',   'THIRTEENTH',
      \  'FOURTEENTH', 'FIFTEENTH',  'SIXTEENTH', 'SEVENTEENTH',
      \  'EIGHTEENTH', 'NINETEENTH', 'TWENTIETH'],
      \ ['Zeroth', 'First', 'Second',  'Third',  'Fourth',
      \  'Fifth',  'Sixth', 'Seventh', 'Eighth', 'Ninth',
      \  'Tenth',      'Eleventh',   'Twelfth',   'Thirteenth',
      \  'Fourteenth', 'Fifteenth',  'Sixteenth', 'Seventeenth',
      \  'Eighteenth', 'Nineteenth', 'Twentieth'],
      \ ['zeroth', 'first', 'second',  'third',  'fourth',
      \  'fifth',  'sixth', 'seventh', 'eighth', 'ninth',
      \  'tenth',      'eleventh',   'twelfth',   'thirteenth',
      \  'fourteenth', 'fifteenth',  'sixteenth', 'seventeenth',
      \  'eighteenth', 'nineteenth', 'twentieth']]
      call add(g:switch_increment_definitions, l)
      call add(g:switch_decrement_definitions, reverse(copy(l)))
    endfor

    call extend(g:switch_increment_definitions, [{
      \ '\C\(-\?\d\+\)\%(TH\|ST\|ND\|RD\)' :
      \   '\=toupper(call(''myvimrc#ordinal'', [submatch(1) + 1]))',
      \ '\C\(-\?\d\+\)\%(th\|st\|nd\|rd\)' :
      \   '\=tolower(call(''myvimrc#ordinal'', [submatch(1) + 1]))'}])
    call extend(g:switch_decrement_definitions, [{
      \ '\C\(-\?\d\+\)\%(TH\|ST\|ND\|RD\)' :
      \   '\=toupper(call(''myvimrc#ordinal'', [submatch(1) - 1]))',
      \ '\C\(-\?\d\+\)\%(th\|st\|nd\|rd\)' :
      \   '\=tolower(call(''myvimrc#ordinal'', [submatch(1) - 1]))'}])

    command! -bar
      \ SwitchIncrement
      \ call myvimrc#switch(1)
    command! -bar
      \ SwitchDecrement
      \ call myvimrc#switch(0)
  endfunction

  nnoremap <C-A> :<C-U>SwitchIncrement<CR>
  nnoremap <C-X> :<C-U>SwitchDecrement<CR>

  autocmd MyVimrc VimEnter,BufNewFile,BufRead *
    \ let b:switch_no_builtins = 1
endif
"}}}

"------------------------------------------------------------------------------
" TComment: {{{
if s:has_neobundle && neobundle#tap('tcomment')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:tcommentMaps = 0

    call operator#user#define(
      \ 'tcomment',
      \ 'tcomment#Operator',
      \ 'call myvimrc#operator_tcomment_setup({})')
    call operator#user#define(
      \ 'tcomment-col=1',
      \ 'tcomment#Operator',
      \ 'call myvimrc#operator_tcomment_setup({"col" : 1})')

    call operator#user#define(
      \ 'tcomment-block',
      \ 'myvimrc#operator_tcomment_block',
      \ 'call myvimrc#operator_tcomment_setup({})')
    call operator#user#define(
      \ 'tcomment-block-col=1',
      \ 'myvimrc#operator_tcomment_block',
      \ 'call myvimrc#operator_tcomment_setup({"col" : 1})')
  endfunction

  function! neobundle#tapped.hooks.on_post_source(bundle)
    call tcomment#DefineType('c',         '// %s', {}, 1)
    call tcomment#DefineType('d',         '// %s')
    call tcomment#DefineType('d_inline',  g:tcommentInlineC)
    call tcomment#DefineType('d_block',   g:tcommentBlockC)
    call tcomment#DefineType('gitconfig', '# %s')
    call tcomment#DefineType('mayu',      '# %s')
    call tcomment#DefineType('nyaos',     '# %s')
    call tcomment#DefineType('screen',    '# %s')
    call tcomment#DefineType('snippet',   '# %s')
    call tcomment#DefineType('tmux',      '# %s')
    call tcomment#DefineType('vbnet',     "' %s")
    call tcomment#DefineType('vimshrc',   '# %s')
    call tcomment#DefineType('wsh',       "' %s")
    call tcomment#DefineType('z80',       '; %s')
    call tcomment#DefineType('zimbu',     '# %s')
    call tcomment#DefineType('zsh',       '# %s')
  endfunction

  NXOmap gc     <Plug>(operator-tcomment)
  NXOmap gC     <Plug>(operator-tcomment-block)
  NXOmap g<M-c> <Plug>(operator-tcomment-col=1)
  NXOmap g<M-C> <Plug>(operator-tcomment-block-col=1)

  nmap gcc         gcgc
  nmap gCC         gCgC
  nmap g<M-c><M-c> g<M-c>g<M-c>
  nmap g<M-C><M-C> g<M-C>g<M-C>
endif
"}}}

"------------------------------------------------------------------------------
" Tern: {{{
if s:has_neobundle && neobundle#tap('tern')
  call extend(s:neocompl_force_omni_patterns, {
    \ 'tern#Complete' : '\.\h\w*'})
endif
"}}}

"------------------------------------------------------------------------------
" TextManipilate: {{{
if s:has_neobundle && neobundle#tap('textmanip')
  function! neobundle#tapped.hooks.on_source(bundle)
    call operator#user#define(
      \ 'textmanip-duplicate-down',
      \ 'myvimrc#operator_textmanip_duplicate_down')
    call operator#user#define(
      \ 'textmanip-duplicate-up',
      \ 'myvimrc#operator_textmanip_duplicate_up')
    call operator#user#define(
      \ 'textmanip-move-left',
      \ 'myvimrc#operator_textmanip_move_left')
    call operator#user#define(
      \ 'textmanip-move-right',
      \ 'myvimrc#operator_textmanip_move_right')
    call operator#user#define(
      \ 'textmanip-move-down',
      \ 'myvimrc#operator_textmanip_move_down')
    call operator#user#define(
      \ 'textmanip-move-up',
      \ 'myvimrc#operator_textmanip_move_up')
  endfunction

  NOmap <M-p> <Plug>(operator-textmanip-duplicate-down)
  NOmap <M-P> <Plug>(operator-textmanip-duplicate-up)
  xmap  <M-p> <Plug>(textmanip-duplicate-down)
  xmap  <M-P> <Plug>(textmanip-duplicate-up)

  NOmap sj <Plug>(operator-textmanip-move-down)
  NOmap sk <Plug>(operator-textmanip-move-up)
  NOmap sh <Plug>(operator-textmanip-move-left)
  NOmap sl <Plug>(operator-textmanip-move-right)
  xmap  sj <Plug>(textmanip-move-down)
  xmap  sk <Plug>(textmanip-move-up)
  xmap  sh <Plug>(textmanip-move-left)
  xmap  sl <Plug>(textmanip-move-right)

  nmap sjj sjsj
  nmap skk sksk
  nmap shh shsh
  nmap sll slsl
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Between: {{{
if s:has_neobundle && neobundle#tap('textobj-between')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_between_no_default_key_mappings = 1
  endfunction

  XOmap af <Plug>(textobj-between-a)
  XOmap if <Plug>(textobj-between-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Comment: {{{
if s:has_neobundle && neobundle#tap('textobj-comment')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_comment_no_default_key_mappings = 1
  endfunction

  XOmap ac <Plug>(textobj-comment-a)
  XOmap ic <Plug>(textobj-comment-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Continuous Line: {{{
if s:has_neobundle && neobundle#tap('textobj-continuous-line')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_continuous_line_no_default_key_mappings = 1
    let g:textobj_continuous_line_no_default_mappings     = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj DateTime: {{{
if s:has_neobundle && neobundle#tap('textobj-datetime')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_datetime_no_default_key_mappings = 1
  endfunction

  XOnoremap ad <Nop>
  XOmap ada <Plug>(textobj-datetime-auto)
  XOmap add <Plug>(textobj-datetime-date)
  XOmap adf <Plug>(textobj-datetime-full)
  XOmap adt <Plug>(textobj-datetime-time)
  XOmap adz <Plug>(textobj-datetime-tz)

  XOnoremap id <Nop>
  XOmap ida <Plug>(textobj-datetime-auto)
  XOmap idd <Plug>(textobj-datetime-date)
  XOmap idf <Plug>(textobj-datetime-full)
  XOmap idt <Plug>(textobj-datetime-time)
  XOmap idz <Plug>(textobj-datetime-tz)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Diff: {{{
if s:has_neobundle && neobundle#tap('textobj-diff')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_diff_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Entrie: {{{
if s:has_neobundle && neobundle#tap('textobj-entire')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_entire_no_default_key_mappings = 1
  endfunction

  XOmap ae <Plug>(textobj-entire-a)
  XOmap ie <Plug>(textobj-entire-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj EnclosedSyntax: {{{
if s:has_neobundle && neobundle#tap('textobj-enclosedsyntax')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_enclosedsyntax_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Fold: {{{
if s:has_neobundle && neobundle#tap('textobj-fold')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_fold_no_default_key_mappings = 1
  endfunction

  XOmap az <Plug>(textobj-fold-a)
  XOmap iz <Plug>(textobj-fold-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Function: {{{
if s:has_neobundle && neobundle#tap('textobj-function')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_function_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Ifdef: {{{
if s:has_neobundle && neobundle#tap('textobj-ifdef')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_ifdef_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj IndentBlock: {{{
if s:has_neobundle && neobundle#tap('textobj-indblock')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_indblock_no_default_key_mappings = 1
  endfunction

  XOmap ao <Plug>(textobj-indblock-a)
  XOmap io <Plug>(textobj-indblock-i)
  XOmap aO <Plug>(textobj-indblock-same-a)
  XOmap iO <Plug>(textobj-indblock-same-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Indent: {{{
if s:has_neobundle && neobundle#tap('textobj-indent')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_indent_no_default_key_mappings = 1
  endfunction

  XOmap ai <Plug>(textobj-indent-a)
  XOmap ii <Plug>(textobj-indent-i)
  XOmap aI <Plug>(textobj-indent-same-a)
  XOmap iI <Plug>(textobj-indent-same-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj JaBraces: {{{
if s:has_neobundle && neobundle#tap('textobj-jabraces')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_jabraces_no_default_key_mappings = 1
  endfunction

  XOnoremap aj <Nop>
  XOmap aj( <Plug>(textobj-jabraces-parens-a)
  XOmap aj) <Plug>(textobj-jabraces-parens-a)
  XOmap aj{ <Plug>(textobj-jabraces-braces-a)
  XOmap aj} <Plug>(textobj-jabraces-braces-a)
  XOmap aj[ <Plug>(textobj-jabraces-brackets-a)
  XOmap aj] <Plug>(textobj-jabraces-brackets-a)
  XOmap aj< <Plug>(textobj-jabraces-angles-a)
  XOmap aj> <Plug>(textobj-jabraces-angles-a)
  XOmap aja <Plug>(textobj-jabraces-angles-a)
  XOmap ajA <Plug>(textobj-jabraces-double-angles-a)
  XOmap ajk <Plug>(textobj-jabraces-kakko-a)
  XOmap ajK <Plug>(textobj-jabraces-double-kakko-a)
  XOmap ajy <Plug>(textobj-jabraces-yama-kakko-a)
  XOmap ajY <Plug>(textobj-jabraces-double-yama-kakko-a)
  XOmap ajt <Plug>(textobj-jabraces-kikkou-kakko-a)
  XOmap ajs <Plug>(textobj-jabraces-sumi-kakko-a)

  XOnoremap ij <Nop>
  XOmap ij( <Plug>(textobj-jabraces-parens-i)
  XOmap ij) <Plug>(textobj-jabraces-parens-i)
  XOmap ij{ <Plug>(textobj-jabraces-braces-i)
  XOmap ij} <Plug>(textobj-jabraces-braces-i)
  XOmap ij[ <Plug>(textobj-jabraces-brackets-i)
  XOmap ij] <Plug>(textobj-jabraces-brackets-i)
  XOmap ij< <Plug>(textobj-jabraces-angles-i)
  XOmap ij> <Plug>(textobj-jabraces-angles-i)
  XOmap ija <Plug>(textobj-jabraces-angles-i)
  XOmap ijA <Plug>(textobj-jabraces-double-angles-i)
  XOmap ijk <Plug>(textobj-jabraces-kakko-i)
  XOmap ijK <Plug>(textobj-jabraces-double-kakko-i)
  XOmap ijy <Plug>(textobj-jabraces-yama-kakko-i)
  XOmap ijY <Plug>(textobj-jabraces-double-yama-kakko-i)
  XOmap ijt <Plug>(textobj-jabraces-kikkou-kakko-i)
  XOmap ijs <Plug>(textobj-jabraces-sumi-kakko-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Line: {{{
if s:has_neobundle && neobundle#tap('textobj-line')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_line_no_default_key_mappings = 1
  endfunction

  XOmap al <Plug>(textobj-line-a)
  XOmap il <Plug>(textobj-line-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj MultiBlock: {{{
if s:has_neobundle && neobundle#tap('textobj-multiblock')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_multiblock_no_default_key_mappings = 1
  endfunction

  XOmap ab <Plug>(textobj-multiblock-a)
  XOmap ib <Plug>(textobj-multiblock-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj MultiTextObj: {{{
if s:has_neobundle && neobundle#tap('textobj-multitextobj')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_multitextobj_textobjects_group_a = {
      \ 'doublequotes' : [
      \   {'textobj' : 'a"',  'is_cursor_in' : 1, 'noremap' : 1}],
      \ 'singlequotes' : [
      \   {'textobj' : 'a''', 'is_cursor_in' : 1, 'noremap' : 1}],
      \ 'backquotes' : [
      \   {'textobj' : 'a`',  'is_cursor_in' : 1, 'noremap' : 1}],
      \ 'jabraces' : [
      \   ["\<Plug>(textobj-jabraces-parens-a)",
      \    "\<Plug>(textobj-jabraces-braces-a)",
      \    "\<Plug>(textobj-jabraces-brackets-a)",
      \    "\<Plug>(textobj-jabraces-angles-a)",
      \    "\<Plug>(textobj-jabraces-double-angles-a)",
      \    "\<Plug>(textobj-jabraces-kakko-a)",
      \    "\<Plug>(textobj-jabraces-double-kakko-a)",
      \    "\<Plug>(textobj-jabraces-yama-kakko-a)",
      \    "\<Plug>(textobj-jabraces-double-yama-kakko-a)",
      \    "\<Plug>(textobj-jabraces-kikkou-kakko-a)",
      \    "\<Plug>(textobj-jabraces-sumi-kakko-a)"]]}
    let g:textobj_multitextobj_textobjects_group_i = {
      \ 'doublequotes' : [
      \   {'textobj' : 'i"',  'is_cursor_in' : 1, 'noremap' : 1}],
      \ 'singlequotes' : [
      \   {'textobj' : 'i''', 'is_cursor_in' : 1, 'noremap' : 1}],
      \ 'backquotes' : [
      \   {'textobj' : 'i`',  'is_cursor_in' : 1, 'noremap' : 1}],
      \ 'jabraces' : [
      \   ["\<Plug>(textobj-jabraces-parens-i)",
      \    "\<Plug>(textobj-jabraces-braces-i)",
      \    "\<Plug>(textobj-jabraces-brackets-i)",
      \    "\<Plug>(textobj-jabraces-angles-i)",
      \    "\<Plug>(textobj-jabraces-double-angles-i)",
      \    "\<Plug>(textobj-jabraces-kakko-i)",
      \    "\<Plug>(textobj-jabraces-double-kakko-i)",
      \    "\<Plug>(textobj-jabraces-yama-kakko-i)",
      \    "\<Plug>(textobj-jabraces-double-yama-kakko-i)",
      \    "\<Plug>(textobj-jabraces-kikkou-kakko-i)",
      \    "\<Plug>(textobj-jabraces-sumi-kakko-i)"]]}
  endfunction

  XOmap <expr> a" textobj#multitextobj#mapexpr_a('doublequotes')
  XOmap <expr> i" textobj#multitextobj#mapexpr_i('doublequotes')
  XOmap <expr> a' textobj#multitextobj#mapexpr_a('singlequotes')
  XOmap <expr> i' textobj#multitextobj#mapexpr_i('singlequotes')
  XOmap <expr> a` textobj#multitextobj#mapexpr_a('backquotes')
  XOmap <expr> i` textobj#multitextobj#mapexpr_i('backquotes')
  XOmap <expr> aB textobj#multitextobj#mapexpr_a('jabraces')
  XOmap <expr> iB textobj#multitextobj#mapexpr_i('jabraces')
endif
"}}}

"------------------------------------------------------------------------------
" TextObj MotionMotion: {{{
if s:has_neobundle && neobundle#tap('textobj-motionmotion')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_motionmotion_no_default_key_mappings = 1
  endfunction

  XOmap am <Plug>(textobj-motionmotion-a)
  XOmap im <Plug>(textobj-motionmotion-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Parameter: {{{
if s:has_neobundle && neobundle#tap('textobj-parameter')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_parameter_no_default_key_mappings = 1
  endfunction

  XOmap a, <Plug>(textobj-parameter-a)
  XOmap i, <Plug>(textobj-parameter-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj PHP: {{{
if s:has_neobundle && neobundle#tap('textobj-php')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_php_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Python: {{{
if s:has_neobundle && neobundle#tap('textobj-python')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_python_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Ruby: {{{
if s:has_neobundle && neobundle#tap('textobj-ruby')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_ruby_no_default_key_mappings = 1
    let g:textobj_ruby_more_mappings           = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Sigil: {{{
if s:has_neobundle && neobundle#tap('textobj-sigil')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_sigil_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Space: {{{
if s:has_neobundle && neobundle#tap('textobj-space')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_space_no_default_key_mappings = 1
  endfunction

  XOmap aS <Plug>(textobj-space-a)
  XOmap iS <Plug>(textobj-space-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Syntax: {{{
if s:has_neobundle && neobundle#tap('textobj-syntax')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_syntax_no_default_key_mappings = 1
  endfunction

  XOmap ay <Plug>(textobj-syntax-a)
  XOmap iy <Plug>(textobj-syntax-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Url: {{{
if s:has_neobundle && neobundle#tap('textobj-url')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_url_no_default_key_mappings = 1
  endfunction

  XOmap au <Plug>(textobj-url-a)
  XOmap iu <Plug>(textobj-url-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj WordInWord: {{{
if s:has_neobundle && neobundle#tap('textobj-wiw')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_wiw_no_default_key_mappings = 1
  endfunction

  NXOmap <M-w>      <Plug>(textobj-wiw-n)
  NXOmap <M-b>      <Plug>(textobj-wiw-p)
  NXOmap <M-e>      <Plug>(textobj-wiw-N)
  NXOmap <M-g><M-e> <Plug>(textobj-wiw-P)

  XOmap a<M-w> <Plug>(textobj-wiw-a)
  XOmap i<M-w> <Plug>(textobj-wiw-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj Word Column: {{{
if s:has_neobundle && neobundle#tap('textobj-word-column')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_wordcolumn_no_default_key_mappings = 1
  endfunction

  XOmap av <Plug>(textobj-wordcolumn-w-a)
  XOmap aV <Plug>(textobj-wordcolumn-W-a)
  XOmap iv <Plug>(textobj-wordcolumn-w-i)
  XOmap iV <Plug>(textobj-wordcolumn-W-i)
endif
"}}}

"------------------------------------------------------------------------------
" TextObj XML Attribute: {{{
if s:has_neobundle && neobundle#tap('textobj-xml-attribute')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:textobj_xmlattribute_no_default_key_mappings = 1
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" UndoTree: {{{
if s:has_neobundle && neobundle#tap('undotree')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:undotree_SetFocusWhenToggle = 1
  endfunction

  NXnoremap <M-U> :<C-U>UndotreeToggle<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Unite: {{{
if s:has_neobundle && neobundle#tap('unite')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:unite_data_directory             = $HOME . '/.local/.cache/unite'
    let g:unite_enable_start_insert        = 1
    let g:unite_winheight                  = 25
    let g:unite_candidate_icon             = "-"
    let g:unite_marked_icon                = "+"
    let g:unite_cursor_line_highlight      = 'CursorLine'
    let g:unite_source_history_yank_enable = 1
    let g:unite_source_grep_max_candidates = 1000
    let g:unite_source_grep_encoding       = 'utf-8'

    if !has('win32') && s:executable('find')
      let g:unite_source_rec_async_command = 'find'
    elseif neobundle#is_installed('files') || s:executable('files')
      let g:unite_source_rec_async_command = 'files -p'
    elseif neobundle#is_installed('the_silver_searcher') || s:executable('ag')
      let g:unite_source_rec_async_command =
        \ 'ag --follow --nocolor --nogroup --hidden -g ""'
    endif

    if neobundle#is_installed('jvgrep') || s:executable('jvgrep')
      let g:unite_source_grep_command       = 'jvgrep'
      let g:unite_source_grep_recursive_opt = '-R'
      let g:unite_source_grep_default_opts  = '-n'
    elseif neobundle#is_installed('the_silver_searcher') || s:executable('ag')
      let g:unite_source_grep_command       = 'ag'
      let g:unite_source_grep_recursive_opt = ''
      let g:unite_source_grep_default_opts  =
        \ '--line-numbers --nocolor --nogroup --hidden'
    elseif s:executable('grep')
      let g:unite_source_grep_command       = 'grep'
      let g:unite_source_grep_recursive_opt = '-r'
      let g:unite_source_grep_default_opts  = '-Hn'
    endif

    let g:unite_source_menu_menus =
      \ get(g:, 'unite_source_menu_menus', {})

    let g:unite_source_menu_menus.directory_current = {
      \ 'description' : 'Current directory.'}
    let g:unite_source_menu_menus.directory_current.candidates = {
      \ '_' : ''}
    function! g:unite_source_menu_menus.directory_current.map(key, value)
      return {
        \ 'word' : './',
        \ 'kind' : 'directory',
        \ 'action__directory' : getcwd()}
    endfunction

    let g:unite_source_menu_menus.directory_file = {
      \ 'description' : 'File directory.'}
    let g:unite_source_menu_menus.directory_file.candidates = {
      \ (has('win32') ? ':gs?\\?/?' : '') . ':s?/$??' : ''}
    function! g:unite_source_menu_menus.directory_file.map(key, value)
      let d = expand('%') != '' ? expand('%:p:h') : getcwd()
      return {
        \ 'word' : fnamemodify(d, a:key) . '/',
        \ 'kind' : 'directory',
        \ 'action__directory' : d}
    endfunction

    let g:unite_source_menu_menus.set_ff = {
      \ 'description' : 'Change file format option.'}
    let g:unite_source_menu_menus.set_ff.command_candidates = [
      \ ['unix', 'FfUnix'],
      \ ['dos',  'FfDos'],
      \ ['mac',  'FfMac']]

    if has('multi_byte')
      let g:unite_source_menu_menus.set_fenc = {
        \ 'description' : 'Change file encding option.'}
      let g:unite_source_menu_menus.set_fenc.command_candidates = [
        \ ['utf-8',    'FencUtf8'],
        \ ['utf-16le', 'FencUtf16le'],
        \ ['utf-16',   'FencUtf16'],
        \ ['cp932',    'FencCp932'],
        \ ['euc-jp',   'FencEucjp']]
      if s:enc_jisx0213
        call extend(g:unite_source_menu_menus.set_fenc.command_candidates, [
          \ ['euc-jisx0213',  'FencEucJisx0213'],
          \ ['iso-2022-jp-3', 'FencIso2022jp']])
      else
        call extend(g:unite_source_menu_menus.set_fenc.command_candidates, [
          \ ['iso-2022-jp', 'FencIso2022jp']])
      endif

      let g:unite_source_menu_menus.edit_enc = {
        \ 'description' : 'Open with a specific character code again.'}
      let g:unite_source_menu_menus.edit_enc.command_candidates = [
        \ ['utf-8',    'EditUtf8'],
        \ ['utf-16le', 'EditUtf16le'],
        \ ['utf-16',   'EditUtf16'],
        \ ['cp932',    'EditCp932'],
        \ ['euc-jp',   'EditEucjp']]
      if s:enc_jisx0213
        call extend(g:unite_source_menu_menus.edit_enc.command_candidates, [
          \ ['euc-jisx0213',  'EditEucJisx0213'],
          \ ['iso-2022-jp-3', 'EditIso2022jp']])
      else
        call extend(g:unite_source_menu_menus.edit_enc.command_candidates, [
          \ ['iso-2022-jp', 'EditIso2022jp']])
      endif
    endif
  endfunction

  NXnoremap <Leader>u <Nop>
  NXnoremap <script> <Leader>uu <SID>:<C-U>Unite<Space>

  NXnoremap <Leader>uU
    \ :<C-U>Unite source
    \ -buffer-name=help -no-split<CR>

  NXnoremap <Leader>um :<C-U>Unite menu<CR>
  NXnoremap <Leader>u<CR> :<C-U>Unite menu:set_ff<CR>
  if has('multi_byte')
    NXnoremap <Leader>ue :<C-U>Unite menu:edit_enc<CR>
    NXnoremap <Leader>uf :<C-U>Unite menu:set_fenc<CR>
  endif

  NXnoremap <Leader>b
    \ :<C-U>Unite buffer
    \ -buffer-name=files -no-split<CR>
  NXnoremap <Leader>t
    \ :<C-U>Unite tab
    \ -buffer-name=files -no-split<CR>

  if &grepprg == 'internal'
    nnoremap sgsg
      \ :<C-U>Unite vimgrep
      \ -buffer-name=grep -no-split -wrap<CR>
  else
    nnoremap sgsg
      \ :<C-U>Unite grep
      \ -buffer-name=grep -no-split -wrap<CR>
  endif
  NXnoremap sG
    \ :<C-U>UniteResume grep
    \ -no-split -wrap -no-start-insert<CR>

  NXnoremap <Leader>j
    \ :<C-U>Unite jump
    \ -buffer-name=register -no-empty<CR>
  NXnoremap <Leader>J
    \ :<C-U>Unite change
    \ -buffer-name=register -no-empty<CR>
  nnoremap <C-P>
    \ :<C-U>Unite history/yank
    \ -buffer-name=register -no-empty -wrap<CR>
  xnoremap <C-P>
    \ d:<C-U>Unite history/yank
    \ -buffer-name=register -no-empty -wrap<CR>
  inoremap <expr> <C-P>
    \ unite#start_complete('history/yank', {
    \   'buffer_name': 'register',
    \   'is_multi_line' : 1,
    \   'direction' : 'leftabove'})

  NXnoremap <Leader>un
    \ :<C-U>UniteResume search -start-insert<CR>

  NXnoremap <Leader>u/
    \ :<C-U>Unite line
    \ -buffer-name=search -no-split -start-insert<CR>
  NXnoremap <Leader>u?
    \ :<C-U>Unite line:backward
    \ -buffer-name=search -no-split -start-insert<CR>
  NXnoremap <Leader>u*
    \ :<C-U>UniteWithCursorWord line
    \ -buffer-name=search -no-split -no-start-insert<CR>
  NXnoremap <Leader>u#
    \ :<C-U>UniteWithCursorWord line:backward
    \ -buffer-name=search -no-split -no-start-insert<CR>

  NXmap <Leader>ug/ <Leader>u*
  NXmap <Leader>ug? <Leader>u#

  call extend(s:altercmd_define, {
    \ 'u[nite]' : 'Unite'})
endif
"}}}

"------------------------------------------------------------------------------
" Unite Help: {{{
if s:has_neobundle && neobundle#tap('unite-help')
  nnoremap <Leader>u<F1>
    \ :<C-U>Unite help
    \ -buffer-name=help -start-insert<CR>
  nnoremap <Leader>u<F2>
    \ :<C-U>UniteWithCursorWord help
    \ -buffer-name=help -no-start-insert<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Unite Mark: {{{
if s:has_neobundle && neobundle#tap('unite-mark')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:unite_source_mark_marks =
      \ myvimrc#unite_source_mark_marks()
  endfunction

  nnoremap ml
    \ :<C-U>Unite mark bookmark
    \ -buffer-name=register -no-start-insert -no-empty<CR>
  nnoremap mu :<C-U>UniteBookmarkAdd<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Unite Outline: {{{
if s:has_neobundle && neobundle#tap('unite-outline')
  NXnoremap <Leader>uo
    \ :<C-U>Unite outline
    \ -buffer-name=outline -no-split<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Unite QuickFix: {{{
if s:has_neobundle && neobundle#tap('unite-quickfix')
  NXnoremap <Leader>u,
    \ :<C-U>Unite quickfix
    \ -buffer-name=register -no-empty<CR>
  NXnoremap <Leader>u.
    \ :<C-U>Unite location_list
    \ -buffer-name=register -no-empty<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Unite QuickRun Config: {{{
if s:has_neobundle && neobundle#tap('unite-quickrun_config')
  NXnoremap <Leader>ur
    \ :<C-U>Unite quickrun_config
    \ -buffer-name=register -no-empty<CR>
endif
"}}}

"------------------------------------------------------------------------------
" Unite Tag: {{{
if s:has_neobundle && neobundle#tap('unite-tag')
  NXnoremap <Leader>ut
    \ :<C-U>UniteWithCursorWord tag tag/include
    \ -buffer-name=outline -no-split -no-start-insert<CR>
endif
"}}}

"------------------------------------------------------------------------------
" VimDoc Ja: {{{
if s:has_neobundle && neobundle#tap('vimdoc-ja')
  set helplang^=ja
endif
"}}}

"------------------------------------------------------------------------------
" VimFiler: {{{
if s:has_neobundle && neobundle#tap('vimfiler')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:vimfiler_data_directory      = $HOME . '/.local/.cache/vimfiler'
    let g:vimfiler_as_default_explorer = 1
  endfunction

  NXnoremap <Leader>E     :<C-U>VimFiler<CR>
  NXnoremap <Leader><C-E> :<C-U>VimFilerExplorer<CR>
endif
"}}}

"------------------------------------------------------------------------------
" VimProc: {{{
if s:has_neobundle && neobundle#tap('vimproc')
  function! neobundle#tapped.hooks.on_source(bundle)
    if s:is_android
      let g:vimproc_dll_path = expand('/data/local/vimproc_unix.so')
    endif
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" VimShell: {{{
if s:has_neobundle && neobundle#tap('vimshell')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:vimshell_data_directory           = $HOME . '/.local/.cache/vimshell'
    let g:vimshell_vimshrc_path             = $HOME . '/.vim/.vimshrc'
    let g:vimshell_max_command_history      = 100000
    let g:vimshell_no_save_history_commands = {}
    let g:vimshell_scrollback_limit         = 500
    let g:vimshell_prompt                   = '$ '
    let g:vimshell_secondary_prompt         = '> '
    let g:vimshell_right_prompt             =
      \ 'vcs#info("(%s)-[%b]", "(%s)-[%b|%a]")'

    if has('win32')
      if filereadable('C:/Apps/ckw/ckw.exe')
        let g:vimshell_use_terminal_command = 'C:/Apps/ckw/ckw.exe -e'
      endif
      let g:vimshell_environment_term     = 'cygwin'
      let g:vimshell_user_prompt          =
        \ '$USERNAME . "@" . hostname() . " " . getcwd()'
    else
      let g:vimshell_environment_term     = 'xterm-256color'
      let g:vimshell_user_prompt          =
        \ '$USER . "@" . hostname() . " " . getcwd()'
    endif

    if s:executable('grep')
      call vimshell#set_alias('lld', 'ls -alF | grep "/$"')
      call vimshell#set_alias('llf', 'ls -alF | grep -v "/$"')
      call vimshell#set_alias('lle', 'ls -alF | grep "\*$"')
      call vimshell#set_alias('lls', 'ls -alF | grep "\->"')
    endif
    if s:executable('head')
      call vimshell#set_alias('h', 'head')
    endif
    if s:executable('tailf')
      call vimshell#set_alias('t', 'tailf')
    elseif s:executable('tail')
      call vimshell#set_alias('t', 'tail -f')
    endif
  endfunction

  NXnoremap <Leader>! :<C-U>VimShell<CR>

  call extend(s:altercmd_define, {
    \ 'sh[ell]' : 'VimShell',
    \
    \ '_sh[ell]' : 'shell'})
  call extend(s:neocompl_dictionary_filetype_lists, {
    \ 'vimshell' : $HOME . '/.local/.vimshell/command-history'})
endif
"}}}

"------------------------------------------------------------------------------
" VisualStar: {{{
if s:has_neobundle && neobundle#tap('visualstar')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:visualstar_no_default_key_mappings = 1
  endfunction

  xmap *  <Plug>(visualstar-*)
  xmap #  <Plug>(visualstar-#)
  xmap g* <Plug>(visualstar-g*)
  xmap g# <Plug>(visualstar-g#)

  xmap <SID>(visualstar-*)  <Plug>(visualstar-*)
  xmap <SID>(visualstar-#)  <Plug>(visualstar-#)
  xmap <SID>(visualstar-g*) <Plug>(visualstar-g*)
  xmap <SID>(visualstar-g#) <Plug>(visualstar-g#)

  xnoremap <script> <C-W>*
    \ <SID>(split-nicely)gv<SID>(visualstar-*)
  xnoremap <script> <C-W>#
    \ <SID>(split-nicely)gv<SID>(visualstar-#)
  xnoremap <script> <C-W>g*
    \ <SID>(split-nicely)gv<SID>(visualstar-g*)
  xnoremap <script> <C-W>g#
    \ <SID>(split-nicely)gv<SID>(visualstar-g#)
endif
"}}}

"------------------------------------------------------------------------------
" VisualStudio: {{{
if s:has_neobundle && neobundle#tap('visualstudio')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:visualstudio_controllerpath =
      \ neobundle#get('VisualStudioController').path .
      \ '/bin/VisualStudioController.exe'
  endfunction
endif
"}}}

"------------------------------------------------------------------------------
" WatchDogs: {{{
if s:has_neobundle && neobundle#tap('watchdogs')
  function! neobundle#tapped.hooks.on_source(bundle)
    let g:watchdogs_check_BufWritePost_enable = 1

    let g:quickrun_config =
      \ get(g:, 'quickrun_config', {})

    call extend(g:quickrun_config, {
      \ 'c/watchdogs_checker' : {
      \   'type' :
      \     s:executable('clang') ? 'watchdogs_checker/clang' :
      \     s:executable('gcc')   ? 'watchdogs_checker/gcc' :
      \     exists('$VCVARSALL')  ? 'watchdogs_checker/msvc' :
      \     s:executable('cl')    ? 'watchdogs_checker/msvc' : ''},
      \ 'cpp/watchdogs_checker' : {
      \   'type' :
      \     s:executable('clang-check') ? 'watchdogs_checker/clang_check' :
      \     s:executable('clang++')     ? 'watchdogs_checker/clang++' :
      \     s:executable('g++')         ? 'watchdogs_checker/g++' :
      \     exists('$VCVARSALL')        ? 'watchdogs_checker/msvc' :
      \     s:executable('cl')          ? 'watchdogs_checker/msvc' : ''},
      \ 'watchdogs_checker/msvc' : {
      \   'hook/output_encode/encoding' : has('win32') ? 'cp932' : &encoding,
      \   'hook/vcvarsall/enable' : exists('$VCVARSALL'),
      \   'hook/vcvarsall/bat' : $VCVARSALL},
      \
      \ 'vim/watchdogs_checker' : {
      \   'type' :
      \     has('python') ? 'watchdogs_checker/vimlint_by_dbakker' : ''}})

    call watchdogs#setup(g:quickrun_config)
  endfunction
endif
"}}}

"==============================================================================
" Post Init: {{{
silent! call neobundle#untap()

if filereadable($HOME . '/.local/.vimrc_local.vim')
  source ~/.local/.vimrc_local.vim
endif

if exists('#User#VimrcPost')
  execute 'doautocmd' (s:has_patch(7, 3, 438) ? '<nomodeline>' : '')
    \ 'User VimrcPost'
endif
"}}}