Vim regexp

http://vimdoc.sourceforge.net/htmldoc/pattern.html#pattern

*pattern.txt*   For Vim version 7.3.  Last change: 2011 Feb 25


    VIM REFERENCE MANUAL    by Bram Moolenaar



Patterns and search commands    *pattern-searches*

The very basics can be found in section |03.9| of the user manual.  A few more
explanations are in chapter 27 |usr_27.txt|.

1. Search commands  |search-commands|
2. The definition of a pattern |search-pattern|
3. Magic   |/magic|
4. Overview of pattern items |pattern-overview|
5. Multi items   |pattern-multi-items|
6. Ordinary atoms  |pattern-atoms|
7. Ignoring case in a pattern |/ignorecase|
8. Composing characters  |patterns-composing|
9. Compare with Perl patterns |perl-patterns|
10. Highlighting matches |match-highlight|

==============================================================================

1. Search commands    *search-commands* *E486*


       */*
/{pattern}[/]<CR> Search forward for the [count]'th occurrence of
   {pattern} |exclusive|.

/{pattern}/{offset}<CR> Search forward for the [count]'th occurrence of
   {pattern} and go |{offset}| lines up or down.
   |linewise|.


       */<CR>*
/<CR>   Search forward for the [count]'th occurrence of the
   latest used pattern |last-pattern| with latest used
   |{offset}|.

//{offset}<CR>  Search forward for the [count]'th occurrence of the
   latest used pattern |last-pattern| with new
   |{offset}|.  If {offset} is empty no offset is used.


       *?*
?{pattern}[?]<CR> Search backward for the [count]'th previous
   occurrence of {pattern} |exclusive|.

?{pattern}?{offset}<CR> Search backward for the [count]'th previous
   occurrence of {pattern} and go |{offset}| lines up or
   down |linewise|.


       *?<CR>*
?<CR>   Search backward for the [count]'th occurrence of the
   latest used pattern |last-pattern| with latest used
   |{offset}|.

??{offset}<CR>  Search backward for the [count]'th occurrence of the
   latest used pattern |last-pattern| with new
   |{offset}|.  If {offset} is empty no offset is used.


       *n*
n   Repeat the latest "/" or "?" [count] times.
   |last-pattern| {Vi: no count}


       *N*
N   Repeat the latest "/" or "?" [count] times in
   opposite direction. |last-pattern| {Vi: no count}


       *star* *E348* *E349*
*   Search forward for the [count]'th occurrence of the
   word nearest to the cursor.  The word used for the
   search is the first of:
    1. the keyword under the cursor |'iskeyword'|
    2. the first keyword after the cursor, in the
       current line
    3. the non-blank word under the cursor
    4. the first non-blank word after the cursor,
       in the current line
   Only whole keywords are searched for, like with the
   command "/\<keyword\>".  |exclusive|  {not in Vi}
   'ignorecase' is used, 'smartcase' is not.


       *#*
#   Same as "*", but search backward.  The pound sign
   (character 163) also works.  If the "#" key works as
   backspace, try using "stty erase <BS>" before starting
   Vim (<BS> is CTRL-H or a real backspace).  {not in Vi}


       *gstar*
g*   Like "*", but don't put "\<" and "\>" around the word.
   This makes the search also find matches that are not a
   whole word.  {not in Vi}


       *g#*
g#   Like "#", but don't put "\<" and "\>" around the word.
   This makes the search also find matches that are not a
   whole word.  {not in Vi}


       *gd*
gd   Goto local Declaration.  When the cursor is on a local
   variable, this command will jump to its declaration.
   First Vim searches for the start of the current
   function, just like "[[".  If it is not found the
   search stops in line 1.  If it is found, Vim goes back
   until a blank line is found.  From this position Vim
   searches for the keyword under the cursor, like with
   "*", but lines that look like a comment are ignored
   (see 'comments' option).
   Note that this is not guaranteed to work, Vim does not
   really check the syntax, it only searches for a match
   with the keyword.  If included files also need to be
   searched use the commands listed in |include-search|.
   After this command |n| searches forward for the next
   match (not backward).
   {not in Vi}


       *gD*
gD   Goto global Declaration.  When the cursor is on a
   global variable that is defined in the file, this
   command will jump to its declaration.  This works just
   like "gd", except that the search for the keyword
   always starts in line 1.  {not in Vi}


       *1gd*
1gd   Like "gd", but ignore matches inside a {} block that
   ends before the cursor position. {not in Vi}


       *1gD*
1gD   Like "gD", but ignore matches inside a {} block that
   ends before the cursor position. {not in Vi}


       *CTRL-C*
CTRL-C   Interrupt current (search) command.  Use CTRL-Break on
   MS-DOS |dos-CTRL-Break|.
   In Normal mode, any pending command is aborted.


       *:noh* *:nohlsearch*
:noh[lsearch]  Stop the highlighting for the 'hlsearch' option.  It
   is automatically turned back on when using a search
   command, or setting the 'hlsearch' option.
   This command doesn't work in an autocommand, because
   the highlighting state is saved and restored when
   executing autocommands |autocmd-searchpat|.
   Same thing for when invoking a user function.

While typing the search pattern the current match will be shown if the
'incsearch' option is on.  Remember that you still have to finish the search
command with <CR> to actually position the cursor at the displayed match.  Or
use <Esc> to abandon the search.

All matches for the last used search pattern will be highlighted if you set
the 'hlsearch' option.  This can be suspended with the |:nohlsearch| command.


     *search-offset* *{offset}*
These commands search for the specified pattern.  With "/" and "?" an
additional offset may be given.  There are two types of offsets: line offsets
and character offsets.  {the character offsets are not in Vi}

The offset gives the cursor position relative to the found match:
    [num] [num] lines downwards, in column 1
    +[num] [num] lines downwards, in column 1
    -[num] [num] lines upwards, in column 1
    e[+num] [num] characters to the right of the end of the match
    e[-num] [num] characters to the left of the end of the match
    s[+num] [num] characters to the right of the start of the match
    s[-num] [num] characters to the left of the start of the match
    b[+num] [num] identical to s[+num] above (mnemonic: begin)
    b[-num] [num] identical to s[-num] above (mnemonic: begin)
    ;{pattern}  perform another search, see |//;|

If a '-' or '+' is given but [num] is omitted, a count of one will be used.
When including an offset with 'e', the search becomes inclusive (the
character the cursor lands on is included in operations).

Examples:

pattern   cursor position 
/test/+1  one line below "test", in column 1
/test/e   on the last t of "test"
/test/s+2  on the 's' of "test"
/test/b-3  three characters before "test"

If one of these commands is used after an operator, the characters between
the cursor position before and after the search is affected.  However, if a
line offset is given, the whole lines between the two cursor positions are
affected.

An example of how to search for matches with a pattern and change the match
with another word:
 /foo<CR> find "foo"
 c//e  change until end of match
 bar<Esc> type replacement
 //<CR>  go to start of next match
 c//e  change until end of match
 beep<Esc> type another replacement
   etc.
 

       *//;* *E386*
A very special offset is ';' followed by another search command.  For example:

   /test 1/;/test
   /test.*/+1;?ing?

The first one first finds the next occurrence of "test 1", and then the first
occurrence of "test" after that.

This is like executing two search commands after each other, except that:
- It can be used as a single motion command after an operator.
- The direction for a following "n" or "N" command comes from the first
  search command.
- When an error occurs the cursor is not moved at all.


       *last-pattern*
The last used pattern and offset are remembered.  They can be used to repeat
the search, possibly in another direction or with another count.  Note that
two patterns are remembered: One for 'normal' search commands and one for the
substitute command ":s".  Each time an empty pattern is given, the previously
used pattern is used.  However, if there is no previous search command, a
previous substitute pattern is used, if possible.

The 'magic' option sticks with the last used pattern.  If you change 'magic',
this will not change how the last used pattern will be interpreted.
The 'ignorecase' option does not do this.  When 'ignorecase' is changed, it
will result in the pattern to match other text.

All matches for the last used search pattern will be highlighted if you set
the 'hlsearch' option.

To clear the last used search pattern:
 :let @/ = ""
This will not set the pattern to an empty string, because that would match
everywhere.  The pattern is really cleared, like when starting Vim.

The search usually skips matches that don't move the cursor.  Whether the next
match is found at the next character or after the skipped match depends on the
'c' flag in 'cpoptions'.  See |cpo-c|.
    with 'c' flag:   "/..." advances 1 to 3 characters
 without 'c' flag:   "/..." advances 1 character
The unpredictability with the 'c' flag is caused by starting the search in the
first column, skipping matches until one is found past the cursor position.

When searching backwards, searching starts at the start of the line, using the
'c' flag in 'cpoptions' as described above.  Then the last match before the
cursor position is used.

In Vi the ":tag" command sets the last search pattern when the tag is searched
for.  In Vim this is not done, the previous search pattern is still remembered,
unless the 't' flag is present in 'cpoptions'.  The search pattern is always
put in the search history.

If the 'wrapscan' option is on (which is the default), searches wrap around
the end of the buffer.  If 'wrapscan' is not set, the backward search stops
at the beginning and the forward search stops at the end of the buffer.  If
'wrapscan' is set and the pattern was not found the error message "pattern
not found" is given, and the cursor will not be moved.  If 'wrapscan' is not
set the message becomes "search hit BOTTOM without match" when searching
forward, or "search hit TOP without match" when searching backward.  If
wrapscan is set and the search wraps around the end of the file the message
"search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at
TOP" is given when searching backwards or forwards respectively.  This can be
switched off by setting the 's' flag in the 'shortmess' option.  The highlight
method 'w' is used for this message (default: standout).


       *search-range*
You can limit the search command "/" to a certain range of lines by including
\%>l items.  For example, to match the word "limit" below line 199 and above
line 300:
 /\%>199l\%<300llimit
Also see |/\%>l|.

Another way is to use the ":substitute" command with the 'c' flag.  Example:
   :.,300s/Pattern//gc
This command will search from the cursor position until line 300 for
"Pattern".  At the match, you will be asked to type a character.  Type 'q' to
stop at this match, type 'n' to find the next match.

The "*", "#", "g*" and "g#" commands look for a word near the cursor in this
order, the first one that is found is used:
- The keyword currently under the cursor.
- The first keyword to the right of the cursor, in the same line.
- The WORD currently under the cursor.
- The first WORD to the right of the cursor, in the same line.
The keyword may only contain letters and characters in 'iskeyword'.
The WORD may contain any non-blanks (<Tab>s and/or <Space>s).
Note that if you type with ten fingers, the characters are easy to remember:
the "#" is under your left hand middle finger (search to the left and up) and
the "*" is under your right hand middle finger (search to the right and down).
(this depends on your keyboard layout though).

==============================================================================

2. The definition of a pattern  *search-pattern* *pattern* *[pattern]*

     *regular-expression* *regexp* *Pattern*

     *E76* *E383* *E476*

For starters, read chapter 27 of the user manual |usr_27.txt|.


      */bar* */\bar* */pattern*
1. A pattern is one or more branches, separated by "\|".  It matches anything
   that matches one of the branches.  Example: "foo\|beep" matches "foo" and
   matches "beep".  If more than one branch matches, the first one is used.

   pattern ::=     branch
  or  branch \| branch
  or  branch \| branch \| branch
  etc.


      */branch* */\&*
2. A branch is one or more concats, separated by "\&".  It matches the last
   concat, but only if all the preceding concats also match at the same
   position.  Examples:
 "foobeep\&..." matches "foo" in "foobeep".
 ".*Peter\&.*Bob" matches in a line containing both "Peter" and "Bob"

   branch ::=     concat
  or  concat \& concat
  or  concat \& concat \& concat
  etc.


      */concat*
3. A concat is one or more pieces, concatenated.  It matches a match for the
   first piece, followed by a match for the second piece, etc.  Example:
   "f[0-9]b", first matches "f", then a digit and then "b".

   concat  ::=     piece
  or  piece piece
  or  piece piece piece
  etc.


      */piece*
4. A piece is an atom, possibly followed by a multi, an indication of how many
   times the atom can be matched.  Example: "a*" matches any sequence of "a"
   characters: "", "a", "aa", etc.  See |/multi|.

   piece   ::=     atom
  or  atom  multi


      */atom*
