├── .github
    └── FUNDING.yml
├── CONTRIBUTING.markdown
├── LICENSE
├── README.markdown
└── autoload
    └── pathogen.vim


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: tpope
2 | custom: ["https://www.paypal.me/vimpope"]
3 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.markdown:
--------------------------------------------------------------------------------
 1 | Follow the commit message guidelines at [commit.style](https://commit.style).
 2 | This is an absolute requirement for my repositories, and doing so proves you
 3 | actually read the contribution guidelines, which makes for a good first
 4 | impression.
 5 | 
 6 | Good commit messages imply good commits.  Pull requests should typically be a
 7 | single commit, or for the rare complicated case, a series of atomic commits.
 8 | If I request a change, use `git commit --amend` or `git rebase --interactive`
 9 | and force push to your branch.
10 | 
11 | For feature requests, don't be shy about proposing it in an issue before
12 | drafting a patch.  If it's a great idea, I might do it for you.  If it's a
13 | terrible idea, no patch will change my mind.
14 | 
15 | The worst ideas are configuration options.  You'll need to provide a great
16 | justification in order to persuade me to take on the maintenance and support
17 | burden it will inevitably entail.  See if you can get away with a custom map
18 | or autocommand instead.
19 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | VIM LICENSE
 2 | 
 3 | I)  There are no restrictions on distributing unmodified copies of
 4 |     pathogen.vim except that they must include this license text.  You can
 5 |     also distribute unmodified parts of pathogen.vim, likewise unrestricted
 6 |     except that they must include this license text.  You are also allowed to
 7 |     include executables that you made from the unmodified pathogen.vim
 8 |     sources, plus your own usage examples and Vim scripts.
 9 | 
10 | II) It is allowed to distribute a modified (or extended) version of
11 |     pathogen.vim, including executables and/or source code, when the following
12 |     four conditions are met:
13 |     1) This license text must be included unmodified.
14 |     2) The modified pathogen.vim must be distributed in one of the following
15 |        five ways:
16 |        a) If you make changes to pathogen.vim yourself, you must clearly
17 |           describe in the distribution how to contact you.  When the
18 |           maintainer asks you (in any way) for a copy of the modified
19 |           pathogen.vim you distributed, you must make your changes, including
20 |           source code, available to the maintainer without fee.  The
21 |           maintainer reserves the right to include your changes in the
22 |           official version of pathogen.vim.  What the maintainer will do with
23 |           your changes and under what license they will be distributed is
24 |           negotiable.  If there has been no negotiation then this license, or
25 |           a later version, also applies to your changes. The current
26 |           maintainer is Bram Moolenaar <Bram@vim.org>.  If this changes it
27 |           will be announced in appropriate places (most likely vim.sf.net,
28 |           www.vim.org and/or comp.editors). When it is completely impossible
29 |           to contact the maintainer, the obligation to send him your changes
30 |           ceases.  Once the maintainer has confirmed that he has received your
31 |           changes they will not have to be sent again.
32 |        b) If you have received a modified pathogen.vim that was distributed as
33 |           mentioned under a) you are allowed to further distribute it
34 |           unmodified, as mentioned at I).  If you make additional changes the
35 |           text under a) applies to those changes.
36 |        c) Provide all the changes, including source code, with every copy of
37 |           the modified pathogen.vim you distribute.  This may be done in the
38 |           form of a context diff.  You can choose what license to use for new
39 |           code you add.  The changes and their license must not restrict
40 |           others from making their own changes to the official version of
41 |           pathogen.vim.
42 |        d) When you have a modified pathogen.vim which includes changes as
43 |           mentioned under c), you can distribute it without the source code
44 |           for the changes if the following three conditions are met:
45 |           - The license that applies to the changes permits you to distribute
46 |             the changes to the Vim maintainer without fee or restriction, and
47 |             permits the Vim maintainer to include the changes in the official
48 |             version of pathogen.vim without fee or restriction.
49 |           - You keep the changes for at least three years after last
50 |             distributing the corresponding modified pathogen.vim.  When the
51 |             maintainer or someone who you distributed the modified
52 |             pathogen.vim to asks you (in any way) for the changes within this
53 |             period, you must make them available to him.
54 |           - You clearly describe in the distribution how to contact you.  This
55 |             contact information must remain valid for at least three years
56 |             after last distributing the corresponding modified pathogen.vim,
57 |             or as long as possible.
58 |        e) When the GNU General Public License (GPL) applies to the changes,
59 |           you can distribute the modified pathogen.vim under the GNU GPL
60 |           version 2 or any later version.
61 |     3) A message must be added, at least in the output of the ":version"
62 |        command and in the intro screen, such that the user of the modified
63 |        pathogen.vim is able to see that it was modified.  When distributing as
64 |        mentioned under 2)e) adding the message is only required for as far as
65 |        this does not conflict with the license used for the changes.
66 |     4) The contact information as required under 2)a) and 2)d) must not be
67 |        removed or changed, except that the person himself can make
68 |        corrections.
69 | 
70 | III) If you distribute a modified version of pathogen.vim, you are encouraged
71 |      to use the Vim license for your changes and make them available to the
72 |      maintainer, including the source code.  The preferred way to do this is
73 |      by e-mail or by uploading the files to a server and e-mailing the URL. If
74 |      the number of changes is small (e.g., a modified Makefile) e-mailing a
75 |      context diff will do.  The e-mail address to be used is
76 |      <maintainer@vim.org>
77 | 
78 | IV)  It is not allowed to remove this license from the distribution of the
79 |      pathogen.vim sources, parts of it or from a modified version.  You may
80 |      use this license for previous pathogen.vim releases instead of the
81 |      license that they came with, at your option.
82 | 