5. An atom can be one of a long list of items.  Many atoms match one character
   in the text.  It is often an ordinary character or a character class.
   Braces can be used to make a pattern into an atom.  The "\z(\)" construct
   is only for syntax highlighting.

   atom    ::=     ordinary-atom  |/ordinary-atom|
  or  \( pattern \)  |/\(|
  or  \%( pattern \)  |/\%(|
  or  \z( pattern \)  |/\z(|


==============================================================================

3. Magic       */magic*

Some characters in the pattern are taken literally.  They match with the same
character in the text.  When preceded with a backslash however, these
characters get a special meaning.

Other characters have a special meaning without a backslash.  They need to be
preceded with a backslash to match literally.

If a character is taken literally or not depends on the 'magic' option and the
items mentioned next.

       */\m* */\M*
Use of "\m" makes the pattern after it be interpreted as if 'magic' is set,
ignoring the actual value of the 'magic' option.
Use of "\M" makes the pattern after it be interpreted as if 'nomagic' is used.

       */\v* */\V*
Use of "\v" means that in the pattern after it all ASCII characters except
'0'-'9', 'a'-'z', 'A'-'Z' and '_' have a special meaning.  "very magic"

Use of "\V" means that in the pattern after it only the backslash has a
special meaning.  "very nomagic"

Examples:
after:   \v    \m     \M      \V  matches 
  'magic' 'nomagic'
   $    $     $      \$  matches end-of-line
   .    .     \.      \.  matches any character
   *    *     \*      \*  any number of the previous atom
   ()    \(\)     \(\)     \(\) grouping into an atom
   |    \|     \|      \|  separating alternatives
   \a    \a     \a      \a  alphabetic character
   \\    \\     \\      \\  literal backslash
   \.    \.     .      .  literal dot
   \{    {     {      {  literal '{'
   a    a     a      a  literal 'a'

{only Vim supports \m, \M, \v and \V}

It is recommended to always keep the 'magic' option at the default setting,
which is 'magic'.  This avoids portability problems.  To make a pattern immune
to the 'magic' option being set or not, put "\m" or "\M" at the start of the
pattern.

==============================================================================

4. Overview of pattern items    *pattern-overview*


Overview of multi items.    */multi* *E61* *E62*

More explanation and examples below, follow the links.   *E64*

   multi 
     'magic' 'nomagic' matches of the preceding atom 
|/star| * \* 0 or more as many as possible
|/\+| \+ \+ 1 or more as many as possible (*)
|/\=| \= \= 0 or 1  as many as possible (*)
|/\?| \? \? 0 or 1  as many as possible (*)

|/\{| \{n,m} \{n,m} n to m  as many as possible (*)
 \{n} \{n} n  exactly (*)
 \{n,} \{n,} at least n as many as possible (*)
 \{,m} \{,m} 0 to m  as many as possible (*)
 \{} \{} 0 or more as many as possible (same as *) (*)

|/\{-| \{-n,m} \{-n,m} n to m  as few as possible (*)
 \{-n} \{-n} n  exactly (*)
 \{-n,} \{-n,} at least n as few as possible (*)
 \{-,m} \{-,m} 0 to m  as few as possible (*)
 \{-} \{-} 0 or more as few as possible (*)


       *E59*
|/\@>| \@> \@> 1, like matching a whole pattern (*)
|/\@=| \@= \@= nothing, requires a match |/zero-width| (*)
|/\@!| \@! \@! nothing, requires NO match |/zero-width| (*)
|/\@<=| \@<= \@<= nothing, requires a match behind |/zero-width| (*)
|/\@<!| \@<! \@<! nothing, requires NO match behind |/zero-width| (*)

(*) {not in Vi}



Overview of ordinary atoms.    */ordinary-atom*
More explanation and examples below, follow the links.

      ordinary atom 
      magic   nomagic matches 
|/^| ^ ^ start-of-line (at start of pattern) |/zero-width|
|/\^| \^ \^ literal '^'
|/\_^| \_^ \_^ start-of-line (used anywhere) |/zero-width|
|/$| $ $ end-of-line (at end of pattern) |/zero-width|
|/\$| \$ \$ literal '$'
|/\_$| \_$ \_$ end-of-line (used anywhere) |/zero-width|
|/.| . \. any single character (not an end-of-line)
|/\_.| \_. \_. any single character or end-of-line
|/\<| \< \< beginning of a word |/zero-width|
|/\>| \> \> end of a word |/zero-width|
|/\zs| \zs \zs anything, sets start of match
|/\ze| \ze \ze anything, sets end of match

|/\%^| \%^ \%^ beginning of file |/zero-width|  *E71*
|/\%$| \%$ \%$ end of file |/zero-width|
|/\%V| \%V \%V inside Visual area |/zero-width|
|/\%#| \%# \%# cursor position |/zero-width|
|/\%'m| \%'m \%'m mark m position |/zero-width|
|/\%l| \%23l \%23l in line 23 |/zero-width|
|/\%c| \%23c \%23c in column 23 |/zero-width|
|/\%v| \%23v \%23v in virtual column 23 |/zero-width|


Character classes {not in Vi}:    */character-classes*
|/\i| \i \i identifier character (see 'isident' option)
|/\I| \I \I like "\i", but excluding digits
|/\k| \k \k keyword character (see 'iskeyword' option)
|/\K| \K \K like "\k", but excluding digits
|/\f| \f \f file name character (see 'isfname' option)
|/\F| \F \F like "\f", but excluding digits
|/\p| \p \p printable character (see 'isprint' option)
|/\P| \P \P like "\p", but excluding digits
|/\s| \s \s whitespace character: <Space> and <Tab>
|/\S| \S \S non-whitespace character; opposite of \s
|/\d| \d \d digit:    [0-9]
|/\D| \D \D non-digit:   [^0-9]
|/\x| \x \x hex digit:   [0-9A-Fa-f]
|/\X| \X \X non-hex digit:   [^0-9A-Fa-f]
|/\o| \o \o octal digit:   [0-7]
|/\O| \O \O non-octal digit:  [^0-7]
|/\w| \w \w word character:   [0-9A-Za-z_]
|/\W| \W \W non-word character:  [^0-9A-Za-z_]
|/\h| \h \h head of word character:  [A-Za-z_]
|/\H| \H \H non-head of word character: [^A-Za-z_]
|/\a| \a \a alphabetic character:  [A-Za-z]
|/\A| \A \A non-alphabetic character: [^A-Za-z]
|/\l| \l \l lowercase character:  [a-z]
|/\L| \L \L non-lowercase character: [^a-z]
|/\u| \u \u uppercase character:  [A-Z]
|/\U| \U \U non-uppercase character  [^A-Z]
|/\_| \_x \_x where x is any of the characters above: character
   class with end-of-line included
(end of character classes)

|/\e| \e \e <Esc>
|/\t| \t \t <Tab>
|/\r| \r \r <CR>
|/\b| \b \b <BS>
|/\n| \n \n end-of-line
|/~| ~ \~ last given substitute string
|/\1| \1 \1 same string as matched by first \(\) {not in Vi}
|/\2| \2 \2 Like "\1", but uses second \(\)
    ...
|/\9| \9 \9 Like "\1", but uses ninth \(\)

        *E68*
|/\z1| \z1 \z1 only for syntax highlighting, see |:syn-ext-match|
    ...
|/\z1| \z9 \z9 only for syntax highlighting, see |:syn-ext-match|

 x x a character with no special meaning matches itself

|/[]| [] \[] any character specified inside the []
|/\%[]| \%[] \%[] a sequence of optionally matched atoms

|/\c| \c \c ignore case, do not use the 'ignorecase' option
|/\C| \C \C match case, do not use the 'ignorecase' option
|/\m| \m \m 'magic' on for the following chars in the pattern
|/\M| \M \M 'magic' off for the following chars in the pattern
|/\v| \v \v the following chars in the pattern are "very magic"
|/\V| \V \V the following chars in the pattern are "very nomagic"
|/\Z| \Z \Z ignore differences in Unicode "combining characters".
   Useful when searching voweled Hebrew or Arabic text.

|/\%d| \%d \%d match specified decimal character (eg \%d123)
|/\%x| \%x \%x match specified hex character (eg \%x2a)
|/\%o| \%o \%o match specified octal character (eg \%o040)
|/\%u| \%u \%u match specified multibyte character (eg \%u20ac)
|/\%U| \%U \%U match specified large multibyte character (eg
   \%U12345678)

Example   matches 
\<\I\i*  or
\<\h\w*
\<[a-zA-Z_][a-zA-Z0-9_]*
   An identifier (e.g., in a C program).

\(\.$\|\. \)  A period followed by <EOL> or a space.

[.!?][])"']*\($\|[ ]\) A search pattern that finds the end of a sentence,
   with almost the same definition as the ")" command.

cat\Z   Both "cat" and "càt" ("a" followed by 0x0300)
   Does not match "càt" (character 0x00e0), even
   though it may look the same.


==============================================================================

5. Multi items      *pattern-multi-items*

An atom can be followed by an indication of how many times the atom can be
matched and in what way.  This is called a multi.  See |/multi| for an
overview.


      */star* */\star* *E56*
* (use \* when 'magic' is not set)
 Matches 0 or more of the preceding atom, as many as possible.
 Example  'nomagic' matches 
 a*    a\*  "", "a", "aa", "aaa", etc.
 .*    \.\*  anything, also an empty string, no end-of-line
 \_.*    \_.\* everything up to the end of the buffer
 \_.*END    \_.\*END everything up to and including the last "END"
    in the buffer

 Exception: When "*" is used at the start of the pattern or just after
 "^" it matches the star character.

 Be aware that repeating "\_." can match a lot of text and take a long
 time.  For example, "\_.*END" matches all text from the current
 position to the last occurrence of "END" in the file.  Since the "*"
 will match as many as possible, this first skips over all lines until
 the end of the file and then tries matching "END", backing up one
 character at a time.


       */\+* *E57*
\+ Matches 1 or more of the preceding atom, as many as possible. {not in
 Vi}
 Example  matches 
 ^.\+$  any non-empty line
 \s\+  white space of at least one character


       */\=*
\= Matches 0 or 1 of the preceding atom, as many as possible. {not in Vi}
 Example  matches 
 foo\=  "fo" and "foo"


       */\?*
\? Just like \=.  Cannot be used when searching backwards with the "?"
 command. {not in Vi}


      */\{* *E58* *E60* *E554*
\{n,m} Matches n to m of the preceding atom, as many as possible
\{n} Matches n of the preceding atom
\{n,} Matches at least n of the preceding atom, as many as possible
\{,m} Matches 0 to m of the preceding atom, as many as possible
\{} Matches 0 or more of the preceding atom, as many as possible (like *)

       */\{-*
\{-n,m} matches n to m of the preceding atom, as few as possible
\{-n} matches n of the preceding atom
\{-n,} matches at least n of the preceding atom, as few as possible
\{-,m} matches 0 to m of the preceding atom, as few as possible
\{-} matches 0 or more of the preceding atom, as few as possible
 {Vi does not have any of these}

 n and m are positive decimal numbers or zero

        *non-greedy*
 If a "-" appears immediately after the "{", then a shortest match
 first algorithm is used (see example below).  In particular, "\{-}" is
 the same as "*" but uses the shortest match first algorithm.  BUT: A
 match that starts earlier is preferred over a shorter match: "a\{-}b"
 matches "aaab" in "xaaab".

 Example   matches 
 ab\{2,3}c  "abbc" or "abbbc"
 a\{5}   "aaaaa"
 ab\{2,}c  "abbc", "abbbc", "abbbbc", etc.
 ab\{,3}c  "ac", "abc", "abbc" or "abbbc"
 a[bc]\{3}d  "abbbd", "abbcd", "acbcd", "acccd", etc.
 a\(bc\)\{1,2}d  "abcd" or "abcbcd"
 a[bc]\{-}[cd]  "abc" in "abcd"
 a[bc]*[cd]  "abcd" in "abcd"

 The } may optionally be preceded with a backslash: \{n,m\}.


       */\@=*
\@= Matches the preceding atom with zero width. {not in Vi}
 Like "(?=pattern)" in Perl.
 Example   matches 
 foo\(bar\)\@=  "foo" in "foobar"
 foo\(bar\)\@=foo nothing

       */zero-width*
 When using "\@=" (or "^", "$", "\<", "\>") no characters are included
 in the match.  These items are only used to check if a match can be
 made.  This can be tricky, because a match with following items will
 be done in the same position.  The last example above will not match
 "foobarfoo", because it tries match "foo" in the same position where
 "bar" matched.

 Note that using "\&" works the same as using "\@=": "foo\&.." is the
 same as "\(foo\)\@=..".  But using "\&" is easier, you don't need the
 braces.



       */\@!*
\@! Matches with zero width if the preceding atom does NOT match at the
 current position. |/zero-width| {not in Vi}
 Like '(?!pattern)" in Perl.
 Example   matches 
 foo\(bar\)\@!  any "foo" not followed by "bar"
 a.\{-}p\@!  "a", "ap", "app", etc. not followed by a "p"
 if \(\(then\)\@!.\)*$ "if " not followed by "then"

 Using "\@!" is tricky, because there are many places where a pattern
 does not match.  "a.*p\@!" will match from an "a" to the end of the
 line, because ".*" can match all characters in the line and the "p"
 doesn't match at the end of the line.  "a.\{-}p\@!" will match any
 "a", "ap", "aap", etc. that isn't followed by a "p", because the "."
 can match a "p" and "p\@!" doesn't match after that.

 You can't use "\@!" to look for a non-match before the matching
 position: "\(foo\)\@!bar" will match "bar" in "foobar", because at the
 position where "bar" matches, "foo" does not match.  To avoid matching
 "foobar" you could use "\(foo\)\@!...bar", but that doesn't match a
 bar at the start of a line.  Use "\(foo\)\@<!bar".


       */\@<=*
\@<= Matches with zero width if the preceding atom matches just before what
 follows. |/zero-width| {not in Vi}
 Like '(?<=pattern)" in Perl, but Vim allows non-fixed-width patterns.
 Example   matches 
 \(an\_s\+\)\@<=file "file" after "an" and white space or an
    end-of-line
 For speed it's often much better to avoid this multi.  Try using "\zs"
 instead |/\zs|.  To match the same as the above example:
  an\_s\+\zsfile

 "\@<=" and "\@<!" check for matches just before what follows.
 Theoretically these matches could start anywhere before this position.
 But to limit the time needed, only the line where what follows matches
 is searched, and one line before that (if there is one).  This should
 be sufficient to match most things and not be too slow.
 The part of the pattern after "\@<=" and "\@<!" are checked for a
 match first, thus things like "\1" don't work to reference \(\) inside
 the preceding atom.  It does work the other way around:
 Example   matches 
 \1\@<=,\([a-z]\+\) ",abc" in "abc,abc"


       */\@<!*
\@<! Matches with zero width if the preceding atom does NOT match just
 before what follows.  Thus this matches if there is no position in the
 current or previous line where the atom matches such that it ends just
 before what follows.  |/zero-width| {not in Vi}
 Like '(?<!pattern)" in Perl, but Vim allows non-fixed-width patterns.
 The match with the preceding atom is made to end just before the match
 with what follows, thus an atom that ends in ".*" will work.
 Warning: This can be slow (because many positions need to be checked
 for a match).
 Example   matches 
 \(foo\)\@<!bar  any "bar" that's not in "foobar"
 \(\/\/.*\)\@<!in "in" which is not after "//"


       */\@>*
\@> Matches the preceding atom like matching a whole pattern. {not in Vi}
 Like "(?>pattern)" in Perl.
 Example  matches 
 \(a*\)\@>a nothing (the "a*" takes all the "a"'s, there can't be
   another one following)

 This matches the preceding atom as if it was a pattern by itself.  If
 it doesn't match, there is no retry with shorter sub-matches or
 anything.  Observe this difference: "a*b" and "a*ab" both match
 "aaab", but in the second case the "a*" matches only the first two
 "a"s.  "\(a*\)\@>ab" will not match "aaab", because the "a*" matches
 the "aaa" (as many "a"s as possible), thus the "ab" can't match.


==============================================================================

6.  Ordinary atoms     *pattern-atoms*

An ordinary atom can be:


       */^*
^ At beginning of pattern or after "\|", "\(", "\%(" or "\n": matches
 start-of-line; at other positions, matches literal '^'. |/zero-width|
 Example  matches 
 ^beep(  the start of the C function "beep" (probably).


       */\^*
\^ Matches literal '^'.  Can be used at any position in the pattern.


       */\_^*
\_^ Matches start-of-line. |/zero-width|  Can be used at any position in
 the pattern.
 Example  matches 
 \_s*\_^foo white space and blank lines and then "foo" at
   start-of-line


       */$*
$ At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
 matches end-of-line <EOL>; at other positions, matches literal '$'.
 |/zero-width|


       */\$*
\$ Matches literal '$'.  Can be used at any position in the pattern.


       */\_$*
\_$ Matches end-of-line. |/zero-width|  Can be used at any position in the
 pattern.  Note that "a\_$b" never matches, since "b" cannot match an
 end-of-line.  Use "a\nb" instead |/\n|.
 Example  matches 
 foo\_$\_s* "foo" at end-of-line and following white space and
   blank lines


. (with 'nomagic': \.)    */.* */\.*
 Matches any single character, but not an end-of-line.


       */\_.*
\_. Matches any single character or end-of-line.
 Careful: "\_.*" matches all text to the end of the buffer!


       */\<*
\< Matches the beginning of a word: The next char is the first char of a
 word.  The 'iskeyword' option specifies what is a word character.
 |/zero-width|


       */\>*
\> Matches the end of a word: The previous char is the last char of a
 word.  The 'iskeyword' option specifies what is a word character.
 |/zero-width|


       */\zs*
\zs Matches at any position, and sets the start of the match there: The
 next char is the first char of the whole match. |/zero-width|
 Example:
  /^\s*\zsif
  matches an "if" at the start of a line, ignoring white space.
 Can be used multiple times, the last one encountered in a matching
 branch is used.  Example:
  /\(.\{-}\zsFab\)\{3}
  Finds the third occurrence of "Fab".
 {not in Vi} {not available when compiled without the |+syntax| feature}

       */\ze*
\ze Matches at any position, and sets the end of the match there: The
 previous char is the last char of the whole match. |/zero-width|
 Can be used multiple times, the last one encountered in a matching
 branch is used.
 Example: "end\ze\(if\|for\)" matches the "end" in "endif" and
 "endfor".
 {not in Vi} {not available when compiled without the |+syntax| feature}


      */\%^* *start-of-file*
\%^ Matches start of the file.  When matching with a string, matches the
 start of the string. {not in Vi}
 For example, to find the first "VIM" in a file:
  /\%^\_.\{-}\zsVIM
 

      */\%$* *end-of-file*
\%$ Matches end of the file.  When matching with a string, matches the
 end of the string. {not in Vi}
 Note that this does NOT find the last "VIM" in a file:
  /VIM\_.\{-}\%$
  It will find the next VIM, because the part after it will always
 match.  This one will find the last "VIM" in the file:
  /VIM\ze\(\(VIM\)\@!\_.\)*\%$
  This uses |/\@!| to ascertain that "VIM" does NOT match in any
 position after the first "VIM".
 Searching from the end of the file backwards is easier!


      */\%V*
\%V Match inside the Visual area.  When Visual mode has already been
 stopped match in the area that |gv| would reselect.
 This is a |/zero-width| match.  To make sure the whole pattern is
 inside the Visual area put it at the start and end of the pattern,
 e.g.:
  /\%Vfoo.*bar\%V
  Only works for the current buffer.


      */\%#* *cursor-position*
\%# Matches with the cursor position.  Only works when matching in a
 buffer displayed in a window. {not in Vi}
 WARNING: When the cursor is moved after the pattern was used, the
 result becomes invalid.  Vim doesn't automatically update the matches.
 This is especially relevant for syntax highlighting and 'hlsearch'.
 In other words: When the cursor moves the display isn't updated for
 this change.  An update is done for lines which are changed (the whole
 line is updated) or when using the |CTRL-L| command (the whole screen
 is updated).  Example, to highlight the word under the cursor:
  /\k*\%#\k*
  When 'hlsearch' is set and you move the cursor around and make changes
 this will clearly show when the match is updated or not.


      */\%'m* */\%<'m* */\%>'m*
\%'m Matches with the position of mark m.
\%<'m Matches before the position of mark m.
\%>'m Matches after the position of mark m.
 Example, to highlight the text from mark 's to 'e:
  /.\%>'s.*\%<'e..
  Note that two dots are required to include mark 'e in the match.  That
 is because "\%<'e" matches at the character before the 'e mark, and
 since it's a |/zero-width| match it doesn't include that character.
 {not in Vi}
 WARNING: When the mark is moved after the pattern was used, the result
 becomes invalid.  Vim doesn't automatically update the matches.
 Similar to moving the cursor for "\%#" |/\%#|.


      */\%l* */\%>l* */\%<l*
\%23l Matches in a specific line.
\%<23l Matches above a specific line (lower line number).
\%>23l Matches below a specific line (higher line number).
 These three can be used to match specific lines in a buffer.  The "23"
 can be any line number.  The first line is 1. {not in Vi}
 WARNING: When inserting or deleting lines Vim does not automatically
 update the matches.  This means Syntax highlighting quickly becomes
 wrong.
 Example, to highlight the line where the cursor currently is:
  :exe '/\%' . line(".") . 'l.*'
  When 'hlsearch' is set and you move the cursor around and make changes
 this will clearly show when the match is updated or not.


      */\%c* */\%>c* */\%<c*
\%23c Matches in a specific column.
\%<23c Matches before a specific column.
\%>23c Matches after a specific column.
 These three can be used to match specific columns in a buffer or
 string.  The "23" can be any column number.  The first column is 1.
 Actually, the column is the byte number (thus it's not exactly right
 for multi-byte characters).  {not in Vi}
 WARNING: When inserting or deleting text Vim does not automatically
 update the matches.  This means Syntax highlighting quickly becomes
 wrong.
 Example, to highlight the column where the cursor currently is:
  :exe '/\%' . col(".") . 'c'
  When 'hlsearch' is set and you move the cursor around and make changes
 this will clearly show when the match is updated or not.
 Example for matching a single byte in column 44:
  /\%>43c.\%<46c
  Note that "\%<46c" matches in column 45 when the "." matches a byte in
 column 44.

      */\%v* */\%>v* */\%<v*
\%23v Matches in a specific virtual column.
\%<23v Matches before a specific virtual column.
\%>23v Matches after a specific virtual column.
 These three can be used to match specific virtual columns in a buffer
 or string.  When not matching with a buffer in a window, the option
 values of the current window are used (e.g., 'tabstop').
 The "23" can be any column number.  The first column is 1.
 Note that some virtual column positions will never match, because they
 are halfway through a tab or other character that occupies more than
 one screen character.  {not in Vi}
 WARNING: When inserting or deleting text Vim does not automatically
 update highlighted matches.  This means Syntax highlighting quickly
 becomes wrong.
 Example, to highlight all the characters after virtual column 72:
  /\%>72v.*
  When 'hlsearch' is set and you move the cursor around and make changes
 this will clearly show when the match is updated or not.
 To match the text up to column 17:
  /.*\%17v
  Column 17 is included, because that's where the "\%17v" matches,
 even though this is a |/zero-width| match.  Adding a dot to match the
 next character has the same result:
  /.*\%17v.
  This command does the same thing, but also matches when there is no
 character in column 17:
  /.*\%<18v.
 

Character classes: {not in Vi}

\i identifier character (see 'isident' option) */\i*

\I like "\i", but excluding digits   */\I*

\k keyword character (see 'iskeyword' option) */\k*

\K like "\k", but excluding digits   */\K*

\f file name character (see 'isfname' option) */\f*

\F like "\f", but excluding digits   */\F*

\p printable character (see 'isprint' option) */\p*

\P like "\p", but excluding digits   */\P*

NOTE: the above also work for multi-byte characters.  The ones below only
match ASCII characters, as indicated by the range.


      *whitespace* *white-space*

\s whitespace character: <Space> and <Tab>  */\s*

\S non-whitespace character; opposite of \s */\S*

\d digit:    [0-9]  */\d*

\D non-digit:   [^0-9]  */\D*

\x hex digit:   [0-9A-Fa-f] */\x*

\X non-hex digit:   [^0-9A-Fa-f] */\X*

\o octal digit:   [0-7]  */\o*

\O non-octal digit:  [^0-7]  */\O*

\w word character:   [0-9A-Za-z_] */\w*

\W non-word character:  [^0-9A-Za-z_] */\W*

\h head of word character:  [A-Za-z_] */\h*

\H non-head of word character: [^A-Za-z_] */\H*

\a alphabetic character:  [A-Za-z] */\a*

\A non-alphabetic character: [^A-Za-z] */\A*

\l lowercase character:  [a-z]  */\l*

\L non-lowercase character: [^a-z]  */\L*

\u uppercase character:  [A-Z]  */\u*

\U non-uppercase character  [^A-Z]  */\U*

 NOTE: Using the atom is faster than the [] form.

 NOTE: 'ignorecase', "\c" and "\C" are not used by character classes.


   */\_* *E63* */\_i* */\_I* */\_k* */\_K* */\_f* */\_F*

   */\_p* */\_P* */\_s* */\_S* */\_d* */\_D* */\_x* */\_X*

   */\_o* */\_O* */\_w* */\_W* */\_h* */\_H* */\_a* */\_A*

   */\_l* */\_L* */\_u* */\_U*
\_x Where "x" is any of the characters above: The character class with
 end-of-line added
(end of character classes)


\e matches <Esc>     */\e*

\t matches <Tab>     */\t*

\r matches <CR>     */\r*

\b matches <BS>     */\b*

\n matches an end-of-line    */\n*
 When matching in a string instead of buffer text a literal newline
 character is matched.


~ matches the last given substitute string */~* */\~*


\(\) A pattern enclosed by escaped parentheses. */\(* */\(\)* */\)*

 E.g., "\(^a\)" matches 'a' at the start of a line.  *E51* *E54* *E55*


\1      Matches the same string that was matched by */\1* *E65*
 the first sub-expression in \( and \). {not in Vi}
 Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc.

\2      Like "\1", but uses second sub-expression, */\2*

   ...       */\3*

\9      Like "\1", but uses ninth sub-expression. */\9*
 Note: The numbering of groups is done based on which "\(" comes first
 in the pattern (going left to right), NOT based on what is matched
 first.


\%(\) A pattern enclosed by escaped parentheses. */\%(\)* */\%(* *E53*
 Just like \(\), but without counting it as a sub-expression.  This
 allows using more groups and it's a little bit faster.
 {not in Vi}

x A single character, with no special meaning, matches itself


       */\* */\\*
\x A backslash followed by a single character, with no special meaning,
 is reserved for future expansions


[] (with 'nomagic': \[])  */[]* */\[]* */\_[]* */collection*
\_[]
 A collection.  This is a sequence of characters enclosed in brackets.
 It matches any single character in the collection.
 Example  matches 
 [xyz]  any 'x', 'y' or 'z'
 [a-zA-Z]$ any alphabetic character at the end of a line
 \c[a-z]$ same

        */[\n]*
 With "\_" prepended the collection also includes the end-of-line.
 The same can be done by including "\n" in the collection.  The
 end-of-line is also matched when the collection starts with "^"!  Thus
 "\_[^ab]" matches the end-of-line and any character but "a" and "b".
 This makes it Vi compatible: Without the "\_" or "\n" the collection
 does not match an end-of-line.

        *E769*
 When the ']' is not there Vim will not give an error message but
 assume no collection is used.  Useful to search for '['.  However, you
 do get E769 for internal searching.

 If the sequence begins with "^", it matches any single character NOT
 in the collection: "[^xyz]" matches anything but 'x', 'y' and 'z'.
 - If two characters in the sequence are separated by '-', this is
   shorthand for the full list of ASCII characters between them.  E.g.,
   "[0-9]" matches any decimal digit.  Non-ASCII characters can be
   used, but the character values must not be more than 256 apart.
 - A character class expression is evaluated to the set of characters
   belonging to that character class.  The following character classes
   are supported:
     Name  Contents 

*[:alnum:]*    [:alnum:]     letters and digits

*[:alpha:]*    [:alpha:]     letters

*[:blank:]*    [:blank:]     space and tab characters

*[:cntrl:]*    [:cntrl:]     control characters

*[:digit:]*    [:digit:]     decimal digits

*[:graph:]*    [:graph:]     printable characters excluding space

*[:lower:]*    [:lower:]     lowercase letters (all letters when
     'ignorecase' is used)

*[:print:]*    [:print:]     printable characters including space

*[:punct:]*    [:punct:]     punctuation characters

*[:space:]*    [:space:]     whitespace characters

*[:upper:]*    [:upper:]     uppercase letters (all letters when
     'ignorecase' is used)

*[:xdigit:]*    [:xdigit:]    hexadecimal digits

*[:return:]*    [:return:] the <CR> character

*[:tab:]*    [:tab:] the <Tab> character

*[:escape:]*    [:escape:] the <Esc> character

*[:backspace:]*    [:backspace:] the <BS> character
   The brackets in character class expressions are additional to the
   brackets delimiting a collection.  For example, the following is a
   plausible pattern for a UNIX filename: "[-./[:alnum:]_~]\+" That is,
   a list of at least one character, each of which is either '-', '.',
   '/', alphabetic, numeric, '_' or '~'.
   These items only work for 8-bit characters.

       */[[=* *[==]*
 - An equivalence class.  This means that characters are matched that
   have almost the same meaning, e.g., when ignoring accents.  The form
   is:
  [=a=]
   Currently this is only implemented for latin1.  Also works for the
   latin1 characters in utf-8 and latin9.

       */[[.* *[..]*
 - A collation element.  This currently simply accepts a single
   character in the form:
  [.a.]

         */\]*
 - To include a literal ']', '^', '-' or '\' in the collection, put a
   backslash before it: "[xyz\]]", "[\^xyz]", "[xy\-z]" and "[xyz\\]".
   (Note: POSIX does not support the use of a backslash this way).  For
   ']' you can also make it the first character (following a possible
   "^"):  "[]xyz]" or "[^]xyz]" {not in Vi}.
   For '-' you can also make it the first or last character: "[-xyz]",
   "[^-xyz]" or "[xyz-]".  For '\' you can also let it be followed by
   any character that's not in "^]-\bdertnoUux".  "[\xyz]" matches '\',
   'x', 'y' and 'z'.  It's better to use "\\" though, future expansions
   may use other characters after '\'.
 - The following translations are accepted when the 'l' flag is not
   included in 'cpoptions' {not in Vi}:
  \e <Esc>
  \t <Tab>
  \r <CR> (NOT end-of-line!)
  \b <BS>
  \n line break, see above |/[\n]|
  \d123 decimal number of character
  \o40 octal number of character up to 0377
  \x20 hexadecimal number of character up to 0xff
  \u20AC hex. number of multibyte character up to 0xffff
  \U1234 hex. number of multibyte character up to 0xffffffff
   NOTE: The other backslash codes mentioned above do not work inside
   []!
 - Matching with a collection can be slow, because each character in
   the text has to be compared with each character in the collection.
   Use one of the other atoms above when possible.  Example: "\d" is
   much faster than "[0-9]" and matches the same characters.


      */\%[]* *E69* *E70* *E369*
\%[] A sequence of optionally matched atoms.  This always matches.
 It matches as much of the list of atoms it contains as possible.  Thus
 it stops at the first atom that doesn't match.  For example:
  /r\%[ead]
  matches "r", "re", "rea" or "read".  The longest that matches is used.
 To match the Ex command "function", where "fu" is required and
 "nction" is optional, this would work:
  /\<fu\%[nction]\>
  The end-of-word atom "\>" is used to avoid matching "fu" in "full".
 It gets more complicated when the atoms are not ordinary characters.
 You don't often have to use it, but it is possible.  Example:
  /\<r\%[[eo]ad]\>
  Matches the words "r", "re", "ro", "rea", "roa", "read" and "road".
 There can be no \(\), \%(\) or \z(\) items inside the [] and \%[] does
 not nest.
 To include a "[" use "[[]" and for "]" use []]", e.g.,:
  /index\%[[[]0[]]]
  matches "index" "index[", "index[0" and "index[0]".
 {not available when compiled without the |+syntax| feature}


    */\%d* */\%x* */\%o* */\%u* */\%U* *E678*

\%d123 Matches the character specified with a decimal number.  Must be
 followed by a non-digit.
\%o40 Matches the character specified with an octal number up to 0377.
 Numbers below 040 must be followed by a non-octal digit or a non-digit.
\%x2a Matches the character specified with up to two hexadecimal characters.
\%u20AC Matches the character specified with up to four hexadecimal
 characters.
\%U1234abcd Matches the character specified with up to eight hexadecimal
 characters.

==============================================================================

7. Ignoring case in a pattern     */ignorecase*

If the 'ignorecase' option is on, the case of normal letters is ignored.
'smartcase' can be set to ignore case when the pattern contains lowercase
letters only.

       */\c* */\C*
When "\c" appears anywhere in the pattern, the whole pattern is handled like
'ignorecase' is on.  The actual value of 'ignorecase' and 'smartcase' is
ignored.  "\C" does the opposite: Force matching case for the whole pattern.
{only Vim supports \c and \C}
Note that 'ignorecase', "\c" and "\C" are not used for the character classes.

Examples:
      pattern 'ignorecase'  'smartcase' matches 
 foo   off  -  foo
 foo   on  -  foo Foo FOO
 Foo   on  off  foo Foo FOO
 Foo   on  on      Foo
 \cfoo   -  -  foo Foo FOO
 foo\C   -  -  foo


Technical detail:    *NL-used-for-Nul*
<Nul> characters in the file are stored as <NL> in memory.  In the display
they are shown as "^@".  The translation is done when reading and writing
files.  To match a <Nul> with a search pattern you can just enter CTRL-@ or
"CTRL-V 000".  This is probably just what you expect.  Internally the
character is replaced with a <NL> in the search pattern.  What is unusual is
that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a <Nul>
in the file.  {Vi cannot handle <Nul> characters in the file at all}


      *CR-used-for-NL*
When 'fileformat' is "mac", <NL> characters in the file are stored as <CR>
characters internally.  In the text they are shown as "^J".  Otherwise this
works similar to the usage of <NL> for a <Nul>.

When working with expression evaluation, a <NL> character in the pattern
matches a <NL> in the string.  The use of "\n" (backslash n) to match a <NL>
doesn't work there, it only works to match text in the buffer.


      *pattern-multi-byte*
Patterns will also work with multi-byte characters, mostly as you would
expect.  But invalid bytes may cause trouble, a pattern with an invalid byte
will probably never match.

==============================================================================

8. Composing characters     *patterns-composing*


       */\Z*
When "\Z" appears anywhere in the pattern, composing characters are ignored.
Thus only the base characters need to match, the composing characters may be
different and the number of composing characters may differ.  Only relevant
when 'encoding' is "utf-8".

When a composing character appears at the start of the pattern of after an
item that doesn't include the composing character, a match is found at any
character that includes this composing character.

When using a dot and a composing character, this works the same as the
composing character by itself, except that it doesn't matter what comes before
this.

The order of composing characters matters, even though changing the order
doesn't change what a character looks like.  This may change in the future.

==============================================================================

9. Compare with Perl patterns    *perl-patterns*

Vim's regexes are most similar to Perl's, in terms of what you can do.  The
difference between them is mostly just notation;  here's a summary of where
they differ:

Capability   in Vimspeak in Perlspeak 
force case insensitivity \c  (?i)
force case sensitivity  \C  (?-i)
backref-less grouping  \%(atom\) (?:atom)
conservative quantifiers \{-n,m}  *?, +?, ??, {}?
0-width match   atom\@=  (?=atom)
0-width non-match  atom\@!  (?!atom)
0-width preceding match  atom\@<= (?<=atom)
0-width preceding non-match atom\@<! (?<!atom)
match without retry  atom\@>  (?>atom)

Vim and Perl handle newline characters inside a string a bit differently:

In Perl, ^ and $ only match at the very beginning and end of the text,
by default, but you can set the 'm' flag, which lets them match at
embedded newlines as well.  You can also set the 's' flag, which causes
a . to match newlines as well.  (Both these flags can be changed inside
a pattern using the same syntax used for the i flag above, BTW.)

On the other hand, Vim's ^ and $ always match at embedded newlines, and
you get two separate atoms, \%^ and \%$, which only match at the very
start and end of the text, respectively.  Vim solves the second problem
by giving you the \_ "modifier":  put it in front of a . or a character
class, and they will match newlines as well.

Finally, these constructs are unique to Perl:
- execution of arbitrary code in the regex:  (?{perl code})
- conditional expressions:  (?(condition)true-expr|false-expr)

...and these are unique to Vim:
- changing the magic-ness of a pattern:  \v \V \m \M
   (very useful for avoiding backslashitis)
- sequence of optionally matching atoms:  \%[atoms]
- \& (which is to \| what "and" is to "or";  it forces several branches
   to match at one spot)
- matching lines/columns by number:  \%5l \%5c \%5v
- setting the start and end of the match:  \zs \ze

==============================================================================

10. Highlighting matches    *match-highlight*


       *:mat* *:match*
:mat[ch] {group} /{pattern}/
  Define a pattern to highlight in the current window.  It will
  be highlighted with {group}.  Example:
   :highlight MyGroup ctermbg=green guibg=green
   :match MyGroup /TODO/
   Instead of // any character can be used to mark the start and
  end of the {pattern}.  Watch out for using special characters,
  such as '"'' and '|'.

  {group} must exist at the moment this command is executed.

  The {group} highlighting still applies when a character is
  to be highlighted for 'hlsearch', as the highlighting for
  matches is given higher priority than that of 'hlsearch'.
  Syntax highlighting (see 'syntax') is also overruled by
  matches.

  Note that highlighting the last used search pattern with
  'hlsearch' is used in all windows, while the pattern defined
  with ":match" only exists in the current window.  It is kept
  when switching to another buffer.

  'ignorecase' does not apply, use |/\c| in the pattern to
  ignore case.  Otherwise case is not ignored.

  'redrawtime' defines the maximum time searched for pattern
  matches.

  When matching end-of-line and Vim redraws only part of the
  display you may get unexpected results.  That is because Vim
  looks for a match in the line where redrawing starts.

  Also see |matcharg()| and |getmatches()|. The former returns
  the highlight group and pattern of a previous |:match|
  command.  The latter returns a list with highlight groups and
  patterns defined by both |matchadd()| and |:match|.

  Highlighting matches using |:match| are limited to three
  matches (aside from |:match|, |:2match| and |:3match|are
  available). |matchadd()| does not have this limitation and in
  addition makes it possible to prioritize matches.

  Another example, which highlights all characters in virtual
  column 72 and more:
   :highlight rightMargin term=bold ctermfg=blue guifg=blue
   :match rightMargin /.\%>72v/
   To highlight all character that are in virtual column 7:
   :highlight col8 ctermbg=grey guibg=grey
   :match col8 /\%<8v.\%>7v/
   Note the use of two items to also match a character that
  occupies more than one virtual column, such as a TAB.

:mat[ch]
:mat[ch] none
  Clear a previously defined match pattern.



:2mat[ch] {group} /{pattern}/     *:2match*
:2mat[ch]
:2mat[ch] none

:3mat[ch] {group} /{pattern}/     *:3match*
:3mat[ch]
:3mat[ch] none
  Just like |:match| above, but set a separate match.  Thus
  there can be three matches active at the same time.  The match
  with the lowest number has priority if several match at the
  same position.
  The ":3match" command is used by the |matchparen| plugin.  You
  are suggested to use ":match" for manual matching and
  ":2match" for another plugin.

chroma subsampling notation

http://www.poynton.com/PDFs/Chroma_subsampling_notation.pdf

I always forget this simple notation. I have to search every time. This is simple and clear diagram for chroma subsampling.

2007 sienna engine oil change

http://www.ehow.com/how_8405861_change-toyota-sienna-engine-oil.html
http://www.fixrambler.com/art133.html

Instructions

1. • 1
     Open the Sienna's hood and open the oil filler cap on top of the engine.
   • 2
     Raise the front of the Sienna with a floor jack. Slide jack stands under the vehicle's subframe and lower the Toyota onto the jack stands. Remove the floor jack.
   • 
     
   • 3
     Crawl under the Sienna and locate the oil pan, which is the metal pan on the bottom of the engine. Set a drain pan under the drain plug in the oil pan. Loosen the drain plug, using the closed end of a combination wrench, and remove the drain plug by hand.
   • 4
     Remove the oil drain plug gasket and clean the drain plug, using a clean, lint-free cloth. Install a new gasket on the drain plug. Hand-tighten the drain plug into the oil pan once only slow drips of oil come from the pan. Tighten the drain plug to 30 foot-pounds, using a torque wrench and a six-point socket.
   • 5
     Locate the oil filter cap, which is the circular, metal cap on the passenger-side front of the engine. Set the drain pan under the oil filter cap and loosen it with a 64 mm oil filter cup and a ratchet. Allow the oil to drain from the oil filter housing, then remove the oil filter cap and oil filter.
   • 6
     Place the blade of a flat-head screwdriver under the rubber O-ring on the oil filter cap, and pry the O-ring from its groove in the cap. Remove the O-ring from the oil filter cap.
   • 7
     Install a new O-ring on the oil filter cap and roll it up the cap until it seats in the groove on the cap. Set a new oil filter in the oil filter cap.
   • 8
     Place a small amount of new engine oil on your finger and coat the O-ring on the oil filter cap with oil. Hand-tighten the oil filter cap onto the engine. Apply 18 foot-pounds of torque to the oil filter cap, using a 64 mm oil filter cup and a torque wrench.
   • 9
     Raise the Sienna off of the jack stands, using a floor jack, and remove the jack stands. Lower the van to the ground.
   • 10
     Insert a funnel into the oil filler hole and pour in 6.4 qts. of 5W-30 engine oil.
   • 11
     Allow the oil to settle for approximately 1 minute and remove the oil dipstick. Wipe the dipstick clean, using a clean, lint-free cloth and reinsert the dipstick. Remove the dipstick and check that the oil level is between the two dots on the bottom of the dipstick. Add engine oil as needed. Close the oil filler cap.
   • 12
     Start the engine and allow it to run for 2 to 3 minutes. Check and adjust the oil level according to the procedure in step 11. Close the Sienna's hood.
   • 13
     Insert a funnel in an empty oil bottle and fill this bottle with old oil from the drain pan. Close the bottle's cap when the bottle is full. Repeat this step until all of the oil is out of the drain pan.
   • 14
     Take the bottles of old oil and the filter to a local automotive oil recycling center. Many auto parts stores recycle old oil free of charge.

Read more: How to Change the 2007 Toyota Sienna Engine Oil | eHow.com http://www.ehow.com/how_8405861_change-toyota-sienna-engine-oil.html#ixzz20vpBOtW2

The 2007 Toyota Sienna uses a canister style oil filter. It is possible to get at the canister without lifting the front, although for extra room and maneuverability I jack up the front with a floor jack so the wheels are just barely off of the ground and I put two jack stands under the front for support. Here is where the canister is located: 

 

Remove the drain plug with a 14mm wrench. The plug washer is number 90430-12028. 

 

There is a smaller insert that you can remove. In my case, since I tighten the whole assembly from the insert, the whole filter comes off when I remove the insert. The best way is probably to just use a 65 mm cap wrench to remove the canister. There is a plastic fitting you can use to drain the oil from the canister via the whole beneath the insert. I find it works just as well to put a drain pan beneath the canister, take it off, and dump out the oil. 

 

Here is the inside of the canister: 

 

An oil change shop munged up the canister. Plus, they didn't replace the o-rings and oil leaked, which is why I'm back to changing my own oil again. 

 




My technique of tightening the filter made the insert difficult to get out. I had to put the canister in a vice. I didn't tighten the vice down, I just set it so it would catch the fins and used a 1/2 inch ratchet and 3/8 inch adapter to remove the insert: 

 

Here you can see the insert removed, as well as the small o-ring. The hole in the center is where you stick the plastic drain spout: 

 

The filter I'm using is a 04152-YZZA1; however, this filter has been superseded by part number 04152-YZZA5. Both the filters and the plug washer are available from your Toyota dealer, or online at Toyota Parts Center. Here is the filter label: 

 

Here is the new o-ring installed on the outside of the inner canister: 

 

It is kind of nice to only have to discard the paper element and install a fresh new one that is visible: 

 

sienna 2007 engine air filter change

The engine air filter in your 2006 Toyota Sienna cleans the air that enters your engine. You should change the filter on your Sienna at least once a year or every 20,000 miles, whichever comes first. If you drive in dusty or sandy conditions, you should change your filter more frequently. A dirty air filter will cause your Sienna to lose 1 - 3 mpg, depending on your driving, you can save 70 - 100 gallons of gas per year simply by changing your filter regularly. The video above, shows you where the engine air filter is located in your Sienna and how to change it!

In addition to improving the fuel economy of your Sienna, regularly replacing your air filter will put less strain on your engine. These filters are fairly inexpensive, so check out our parts page for great deals and coupons on a new one (tip: buy several, when you go to check the filter on your Sienna, you can easily swap it for a new one if it is dirty).


http://www.carcarekiosk.com/video/2006_Toyota_Sienna_LE_3.3L_V6/air_filter_engine/replace

1. Getting Started
2. Open the Hood
3. Remove the Filter
4. Replace the Filter
5. Additional Thoughts

도니의 인라인 기술해부-1에서 4까지

http://cafe.daum.net/kjdhwtl

서론 인라인 기술에 관련된 칼럼을 쓰는 것은 만 3년만입니다. 3년전에 파스칼의 더블푸쉬를 분석했던 것 이 후로 기술적인 부분에 대해서 칼럼은 잘 쓰지 않았습니다. 그것은 인라인을 알면 알수록 제 지식이 미천함을 깨닫게 되었기 때문일 것입니다. 그동안 기술에 대한 이해를 높이려 많은 시간을 노력했고 또 제가 이해한 내용을 보다 쉽고 정확하게 전달하고자 틈틈이 자료를 준비해왔습니다. 기본적인 원리에서 고급 기술까지 원포인트 형식으로 정리해보고자 합니다. 부족한 점이 있다면 여러분들과 함께 연구하고 보완하는 칼럼이 되고자 합니다. 1. 효율적인 푸쉬(1) - fall 아마추어 인라인 레이서들의 주 관심사는 어떻게 더 적은 체력으로 더 먼거리를(또는 더 빠르게) 갈 것인가 하는 효율에 대한 것이다. 이것은 마라톤과 로드런 위주로 발전한 인라인 문화의 영향일 것이다. 효율적인 푸쉬를 위해서는 중력을 최대한 이용해야하며 중력을 추진력으로 변환하는 동작이 '체중 떨어뜨리기'(fall)이다. (최근 한홍희님이 언급한 '넘어지기', 이왕중님이 오래전부터 설명하는 '쓰러지기'가 다 이 fall동작이다. 땅에 넘어지는 동작과 구분하기 위해 fall이란 용어를 그대로 사용하고자한다. 영어알레르기가 있는 분들의 양해를 바람.) 체중이 중력에 의해서 땅에 떨어지려는 힘이 fall동작에 의해서 횡방향의 힘을 만들어 낸다. 먼저 그림으로 중력이 어떻게 추진력으로 변환되는지 알아보자. 그림1.1. 푸쉬 = 중력에 의한 추진(fall) + 근력에 의한 추진(밀기)  [사진: 허유빈 데몬] 푸쉬동작은 중력에 의한 추진(fall)와 다리 근력에 의한 추진(밀기)로 이루어진다. 초급자일수록 다리 근력에 의지하여 추진력을 발생시키며, 상급자는 상황에 따라 두 가지 추진력의 비율을 자유롭게 조절할 수 있다. (초급자가 다리 근력에만 의지하는 이유가 체중이 추진력을 만들어내는 원리와 그 느낌을 이해하지 못하기 때문이고 그것을 쉽게 설명하려는 것이 본 글의 목적이다.) 본 글은 효율적인 푸쉬에 대한 내용이므로 근력을 최소한 사용하고 체중을 최대한 활용하는 쪽에 초점을 맞추고자 한다. fall 동작을 풀어 말하면 무게중심(COM:center of mass)을 축발(BOS:base of support)으로부터 횡방향으로 멀어지게 하여 중력에 의해 떨어뜨리는 것이다. 무게중심이 축발을 벗어날 수록 불안정해지고 넘어지기 직전에 위치에너지가 최대 운동에너지를 만들어낸다. 즉, 무게중심(골반)이 충분히 움직여야 큰 추진력을 얻을 수 있고, 이 것이 안될 때 '체중이동이 안된다'라고 말한다. 다음은 fall동작이 전혀없는 전형적인 초급자의 동작과 fall동작이 잘 보이도록 과장한 동작이다. 빨강, 파랑, 녹색 세개의 원은 양발과 무게중심의 위치를 의미한다.   그림1.2. (좌)fall이 전혀 안되는 푸쉬 (우) fall 동작 그림1.3. 두 발과 무게중심의 표시 방법  [사진: 정소영 데몬] 두가지 동작의 차이점은 축발을 먼저 내려놓고 푸쉬를 하는가 아니면 최대한 축발을 늦게 내려놓는 가이다. 축발을 땅에 늦게 내려놓을 수록 낙차가 커지고 큰 추진력을 얻게 된다. fall동작이 무엇인지 이해가 되었다면 다음 동영상을 통해 실제 주행에서의 fall을 이해할 수 있을 것이다. 다은은 에디 매츠거의 주행 영상에 fall 동작을 표시한 것이다. 그림1.4. 살로몬, 데스티네이션 스피드 中 '데스티네이션 스피드'에서 에디는 '이 자세는 장거리에 적합하고 특히 혼자 달리거나 선두에서 달릴때 최소한의 체력으로 스피드를 유지할 수 있다. 셋 다운을 늦게하고 체중이 떨어지는 힘을 푸쉬하는 발에 집중시켜야한다.'라고 설명한다. 다소 과장된 에디의 주행자세에서 fall동작을 쉽게 발견할 수 있다. 본 글에서는 적은 체력 소비하고 효율적으로 주행을 할 수 있는 fall 동작에 대해서 알아보았다. 이는 특히 레이싱 초급자들이 간과하는 부분이다. 다음에는 효율적인 푸쉬 두번째 팁으로 푸쉬 방향에 대해서 설명할 것이다. 효율적인 푸쉬(2) – 푸쉬의 방향 두 번째 주제로 푸쉬 방향을 선택한 이유는 푸쉬 방향이 오랜 동안 논란의 대상이 되었고 그 과정에서 고정관념이 형성되어 바람직하지 않은 영향도 미치고 있다고 생각하기 때문이다. 효율적인 푸쉬 방향은 분명 존재 할 것이다. 그러나, 이 방향(각도)는 단순히 다리의 움직임에 의한 것이 아니라 여러 동작들이 서로 영향을 미쳐 만들어낸 결과이며 속도에 따라 달라지며 스케이팅 스타일이나 신체조건에 따라서도 달라지게 된다. 따라서, 그 원리와 과정을 생략하고 단순히 푸쉬의 방향만을 따지는 것은 바람직하지 않다. 상급자들의 경우 푸쉬의 방향에 자체에 대해서 큰 의미를 두지 않는다. 충분한 가속을 얻을 수 있는지 여부가 중요한 것이며, 어떤 순간에 어느 방향으로 밀어야 하는지는 경험과 감각으로 판단하게 된다. 본 글에서는 그 동안 3시/9시 또는 45도라고 양분하여 생각하였던 고정관념이 비롯된 원인을 밝히고 이를 벗어나 새로운 시각에서 바라볼 수 있는 계기가 되고자 한다. 푸쉬 방향에 대한 고정관념 전통적인 푸쉬의 방향은 45도 뒤쪽으로 미는 것이다. 그러나, 이런 개념을 뒤바꿔놓은 것은 살로몬의 ‘데스티네이션 스피드’ 비디오이다. 뿐만 아니라 [Liz Miller의 칼럼]을 보면 횡방향 푸쉬를 위해 심지어 2시/10시 방향으로 밀라고 설명한다. 그런데, 필라 월드팀의 클리닉은 지난 몇 년간 45도 뒤쪽으로 미는 ‘전통적인 방식’을 가르치고 있다. 게다가 최근 필라팀의 성적이 최고이기 때문에 더 혼란스럽기만 하다.   그림2.1. 파워 박스, 그림2.2. 필라팀 클리닉(45도 방향 푸쉬) (※그림2.2는 알팩닷컴의 [필라팀 클리닉 후기]에서 발췌했음을 밝힙니다) 또, 일부는 '푸쉬를 하는 동안 전진하기 때문에 45도 방향 처럼 보이지만 선수입장에서는 3시/9시를 만들려고 해야한다'라고 설명하기도 한다. 과연 어떤 것이 바람직한 것인지 함께 해답을 찾아보도록 하자. 푸쉬 방향과 추진력의 상관관계 어렵지 않은 물리적인 해석을 통해 푸쉬 방향에 따른 추진력에 대하여 살펴 보도록 하자. 먼저 푸쉬의 방향을 정의해보자. 일반적으로 말하는 푸쉬의 방향은 시계방향과 각도 두 가지를 이용 한다. 이 중에서 각도로 나타낼 때 푸쉬의 방향은 진행방향의 수직방향을 기준으로 표현한다(대각선 뒤쪽으로 미는 경우가 45도). 또한 프레임의 방향은 진행방향을 기준으로 말하는 게 일반적이다. 이러한 관례를 바탕으로 푸쉬의 방향에 영향을 주는 요소인 다리의 각도와 프레임의 각도를 정의하였다(그림2.3). 그림2.3. 다리의 각도와 프레임의 각도 해석을 쉽게 하기 위해 스케이트의 성질에 대하여 살펴보자. 스케이트는 프레임방향에 수직방향으로 작용하는 힘의 성분만이 추진력에 영향을 준다. 그림2.4는 서로 다른 크기의 힘이 작용하지만 같은 크기의 힘만 전달되는 것을 설명하고있다. 따라서, 힘의 손실을 최소로 하기 위해서는 프레임의 수직방향에 가깝게 힘을 가해야 한다. 그림2.4. 스케이트의 성질 따라서, 그림2.3에서 정의한 다리의 각도와 프레임의 각도는 비슷할수록 힘 전달 측면에서 유리하다. 이러한 특성을 바탕으로 계산의 편리를 위해 프레임과 다리의 각도가 같다고 가정하고자 한다(실제 주행에서도 큰 차이를 발생하지 않는다). 또한, 푸쉬의 방향을 다리의 각도로 표현하려 한다. 푸쉬에 의한 추진력은 뒤쪽으로 밀수록 커지며 측면으로 밀수록 작아진다. 그렇다면 소위 백 푸쉬가 바람직한 것일까? 이것은 정지상태에서 푸쉬를 하는 경우이며 속도가 빨라질수록 뒤쪽으로 미는 힘은 상쇄되고 옆으로 미는 힘만이 추진력으로 작용한다. 예를 들어 시속 30km/h로 달리면서 뒤로 푸쉬하려하면 헛발질을 하게 되는 이유는 다리를 뒤로 움직이는 속도보다 몸을 기준으로 지면이 움직이고 있는 속도가 더 빠르기 때문이다. 따라서, 속도가 빨라질수록 옆쪽으로 미는 것이(다리의 각도가 작은 것이) 효율적이 된다. 설명의 편의를 위해 뒤로 미는 힘이 완전히 상쇄 되는 속도를 ‘임계속도’라고 부르도록 하겠다. (뒤로미는 힘이 완전히 상쇄된 후에도 옆으로 미는 힘에의한 가속이 가능하기 때문에 임계속도가 최대속도는 아니다) 그림2.5. 푸쉬방향에 따른 추진력과 속도에 의한 상쇄 다리를 움직일 수 있는 속도는 사람에 따라 다르기 때문에 정확히 시속 몇 킬로가 임계속도인지는 알 수 없다. 따라서,속도에서 최대 추진력을 발생하는 푸쉬의 방향은 그 순간의 주행 속도와 신체조건에 따라 달라진 다는 것이다. 속도의 변화(정지에서 임계속도까지)에 따라 최대 추진력을 발생시키는 푸쉬 방향의 변화는 다음과 같다. 속도가 빨라질 수록 효율적인 푸쉬각도가 작아지는 경향을 확인 할 수 있다. 또 지나치게 옆으로 미는 것 역시 효율적이지 않음을 알 수 있다. 그림2.6. 속도와 푸쉬 방향에 따른 추진력의 변화. 그림2.7. 최대 추진력을 발생시키는 푸쉬의 방향의 변화 위 결과에서는 정지상태에서 임계속도까지에 대해 효율적인 푸쉬 방향에 대하여 보여주고있다. 실제 주행시에는 이 임계속도보다 빠른 속도를 낼 수 있기 때문에 푸쉬각도는 더 작아질 것이다(그림2.7의 점선). 본 글에서는 이와 같이 속도에 따라 푸쉬의 각도가 작아지는 경향을 확인하는 데까지만 물리학적인 접근방법을 사용하고자 한다. 실제 주행의 푸쉬방향: 푸쉬 방향에 영향을 주는 또 다른 요인 서론에서 설명했듯이 푸쉬의 방향은 단순한 다리의 움직임이 아니라 여러 동작이 영향을 미쳐 만들어낸 결과이기 때문에 물리적으로 해석하는데는 한계를 갖고 있다. 실제 주행에서 푸쉬에 영향을 주는 다른 요인들을 살펴보자. 먼저 푸쉬를 시작해서 끝날 때까지 푸쉬의 방향은 변한다. 그림2.8은 지난 회에서 fall에 대해 멋진 시연을 해준 에디의 푸쉬 방향이다(동영상에서 추출한 결과). 0도에서 시작하여 25도까지 커졌다가 20도로 다시 줄어드는 것을 볼 수 있다. 마지막에 푸쉬각도가 다시 작아지는 것은 보다 긴 시간동안 푸쉬를 하기 위한 동작으로 ‘카빙(carving)’이라고 부르기도 한다. 그림2.8. 에디의 푸쉬 방향 다음으로 푸쉬가 끝나는 시점에서 반대쪽발을 내려놓는 셋다운 동작에 의한 영향도 생각할 수 있다. 상급자일수록 그리고 가속동작 일수록 셋다운 동작에 탄력을 주기 때문에 마지막 푸쉬각도가 커질 수 있다. 아래 파스칼의 셋다운 동작과 그 순간의 푸쉬에 대해 주의깊게 관찰해보기 바란다.(더블푸쉬 동작임을 고려하기 바람) 그림2.9. 파스칼의 주행 (살로몬, 데스티네이션 스피드 中) 파워 박스는 잘못된 이론인가? 실제 주행에서의 푸쉬 방향은 우리가 알고 있었던 파워박스이론과는 많이 다른 것을 알 수 있었다. 그렇다면 파워박스는 잘못된 이론인가? 이를 논하기 전에 먼저 파워박스가 무엇인지 확인해보자. 먼저 ‘데스티네이션 스피드’동영상에서 정의하는 파워박스의 의미는 다음과 같다. “The Power Box is a zone around the body in which the skates can affect the push with maximum power” 번역하면 “파워박스는 스케이트가 최대의 힘으로 푸쉬에 영향을 미치는 몸 주위의 영역”을 말하는 것이다. 또한 “과학적 실험결과 푸쉬 힘이 가장 큰 순간은 파워박스 가운데 부근에 위치하며 휠 전체로 땅을 잡고 있는 순간”이라고 설명한다. 그림2.10의 검은색 명암이 푸쉬 힘을 나타내며 그중 가장 어두운 부분이 최대가 되는 순간이다. 그림2.10. 파워 박스(흰색)와 푸쉬 힘(검은색 명암) (살로몬, 데스티네이션 스피드 中) 즉, 파워박스는 푸쉬의 방향을 설명하기 위한 것이 아니라 푸쉬의 힘이 최대가 되는 순간을 설명하기 위한 것이며 이 순간은 모든 휠에 최대의 힘이 가해지는 순간이다. 그리고, 이러한 원리를 바탕으로 제안하는 연습방법이 ‘옆으로 밀기(lateral push)’동작이다. 다시말해 모든 휠로 푸쉬하는 연습을 하는 것이다. 결론적으로 파워박스 이론은 잘못된 것이 아니라 파워박스를 설명하는 화면과 그에 이어지는 연습방법 때문에 잘못 이해하고 있었던 것이다. 연습용 자세과 실제 자세를 혼동하는 일은 비단 파워 박스의 경우만은 아니다. 월드팀이 강습하는 내용을 이렇게 잘못 받아들이는 예가 많이 있다. 또 한가지 예가 리커버리에 관한 것인데 이것은 다음 편에서 설명하려 한다. 맺음말 지금까지 효율적인 푸쉬에 대하여 알아보았다. 정리해보면 효율적인 푸쉬방향이란 정해져있는 각도가 아니라  휠 전체를 이용해서 푸쉬하기 위한 방향이다. 반대로 말하면 휠 전체를 이용해서 푸쉬할 때 자연스럽게 나타나는 각도이기도 하다. 따라서, 속도에 관계없이 휠 전체를 이용해서 푸쉬할 수 있는 능력이 중요하며, 이를 위한 훈련방볍이 옆으로 밀기(lateral push)인 것이다. 스스로 제대로 푸쉬를 하고 있는지를 알고 싶다면 푸쉬동작에서 '무릎이 완전히 펴진 순간에 휠 5개가 모두 지면에 닿아있는지'를 확인해 보기 바란다. 또, 아래 파스칼의 푸쉬동작을 이러한 관점에서 살펴보기 바란다. 그림2.11. 파스칼의 푸쉬 동작 (살로몬, 데스티네이션 스피드 中) 지난 시간에 설명한 fall동작이 다소 혼동의 여지가 있었던 같다. ‘무게중심을 떨어뜨리는 동작이 중요하다’고 설명한 것이 ‘상체움직임이 큰 것이 좋다’라는 해석이 가능했던 것이다. 많은 초급자들이 fall에 대한 느낌을 이해하지 못하기 때문에 이해를 돕기 위한 설명이며 과도한 상체움직임은 당연히 바람직 하지 못하다. 이번 글에서 설명하고자 했던 내용 역시 추진력을 최대로 발생시키는 느낌을 이해할 수 있도록 도움이 되고자 한 글이다. 각도에 대한 고정관념을 버리자는 의미가 '아무렇게나 되는대로 밀자'라는 의미는 아님을 강조하면서 글을 마무리하려 한다. 리커버리: 상급자가 되기 위한 관문 리커버리는 싱글푸쉬의 구분동작(푸쉬,리커버리,셋다운,글라이드) 중 가장 익히기 어려운 동작이다. 그래서 리커버리동작만 보면 한눈에 그사람의 수준을 알 수 있게된다. '체중(중력)을 이용한 푸쉬'(참고: [기술해부1])가 초급자와 중급자를 구분짓는다고도 볼 수 있으며 리커버리는 중급자가 상급자가 되기위해 넘어야할 높은 산이다. (상급자는 일정수준의 기록과 함께 정확한 기술을 구사할 수 있는 수준을 의미) 기술해부1편에서 살펴보았던 에디의 스케이팅에서부터 시작해보고자한다. 아래 동영상에서 에디는 체중과 중력을 최대한 이용하여 체력소모를 줄일 수 있는 자세를 보여준다. 그러나 이 자세는 장거리주행을 위한 효율측면에서 좋은 본보기이지만 최대속력면에서는 바람직하지 못한자세이다. 이 자세는 중상급의 동호인들의 모습과 유사하며 스피드를 지향하는 엘리트선수,월드팀선수들의 자세와는 차이를 갖고있다. 그렇기때문에 에디의 자세에서 설명을 시작하고자한다. (아래 동영상은 에디가 시범을 보이는 동작이며 실제 주행시 에디의 자세와 차이가 있습니다) 그림3.1. 에디의 장거리 주행자세 (살로몬, 데스티네이션 스피드 中) 리커버리의 세가지 모델 이해를 돕기위해 리커버리의 형태를 세가지 모델로 구분하고자 한다. 빨강,파랑,녹색의 세점은 각각 양쪽 발과 무게중심(배꼽)을 나타낸다. (참고: [기술해부1: 효율적인 푸쉬(1)]) 편의상 무게중심은 좌우로만 이동한다고 가정하겠다. 그림3.2. 리커버리 모델1 리커버리 모델1은 체중이동이 정확하게 일어나며(푸쉬가 끝나는 시점에서 셋다운된다), 푸쉬가 끝난 발(이하 회수발)이 체중을 지지하는 발(이하 축발)까지 회수되는 동작을 보여준다. 데몬선수들에게서 볼 수 있는 자세이며, 엘리트(월드팀)선수들이 팩을 만들어 달릴때 사용하는 자세이다. 일반적으로 동호인들은 이 모델을 머릿 속에 그리며 연습한다. 그림3.3. 리커버리 모델2 리커버리 모델2는 체중이동이 제대로 이뤄지지않는 경우이다. 회수발을 배꼽 아래까지 가져오지만 그 전에 체중이 이동되기때문에 결과적으로 회수발이 축발까지 오지않고 허우적대는 모습이 된다. 하지만, 본인은 배꼽아래까지 리커버리를 하고 있는 것을 느끼기때문에 자신의 자세가 잘못된 것을 알지 못한다. (나중에 자신의 사진이나 동영상을 보고 상상했던 모습과 크게 달라 좌절한다) 리커버리와 푸쉬의 동작이 정확히 구분되지 않는 것이 가장 큰 문제이다. 그림3.4. 리커버리 모델3 리커버리 모델3는 푸쉬하는 발에 분산된 체중까지 리커버리과정에서 축발에 실어주어 축발에 완전히 체중이 실리고 이 과정에서 발생한 탄력을 추진력에 더하는 것으로 고속주행의 기본이 되는 자세이다. 이 것은 아이스스케이팅에서 볼 수 있는 자세와 흡사하다. 아이스스케이팅은 이 좌우의 움직임(소위 롤링)이 인라인에 비해 더 크고 글라이딩 구간이 더 길다. 반면에 인라인은 상대적으로 짧은 푸쉬를 반복하게 되는데 인라인에 있어서도 이 롤링은 중요한 역할을 한다. 모델2는 반드시 고쳐야하는 자세이며, 모델1과 모델3는 상황에 따라 모두 사용할 수 있어야하는 자세이다. 장거리에서 체력소모를 줄이고자 하거나 팩을 이룰때는 모델1이 적합하고, 최대속도를 내기위해선 모델3가 필요하다. 모델1은 모델3이 축약된 형태로 생각할 수 있으며 정확한 동작을 익히기 위해선 모델3를 연습해야한다. 실제 주행에서의 리커버리 아래 동영상은 앞서 설명한 리커버리 모델3의 실제 모습이다. 이것은 데몬스트레이션을 위한 과장된 동작으로 좌우 움직임이 지나치게 심해보이고 속력도 느려보인다. 또한 실제 주행자세와는 많이 달라보인다. 그림3.5. 싱글푸쉬 시연 (필라 인터네셔널팀) 그러나 이는 실제 주행의 기본이 되는 자세이고 좋은 기록을 위해서는 필수적인 자세이다. 이렇게 중요한 자세를 실제 경기에서 볼 수 없는 이유는 무엇일까? 앞서 설명했 듯이 이 자세는 고속에 적합한 자세이다. 고속(스퍼트)에서는 리커버리의 타이밍을 최대한 땡겨서 같은 시간동안 많은 회수의 푸쉬를 하기 때문에 이러한 동작이 눈에 잘 드러나지 않는다. 즉, 마라톤 대회에서는 주로 모델1의 모습을 보게되고 모델3는 마지막 스퍼트나 중간중간의 브레이크어웨이에서 또 트랙대회중 직선구간에 잠깐 그것도 '빠른동작'으로만 나타나게된다. 이런 이유로 동호인들은 모델3에 대해 인식하지 못하고 또 연습의 필요성을 못느낀다. 실제로 모델1만 연습해도 아마추어대회의 중상위권에 들 수 있다. 다음에 해당하는 분들은 본 칼럼을 통해 모델3을 연습하기 바란다. 1. 부드럽고 안정적이고 우아한 자세로 타고 싶은 분 2. 마지막스퍼트에서 항상 밀린다고 생각하는 분 3. 남들하고 똑같이 푸쉬하는데 속도가 느린 분 리커버리의 원리 리커버리는 앞으로 전진하기위한 자연스러운 동작이다. 리커버리를 어렵게 생각하고 그 동작을 만들어내려고 하면 더 잘안된다. 오히려 회수하는 다리에 긴장을 풀고 정확한 체중이동에 신경쓰면 생각외로 훌륭한 리커버리동작이 나오게된다. 리커버리는 푸쉬한 발을 모아 다시 푸쉬하기 위한 동작인 동시에 근육에 피로를 푸는 '쉬는 동작'이다. 따라서 리커버리하는 동안 근육을 충분히 이완시키는 것이 중요하며 이를 위해서는 발끝이 땅을 향하게 하는 것이 도움이된다. 또한 앞바퀴가 땅에 닿지 않을 정도로만 다리를 들고있는 것이 좋다. 겉에서 보기에 아무리 비디오와 똑같이 다리가 움직인다고하더라도 근육의 피로를 감소시키지못한다면 잘못된 리커버리이다. 즉, 겉으로 드러나는 모습보다는 그 역할에 충실하는 것이 우선이다. D자모양이나 삼각형모양에 연연하지 말고 자신의 다리가 가장 편한 형태를 찾아보자. 초급자들이 착각하는 부분이 다리를 들어서 가져와야한다고 생각하는 것이다. 푸쉬한 발이 지면에서 떨어진뒤 체중을 축발에 고정시키고 푸쉬한 다리에 힘을 빼면 중력에 의해 회수발이 배꼽아래로 떨어지게 된다. 이때 사용되는 근육은 발이 땅에 닿지 않도록 살짝 들어주기 위한 정도 뿐이다. 그림3.6. 파스칼의 리커버리 시연 (사브살로몬팀 클리닉, 촬영: 박순백박사님) 그림3.6에서 파스칼이 보여주고 있는 동작이 바로 가장 자연스러운 형태의 리커버리이다. 체중을 고정한 채 다리에 힘을 빼고 툭 떨어뜨리는 모습을 발견할 수 있다. 어떤형태를 만들기위해 불필요한 근육을 사용하지 않는 것이 그 포인트이다. 그렇다면 우리가 알고 있는 D자 형태의 리커버리는 잘못된 것인가? 아래 파스칼의 주행장면을 보면 위 동영상과는 또 다른 모습을 보여준다. 얼핏보기에 회수발이 D자모양을 그리는 것으로 보인다. 이제 좀 이해했다 싶었는데 다시 머리가 아파오기 시작할 것이다. 그림3.7. 파스칼의 푸쉬 동작 (살로몬, 데스티네이션 스피드 中) 그림3.6은 앞서 설명했듯이 리커버리하는 동안 근육을 충분히 쉬게 하는 것을 강조하는 것이다. 즉, 위 동영상(그림3.7)에서도 리커버리하는 다리의 근육이 충분히 이완되어있다는 것이다. 겉으로 보이는 모습이 다른 이유는 우선 속도의 차이이다. 빠른 속도에서는 자연히 푸쉬가 뒤로 빠지게 된다. 또한 가속을 위해 셋다운시 축발에 체중을 실어 앞으로 치고 나가기 때문이다. (이 부분은 다음 편 '셋다운'에서 자세한 내용을 다루겠다) 고속에서는 리커버리의 타이밍을 땡기는 것이 중요하다고 설명하였다. 이를 위해서는 무릎을 당겨오거나 구부리는 추가적인 테크닉을 필요로 한다. 리커버리에 어느정도의 근력을 투자하고 그로인해 얼마나 더 빠른 속도를 얻는가는 선택의 문제(trade off)이다. 이를 위해 극단적인 두가지 경우를 모두 연습하는 것이 좋다. 리커버리의 연습방법 먼저 정확한 체중이동을 할 수 있도록 연습하는 것이 중요하다. 중심이동에 대한 연습방법은 '이은상 인라인 교실(http://www.inlineedu.com/index.php )'과 '신영식 인라인 클리닉( http://www.sis.ne.kr )'에 훌륭한 동영상 강좌가 많이 있으므로 참고하기 바란다. 리커버리를 연습하기 위해서는 많은 인내력이 필요하다. 평소의 속도대로 달리다 보면 어느새 다리에 힘이 들어가서 정확한 동작을 연습할 수 없기 때문에 느린속도에서 연습해야한다. 또 계속 낮은 자세를 유지해야하기 때문에 힘들고 재미없는 과정이다. 축발에 체중을 싣고 최대한 오래 동안 글라이딩하는 연습과 좌우로 크게 움직이면서 체중이동을 과장해서 하는 훈련을 하면 많은 도움을 얻을 수 있다. 흔히 실수하는 부분이 체중이 실려있는 다리(supporting leg)의 무릎을 너무 일찍 피는 것이다. 리커버리가 끝나기 전에 무릎을 펴버리면 전형적인 모델2의 모습이 된다. 글라이딩하는 동안 무릎을 더 구부리는 것도 체중이동을 돕고 추진력을 높이는 역할을 한다(실제 주행에서도 사용되는 테크닉이다). 또한, 리커버리 모델3를 연습하기 위해서는 중력에 의해 떨어진 회수발이 무게중심(또는 축발)과 따라가는 느낌을 느껴보도록하자. 그림3.8. 살로몬 이동준데몬의 연습장면(동영상을 보시려면 클릭하세요) 위의 살로몬 이동준데몬의 동영상처럼 좌우로 크게 움직이면서 리듬을 갖고 달리면서 머리속에 리커버리 모델3를 그리는 훈련을 반복하다보면 어느새 멋진 리커버리 동작이 몸에 베어있게 될 것이다. 푸쉬와 체중이동의 관계푸쉬와 체중이동은 많은 관련을 갖고 있다. 상급자들은 푸쉬가 곧 체중이동을 의미함을 잘 알고있을 것이다. 하지만, 기존의 이론과 강습은 눈에 보이는 푸쉬위주로 이루어져있는 경우가 많아, 초급자들은 체중이동에 대해 느끼고 실천하기까지 적지않은 시간이 걸린다. 그림4.1은 싱글푸쉬를 설명하기 위해 일반적으로 많이 사용되는 그림이다. 이 것만 보더라도 그동안의 자료들이 푸쉬위주로 설명되어있음을 알 수 있다. 그림4.1. 싱글푸쉬의 궤적 스스로 체중이동에 대해서 이해하고 있다고 생각하는 분들은 위 그림위에 무게중심이 이동하는 곡선을 그려보자. 대부분 고개를 갸우뚱하게 될 것이다. 그동안 우리는 발의 움직임에만 신경을 쓰면서 스케이팅을 했기 때문에 실제로 무게중심이 어떻게 이동되는지는 잘 모르고 있다. 또한, 위 그림에는 스케이트가 땅에 닿아있는 동안의 움직임만 나타나있기 때문에 리커버리하는 발이 어떻게 이동되는지도 알 수 없다. 체중이동과 리커버리 동작이 이해하기 어려운 이유는 그 실체를 정확히 보여주는 자료가 없기 때문은 아닐까? 위 그림은 이론상의 그림이며 실제 주행시 스케이트가 지면에 남기는 궤적과는 차이가 있다. 본 글에서는 실제 스케이팅의 궤적으로 부터 체중이동과 리커버리의 형태에 대해 알아보고자 한다. 실제 스케이팅의 궤적 그림4.3는 에디 매츠거(Eddy Matzger)의 동영상(그림4.2)로부터 추출한 스케이팅 궤적이다. 일반적으로 중,상급의 동호인들이 장거리를 달릴 때 볼 수 있는 자세이다. 그림4.3(좌)는 무게중심을 기준으로 양쪽 발의 상대적인 움직임을 나타낸 것이다. 앞서 살펴본 그림4.1 역시 상대적인 푸쉬 궤적을 나타내고 있는 것이다. 실제 도로상에 스케이트가 남기는 흔적은 그림4.3(우)에 해당한다. 녹색선으로 무게중심(배꼽위치 기준)의 이동을 함께 나타내었다. 그림4.2. 에디의 장거리 주행자세 (살로몬, 데스티네이션 스피드 中) 그림4.3. 에디의 스케이팅 궤적 그림4.1을 머리 속에 담고 연습하는 경우 문제점은 자로 잰 듯 똑바로 가야 맞는 자세라고 생각한다는 것이다. 그림4.3(우)의 경우 무게중심이 S형태로 좌우로 움직이는 것을 보여주고 있는데, 이와 같이 무게중심이 어느정도 좌우로 이동되는 것이 중요하다. 무게중심의 좌우이동이 전혀 없다는 것은 ‘체중을 이용한 추진’(fall)이 거의 일어나지 않는 다는 것이며, 좌우이동이 심한 것은 감속 동작이 된다. 체중이동의 형태를 살펴보면 양쪽 발이 셋다운 되는 시점을 부근에서 방향전황이 일어남을 알 수 있다. 또 글라이딩 궤적과 체중이동 과적이 거의 일치함을 알 수 있다. 다음으로 리커버리 동작을 살펴보면 푸쉬가 끝난 시점부터 자연스럽게 축발, 무게중심의 움직임을 따라 이동하여 무게중심 아래까지 이동하게 된다. 그림4.4. 전통적인 싱글푸쉬 그림4.5. 전통적인 싱글푸쉬의궤적 그림4.4는 엘리트 여자선수들에게서 쉽게 발견할 수 있는 전통적인 싱글푸쉬의 자세이다(실제 주행자세라기보다 저속의 시연용 자세임을 감안하기 바람) 또 그림4.5는 이 동영상에서 추출한 스케이팅 궤적이다. 무게중심을 기준으로 한 상대적인 발의 움직임(그림4.5(좌))는 크게 다르지 않지만, 실제 주행궤적(그림4.5(우))은 언뜻 보기에도 그림4.1과 크게 다른 것을 알 수 있다. 무게중심이 좌우로 이동되는 간격에 비해 그동안 전진하는 거리가 훨씬 길기 때문에(초당1회 푸쉬로 시속30km를 달릴 경우, 한번 푸쉬했을 때 주행하는 거리가 8m) 앞으로만 전진하는 것으로 보일 수도 있지만 이러한 무게중심 이동은 추진력에 중요한 역할을 한다. 적극적인 체중이동 이와 같이 체중이동이 실제주행에서 어떻게 이루어지는지를 정확히 이해하는 것은 연습에 큰 도움이 될 것이라 생각한다. 그림4.1의 형태를 억지로 만들어내는 스케이팅이 아니라 적극적으로 체중이동을 하고 이를 통해 발생하는 스케이팅의 리듬을 느끼며 달리는 것이 중요하다. 그림4.3(좌)와 그림4.5(좌)의 가장 큰 차이점은 리커버리의 형태이다. 그림4.5은 회수한 발이 셋다운하기 전에 중심선을 더 많이 넘어가는 것을 볼 수 있다. 이 것은 그림4.6와 같이 회수한 발 보다 무게중심을 더 빨리 떨어뜨리기(fall) 위한 동작이다. 에디 매츠거에 의해(&: 앰퍼센드)라고 알려진 이 자세는 체중이 가진 위치에너지를 더 큰 추진력으로 만들어낼 수 있게 한다. (이 자세를 앰퍼센드라고 부르는 이유는 &기호의 모양과 그림4.6을 비교해보면 알 수 있을 것이다) 그림4.6. 적극적인 중심이동 (앰퍼센드 자세) 스케이팅의 이론과 실제에 대한 고찰 그렇다면, 그 동안 실제 주행과 차이가 있는 스케이팅 궤적(그림4.1)이 정석으로 알려져 왔을까? 앞서 설명한 것처럼 그림4.1은 무게중심을 기준으로 한 상대적인 발의 움직임을 나타내는 것이다. 제3자의 관점에서 보이는 전체적인 움직임을 이해하는 것도 중요하지만, 스케이트를 신고 달리는 주인공의 관점에서는 상대적인 양쪽발의 움직임이 더 중요하고 관점에 따라 그림4.1이 맞다고 볼 수도 있다. 또한, 그림4.1이 푸쉬와 글라이드의 궤적만을 나타내고 리커버리를 표시안한 것에서도 중요한 의미를 발견할 수 있다. 리커버리는 앞으로 전진하기위한 자연스러운 동작이다. 리커버리의 형태를 정해두고 그 동작을 만들어내려고 하면 자연스러운 동작이 나오기 어렵다. 리커버리 동작은 오히려 회수하는 다리에 긴장을 풀고 정확한 체중이동에 신경을 쓰면 80%는 완성할 수 있는 동작이다. 하지만, 어떤 형태가 과연 자연스러운 것인지 또 바람직한 것인지는 알 필요가 있기 때문에 본 글에서는 선수들의 동영상을 바탕으로 리커버리의 궤적을 나타내보았다. 이러한 원리들을 이해하고 억지로 정해진 틀에 맞추는 형태를 벗어나 창의적인 스케이팅을 하길 바란다. 출처: KIC

Technique: Increase Your Pushing Power By Liz Miller

http://www.getrolling.com/orbit/10powertips.html

Tired of being left behind on uphills? Ready to adopt a smooth, elegant stroke that is both fast and powerful? If so, here's an opportunity to piece that dream stroke together one component at a time. Practice just one of these tips each time you skate this summer. I recommend you start with the first, which is the easiest. You'll experience impressive improvements from each tip, so just imagine the results when you can incorporate every part into every stroke!
Note: If poor balance prevents you from working on these tips, be sure to read Dan's article, Put a Little Balance in Your Life.

1. Get low -- Bend your support leg close to 90 degrees while your pushing leg is at work. That makes it possible to keep the wheels pushing across a longer distance, which adds power and speed. On the gliding foot, be sure to keep your nose, knee and toes lined up one over the other to maximize the push.
2. No toe-flicking -- For the entire length of each stroke, keep all 4 (or 5) wheels of the pushing skate in contact with the pavement, concentrating the most pressure on the heel wheel. If you lift the back wheels before the end of your stroke, you lose both power and friction.
3. Push to the side, not back -- A side-directed push results in forward momentum (Don't ask me how!) Tip #2 is easy if you do as speedskaters do and imagine you are pushing the right heel toward 2 o'clock and the left heel toward 10 o'clock. Yes, that's more forward than lateral, but the attempt is what results in 3 o'clock and 9 o'clock strokes. To me, it feels like I'm trying to paint a giant handlebar mustache with my heel wheels.
4. Polish your swizzles -- Swizzle practice (making figure eights with both skates in constant pavement contact) is one of the best ways to get used to pushing with the heels and pushing laterally. Be assertive: listen for a slight scrubbing sound from your heel wheels at that moment of greatest force when you steer your toes inward. Then sink to a 90-degree knee bend when both skates are under your hips to regroup for another forceful push. Enjoy the fitness benefits while you're at it!
5. Straighten your knee -- A stroke is incomplete if your knee is still bent when you lift it off the pavement for recovery. This could lose you several inches of contact with the pavement, which means lost power and efficiency.
6. Slow your stroke tempo -- If the previous tips haven't forced you into less strokes per minute, it's time to focus on longer strokes and glides. My favorite game for this is to skate behind somebody and try to match their speed with half the number of strokes. This practice makes a good test for what you've learned so far this summer!
7. Make Air D's -- To conserve energy, keep your wheels close to the pavement as you bring back (recover) your skate at the end of the stroke. While you trace a sideways D with your toe wheel, your knee follows the same path higher up. The knee comes in behind the support leg so close that you brush it as you move the skate ahead for the set-down.
8. Fine tune your set-down -- Put your skate back on the pavement slightly ahead of you, with the wheels parallel to the direction of travel, rather than angled which deflects your speed. Land on the "tops" or center edges, not on the inside wheel edges. Later, once your stroke is powerful enough, try landing that skate beyond your center line of travel and touching down on the outside edges. This is the classic component of the Stride 3 or "power stride" taught by IISA-certified instructors. Try learning it on just one side at first, skating along a long painted line to gauge your set-down placements.
9. Push with your hip -- By fully extending your pushing leg from both the hip and knee joints at the end of each stroke, you access power stored in some of your largest muscle groups. Just try unkinking at the hip when you finish each stroke.
10. Let gravity help -- You can use gravity to aid in stroke efficiency. At the end of each glide, when your body is aligned nose-knee-toes over the support leg, delay set-down of the recovered skate while you let your support leg begin the a new push. As your weight begins its shift toward the recovered skate, you feel a slight "fall" just before before it touches down to catch you. That falling feeling is your body using gravity to add more power to what your muscles give. You want each set down to make a loud "clomp" for this drill. Make sure you're still making lateral pushes throughout.

And here's my bonus Zen tip: On a long fitness or training skate when exhaustion begins to weaken your will and technique, "relax and allow" the discomfort without obsessing, which is sure to make you more miserable and less mobile. Instead, experience each stroke and each inhalation as a new one (be here now) knowing the pain will end in due time.