--------------------------------------------------------------------------------
/README.markdown:
--------------------------------------------------------------------------------
  1 | # pathogen.vim
  2 | 
  3 | Manage your `'runtimepath'` with ease.  In practical terms, pathogen.vim
  4 | makes it super easy to install plugins and runtime files in their own
  5 | private directories.
  6 | 
  7 | **For new users, I recommend using Vim's built-in package management
  8 | instead.**  `:help packages`
  9 | 
 10 | ## Installation
 11 | 
 12 | Install to `~/.vim/autoload/pathogen.vim`.
 13 | Or copy and paste the following into your terminal/shell:
 14 | 
 15 |     mkdir -p ~/.vim/autoload ~/.vim/bundle && \
 16 |     curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
 17 | 
 18 | If you're using Windows, change all occurrences of `~/.vim` to `~\vimfiles`.
 19 | 
 20 | ## Runtime Path Manipulation
 21 | 
 22 | Add this to your vimrc:
 23 | 
 24 |     execute pathogen#infect()
 25 | 
 26 | If you're brand new to Vim and lacking a vimrc, `vim ~/.vimrc` and paste
 27 | in the following super-minimal example:
 28 | 
 29 |     execute pathogen#infect()
 30 |     syntax on
 31 |     filetype plugin indent on
 32 | 
 33 | Now any plugins you wish to install can be extracted to a subdirectory
 34 | under `~/.vim/bundle`, and they will be added to the `'runtimepath'`.
 35 | Observe:
 36 | 
 37 |     cd ~/.vim/bundle && \
 38 |     git clone https://github.com/tpope/vim-sensible.git
 39 | 
 40 | Now [sensible.vim](https://github.com/tpope/vim-sensible) is installed.
 41 | If you really want to get crazy, you could set it up as a submodule in
 42 | whatever repository you keep your dot files in.  I don't like to get
 43 | crazy.
 44 | 
 45 | If you don't like the directory name `bundle`, you can pass a runtime relative
 46 | glob as an argument:
 47 | 
 48 |     execute pathogen#infect('stuff/{}')
 49 | 
 50 | The `{}` indicates where the expansion should occur.
 51 | 
 52 | You can also pass an absolute path instead.  I keep the plugins I maintain under `~/src`, and this is how I add them:
 53 | 
 54 |     execute pathogen#infect('bundle/{}', '~/src/vim/bundle/{}')
 55 | 
 56 | Normally to generate documentation, Vim expects you to run `:helptags`
 57 | on each directory with documentation (e.g., `:helptags ~/.vim/doc`).
 58 | Provided with pathogen.vim is a `:Helptags` command that does this on
 59 | every directory in your `'runtimepath'`.  If you really want to get
 60 | crazy, you could even invoke `Helptags` in your vimrc.  I don't like to
 61 | get crazy.
 62 | 
 63 | Finally, pathogen.vim has a rich API that can manipulate `'runtimepath'`
 64 | and other comma-delimited path options in ways most people will never
 65 | need to do.  If you're one of those edge cases, look at the source.
 66 | It's well documented.
 67 | 
 68 | ## Native Vim Package Management
 69 | 
 70 | Vim 8 includes support for package management in a manner similar to
 71 | pathogen.vim.  If you'd like to transition to this native support,
 72 | pathogen.vim can help.  Calling `pathogen#infect()` on an older version of Vim
 73 | will supplement the `bundle/{}` default with `pack/{}/start/{}`, effectively
 74 | backporting a subset of the new native functionality.
 75 | 
 76 | ## Runtime File Editing
 77 | 
 78 | `:Vopen`, `:Vedit`, `:Vsplit`, `:Vvsplit`, `:Vtabedit`, `:Vpedit`, and
 79 | `:Vread` have all moved to [scriptease.vim][].
 80 | 
 81 | [scriptease.vim]: https://github.com/tpope/vim-scriptease
 82 | 
 83 | ## FAQ
 84 | 
 85 | > Can I put pathogen.vim in a submodule like all my other plugins?
 86 | 
 87 | Sure, stick it under `~/.vim/bundle`, and prepend the following to your
 88 | vimrc:
 89 | 
 90 |     runtime bundle/vim-pathogen/autoload/pathogen.vim
 91 | 
 92 | Or if your bundles are somewhere other than `~/.vim` (say, `~/src/vim`):
 93 | 
 94 |     source ~/src/vim/bundle/vim-pathogen/autoload/pathogen.vim
 95 | 
 96 | > Will you accept these 14 pull requests adding a `.gitignore` for
 97 | > `tags` so I don't see untracked changes in my dot files repository?
 98 | 
 99 | No, but I'll teach you how to ignore `tags` globally:
100 | 
101 |     git config --global core.excludesfile '~/.cvsignore'
102 |     echo tags >> ~/.cvsignore
103 | 
104 | While any filename will work, I've chosen to follow the ancient
105 | tradition of `.cvsignore` because utilities like rsync use it, too.
106 | Clever, huh?
107 | 
108 | > What about Vimballs?
109 | 
110 | If you really must use one:
111 | 
112 |     :e name.vba
113 |     :!mkdir ~/.vim/bundle/name
114 |     :UseVimball ~/.vim/bundle/name
115 | 
116 | > Why don't my plugins load when I use Vim sessions?
117 | 
118 | Vim sessions default to capturing all global options, which includes the
119 | `'runtimepath'` that pathogen.vim manipulates.  This can cause other problems
120 | too, so I recommend turning that behavior off:
121 | 
122 |     set sessionoptions-=options
123 | 
124 | ## Contributing
125 | 
126 | If your [commit message sucks](http://stopwritingramblingcommitmessages.com/),
127 | I'm not going to accept your pull request.  I've explained very politely
128 | dozens of times that
129 | [my general guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
130 | are absolute rules on my own repositories, so I may lack the energy to
131 | explain it to you yet another time.  And please, if I ask you to change
132 | something, `git commit --amend`.
133 | 
134 | Beyond that, don't be shy about asking before patching.  What takes you
135 | hours might take me minutes simply because I have both domain knowledge
136 | and a perverse knowledge of Vim script so vast that many would consider
137 | it a symptom of mental illness.  On the flip side, some ideas I'll
138 | reject no matter how good the implementation is.  "Send a patch" is an
139 | edge case answer in my book.
140 | 
141 | ## Self-Promotion
142 | 
143 | Like pathogen.vim?  Follow the repository on
144 | [GitHub](https://github.com/tpope/vim-pathogen) and vote for it on
145 | [vim.org](http://www.vim.org/scripts/script.php?script_id=2332).  And if
146 | you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
147 | [Twitter](http://twitter.com/tpope) and
148 | [GitHub](https://github.com/tpope).
149 | 
150 | ## License
151 | 
152 | Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
153 | See `:help license`.
154 | 


--------------------------------------------------------------------------------
/autoload/pathogen.vim:
--------------------------------------------------------------------------------
  1 | " pathogen.vim - path option manipulation
  2 | " Maintainer:   Tim Pope <http://tpo.pe/>
  3 | " Version:      2.4
  4 | 
  5 | " Install in ~/.vim/autoload (or ~\vimfiles\autoload).
  6 | "
  7 | " For management of individually installed plugins in ~/.vim/bundle (or
  8 | " ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
  9 | " .vimrc is the only other setup necessary.
 10 | "
 11 | " The API is documented inline below.
 12 | 
 13 | if exists("g:loaded_pathogen") || &cp
 14 |   finish
 15 | endif
 16 | let g:loaded_pathogen = 1
 17 | 
 18 | " Point of entry for basic default usage.  Give a relative path to invoke
 19 | " pathogen#interpose() or an absolute path to invoke pathogen#surround().
 20 | " Curly braces are expanded with pathogen#expand(): "bundle/{}" finds all
 21 | " subdirectories inside "bundle" inside all directories in the runtime path.
 22 | " If no arguments are given, defaults "bundle/{}", and also "pack/{}/start/{}"
 23 | " on versions of Vim without native package support.
 24 | function! pathogen#infect(...) abort
 25 |   if a:0
 26 |     let paths = filter(reverse(copy(a:000)), 'type(v:val) == type("")')
 27 |   else
 28 |     let paths = ['bundle/{}', 'pack/{}/start/{}']
 29 |   endif
 30 |   if has('packages')
 31 |     call filter(paths, 'v:val !~# "^pack/[^/]*/start/[^/]*$"')
 32 |   endif
 33 |   let static = '^\%([$~\\/]\|\w:[\\/]\)[^{}*]*$'
 34 |   for path in filter(copy(paths), 'v:val =~# static')
 35 |     call pathogen#surround(path)
 36 |   endfor
 37 |   for path in filter(copy(paths), 'v:val !~# static')
 38 |     if path =~# '^\%([$~\\/]\|\w:[\\/]\)'
 39 |       call pathogen#surround(path)
 40 |     else
 41 |       call pathogen#interpose(path)
 42 |     endif
 43 |   endfor
 44 |   call pathogen#cycle_filetype()
 45 |   if pathogen#is_disabled($MYVIMRC)
 46 |     return 'finish'
 47 |   endif
 48 |   return ''
 49 | endfunction
 50 | 
 51 | " Split a path into a list.
 52 | function! pathogen#split(path) abort
 53 |   if type(a:path) == type([]) | return a:path | endif
 54 |   if empty(a:path) | return [] | endif
 55 |   let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
 56 |   return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
 57 | endfunction
 58 | 
 59 | " Convert a list to a path.
 60 | function! pathogen#join(...) abort
 61 |   if type(a:1) == type(1) && a:1
 62 |     let i = 1
 63 |     let space = ' '
 64 |   else
 65 |     let i = 0
 66 |     let space = ''
 67 |   endif
 68 |   let path = ""
 69 |   while i < a:0
 70 |     if type(a:000[i]) == type([])
 71 |       let list = a:000[i]
 72 |       let j = 0
 73 |       while j < len(list)
 74 |         let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
 75 |         let path .= ',' . escaped
 76 |         let j += 1
 77 |       endwhile
 78 |     else
 79 |       let path .= "," . a:000[i]
 80 |     endif
 81 |     let i += 1
 82 |   endwhile
 83 |   return substitute(path,'^,','','')
 84 | endfunction
 85 | 
 86 | " Convert a list to a path with escaped spaces for 'path', 'tag', etc.
 87 | function! pathogen#legacyjoin(...) abort
 88 |   return call('pathogen#join',[1] + a:000)
 89 | endfunction
 90 | 
 91 | " Turn filetype detection off and back on again if it was already enabled.
 92 | function! pathogen#cycle_filetype() abort
 93 |   if exists('g:did_load_filetypes')
 94 |     filetype off
 95 |     filetype on
 96 |   endif
 97 | endfunction
 98 | 
 99 | " Check if a bundle is disabled.  A bundle is considered disabled if its
100 | " basename or full name is included in the list g:pathogen_blacklist or the
101 | " comma delimited environment variable $VIMBLACKLIST.
102 | function! pathogen#is_disabled(path) abort
103 |   if a:path =~# '\~$'
104 |     return 1
105 |   endif
106 |   let sep = pathogen#slash()
107 |   let blacklist = get(g:, 'pathogen_blacklist', get(g:, 'pathogen_disabled', [])) + pathogen#split($VIMBLACKLIST)
108 |   if !empty(blacklist)
109 |     call map(blacklist, 'substitute(v:val, "[\\/]$", "", "")')
110 |   endif
111 |   return index(blacklist, fnamemodify(a:path, ':t')) != -1 || index(blacklist, a:path) != -1
112 | endfunction
113 | 
114 | " Prepend the given directory to the runtime path and append its corresponding
115 | " after directory.  Curly braces are expanded with pathogen#expand().
116 | function! pathogen#surround(path) abort
117 |   let sep = pathogen#slash()
118 |   let rtp = pathogen#split(&rtp)
119 |   let path = fnamemodify(a:path, ':s?[\\/]\=$??')
120 |   let before = filter(pathogen#expand(path), '!pathogen#is_disabled(v:val)')
121 |   let after = filter(reverse(pathogen#expand(path, sep.'after')), '!pathogen#is_disabled(v:val[0 : -7])')
122 |   call filter(rtp, 'index(before + after, v:val) == -1')
123 |   let &rtp = pathogen#join(before, rtp, after)
124 |   return &rtp
125 | endfunction
126 | 
127 | " For each directory in the runtime path, add a second entry with the given
128 | " argument appended.  Curly braces are expanded with pathogen#expand().
129 | function! pathogen#interpose(name) abort
130 |   let sep = pathogen#slash()
131 |   let name = a:name
132 |   if has_key(s:done_bundles, name)
133 |     return ""
134 |   endif
135 |   let s:done_bundles[name] = 1
136 |   let list = []
137 |   for dir in pathogen#split(&rtp)
138 |     if dir =~# '\<after$'
139 |       let list += reverse(filter(pathogen#expand(dir[0 : -6].name, sep.'after'), '!pathogen#is_disabled(v:val[0 : -7])')) + [dir]
140 |     else
141 |       let list += [dir] + filter(pathogen#expand(dir.sep.name), '!pathogen#is_disabled(v:val)')
142 |     endif
143 |   endfor
144 |   let &rtp = pathogen#join(pathogen#uniq(list))
145 |   return 1
146 | endfunction
147 | 
148 | let s:done_bundles = {}
149 | 
150 | " Invoke :helptags on all non-$VIM doc directories in runtimepath.
151 | function! pathogen#helptags() abort
152 |   let sep = pathogen#slash()
153 |   for glob in pathogen#split(&rtp)
154 |     for dir in map(split(glob(glob), "\n"), 'v:val.sep."/doc/".sep')
155 |       if (dir)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir) == 2 && !empty(split(glob(dir.'*.txt'))) && (!filereadable(dir.'tags') || filewritable(dir.'tags'))
156 |         silent! execute 'helptags' pathogen#fnameescape(dir)
157 |       endif
158 |     endfor
159 |   endfor
160 | endfunction
161 | 
162 | command! -bar Helptags :call pathogen#helptags()
163 | 
164 | " Execute the given command.  This is basically a backdoor for --remote-expr.
165 | function! pathogen#execute(...) abort
166 |   for command in a:000
167 |     execute command
168 |   endfor
169 |   return ''
170 | endfunction
171 | 
172 | " Section: Unofficial
173 | 
174 | function! pathogen#is_absolute(path) abort
175 |   return a:path =~# (has('win32') ? '^\%([\\/]\|\w:\)[\\/]\|^[~$]' : '^[/~$]')
176 | endfunction
177 | 
178 | " Given a string, returns all possible permutations of comma delimited braced
179 | " alternatives of that string.  pathogen#expand('/{a,b}/{c,d}') yields
180 | " ['/a/c', '/a/d', '/b/c', '/b/d'].  Empty braces are treated as a wildcard
181 | " and globbed.  Actual globs are preserved.
182 | function! pathogen#expand(pattern, ...) abort
183 |   let after = a:0 ? a:1 : ''
184 |   let pattern = substitute(a:pattern, '^[~$][^\/]*', '\=expand(submatch(0))', '')
185 |   if pattern =~# '{[^{}]\+}'
186 |     let [pre, pat, post] = split(substitute(pattern, '\(.\{-\}\){\([^{}]\+\)}\(.*\)', "\\1\001\\2\001\\3", ''), "\001", 1)
187 |     let found = map(split(pat, ',', 1), 'pre.v:val.post')
188 |     let results = []
189 |     for pattern in found
190 |       call extend(results, pathogen#expand(pattern))
191 |     endfor
192 |   elseif pattern =~# '{}'
193 |     let pat = matchstr(pattern, '^.*{}[^*]*\%($\|[\\/]\)')
194 |     let post = pattern[strlen(pat) : -1]
195 |     let results = map(split(glob(substitute(pat, '{}', '*', 'g')), "\n"), 'v:val.post')
196 |   else
197 |     let results = [pattern]
198 |   endif
199 |   let vf = pathogen#slash() . 'vimfiles'
200 |   call map(results, 'v:val =~# "\\*" ? v:val.after : isdirectory(v:val.vf.after) ? v:val.vf.after : isdirectory(v:val.after) ? v:val.after : ""')
201 |   return filter(results, '!empty(v:val)')
202 | endfunction
203 | 
204 | " \ on Windows unless shellslash is set, / everywhere else.
205 | function! pathogen#slash() abort
206 |   return !exists("+shellslash") || &shellslash ? '/' : '\'
207 | endfunction
208 | 
209 | function! pathogen#separator() abort
210 |   return pathogen#slash()
211 | endfunction
212 | 
213 | " Convenience wrapper around glob() which returns a list.
214 | function! pathogen#glob(pattern) abort
215 |   let files = split(glob(a:pattern),"\n")
216 |   return map(files,'substitute(v:val,"[".pathogen#slash()."/]$","","")')
217 | endfunction
218 | 
219 | " Like pathogen#glob(), only limit the results to directories.
220 | function! pathogen#glob_directories(pattern) abort
221 |   return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
222 | endfunction
223 | 
224 | " Remove duplicates from a list.
225 | function! pathogen#uniq(list) abort
226 |   let i = 0
227 |   let seen = {}
228 |   while i < len(a:list)
229 |     if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
230 |       call remove(a:list,i)
231 |     elseif a:list[i] ==# ''
232 |       let i += 1
233 |       let empty = 1
234 |     else
235 |       let seen[a:list[i]] = 1
236 |       let i += 1
237 |     endif
238 |   endwhile
239 |   return a:list
240 | endfunction
241 | 
242 | " Backport of fnameescape().
243 | function! pathogen#fnameescape(string) abort
244 |   if exists('*fnameescape')
245 |     return fnameescape(a:string)
246 |   elseif a:string ==# '-'
247 |     return '\-'
248 |   else
249 |     return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
250 |   endif
251 | endfunction
252 | 
253 | " Like findfile(), but hardcoded to use the runtimepath.
254 | function! pathogen#runtime_findfile(file,count) abort
255 |   let rtp = pathogen#join(1,pathogen#split(&rtp))
256 |   let file = findfile(a:file,rtp,a:count)
257 |   if file ==# ''
258 |     return ''
259 |   else
260 |     return fnamemodify(file,':p')
261 |   endif
262 | endfunction
263 | 
264 | " vim:set et sw=2:
265 | 


--------------------------------------------------------------------------------