vimhelp-de 7.1 - en to de translation catalogue (149 entries)

en: *quickref.txt*  For Vim version 7.1.  Last change: 2007 May 11
de: *quickref.txt*  Für Vim Version 7.1.  Letzte Änderung: 2007-Mai-11

en: 		  VIM REFERENCE MANUAL    by Bram Moolenaar
de: 		  VIM REFERENZ-HANDBUCH    von Bram Moolenaar

en: 			    Quick reference guide
de: 			    Schnellreferenzführer

en: 							 *quickref* *Contents*
     tag	  subject			 tag	  subject	~
    |Q_ct|  list of help files		|Q_re|	Repeating commands
    |Q_lr|	motion: Left-right		|Q_km|	Key mapping
    |Q_ud|	motion: Up-down			|Q_ab|	Abbreviations
    |Q_tm|	motion: Text object		|Q_op|	Options
    |Q_pa|	motion: Pattern searches	|Q_ur|	Undo/Redo commands
    |Q_ma|	motion: Marks			|Q_et|	External commands
    |Q_vm|	motion: Various			|Q_qf|	Quickfix commands
    |Q_ta|	motion: Using tags		|Q_vc|	Various commands
    |Q_sc|	Scrolling			|Q_ce|	Ex: Command-line editing
    |Q_in|	insert: Inserting text		|Q_ra|	Ex: Ranges
    |Q_ai|	insert: Keys			|Q_ex|	Ex: Special characters
    |Q_ss|	insert: Special keys		|Q_st|	Starting VIM
    |Q_di|	insert: Digraphs		|Q_ed|	Editing a file
    |Q_si|	insert: Special inserts		|Q_fl|	Using the argument list
    |Q_de|	change: Deleting text		|Q_wq|	Writing and quitting
    |Q_cm|	change: Copying and moving	|Q_ac|	Automatic commands
    |Q_ch|	change: Changing text		|Q_wi|	Multi-window commands
    |Q_co|	change: Complex			|Q_bu|	Buffer list commands
    |Q_vi|	Visual mode			|Q_sy|	Syntax highlighting
    |Q_to|	Text objects			|Q_gu|	GUI commands
    					|Q_fo|  Folding
de: 					 *quickref* *Contents* *schnellreferenz*
     Tag	  Thema				 Tag	  Thema	~
    |Q_ct|  Liste der Hilfedateien		|Q_re|	Befehle wiederholen
    |Q_lr|	Bewegung: Links-rechts		|Q_km|	Tasten belegen
    |Q_ud|	Bewegung: Oben-unten		|Q_ab|	Abkürzungen
    |Q_tm|	Bewegung: Text-Objekte		|Q_op|	Optionen
    |Q_pa|	Bewegung: Mustersuche		|Q_ur|	Undo/Redo Befehle
    |Q_ma|	Bewegung: Markierungen		|Q_et|	Externe Befehle
    |Q_vm|	Bewegung: Verschiedenes		|Q_qf|	Quickfix Befehle
    |Q_ta|	Bewegung: Tags benutzen		|Q_vc|	Verschiedene Befehle
    |Q_sc|	Scrollen			|Q_ce|	Ex: Befehlszeile editieren
    |Q_in|	Einfügen: Text einfügen		|Q_ra|	Ex: Bereiche
    |Q_ai|	Einfügen: Tasten		|Q_ex|	Ex: Spezielle Zeichen
    |Q_ss|	Einfügen: Spezielle Tasten	|Q_st|	VIM starten
    |Q_di|	Einfügen: Digraphen		|Q_ed|	Eine Datei editieren
    |Q_si|	Einfügen: Spezielle Einfügungen	|Q_fl|	Die Argumentenliste benutzen
    |Q_de|	Ändern: Text löschen		|Q_wq|	Schreiben und Beenden
    |Q_cm|	Ändern: Kopieren und bewegen	|Q_ac|	Automatische Befehle
    |Q_ch|	Ändern: Text ändern		|Q_wi|	Befehle für mehrere Fenster
    |Q_co|	Ändern: Komplex			|Q_bu|	Pufferlistenbefehle
    |Q_vi|	Visueller Modus			|Q_sy|	Syntax-Hervorhebung
    |Q_to|	Textobjekte			|Q_gu|	GUI-Befehle
    					|Q_fo|  Falten

en: N is used to indicate an optional count that can be given before the command.
    ------------------------------------------------------------------------------
de: N wird benutzt, um eine optionale Anzahl anzuzeigen, die vor dem Befehl
    angegeben werden kann.
    ------------------------------------------------------------------------------

en: *Q_lr*		Left-right motions
de: *Q_lr*		Bewegungen links-rechts

en: |h|	N  h		left (also: CTRL-H, <BS>, or <Left> key)
    |l|	N  l		right (also: <Space> or <Right> key)
    |0|	   0		to first character in the line (also: <Home> key)
    |^|	   ^		to first non-blank character in the line
    |$|	N  $		to the last character in the line (N-1 lines lower)
    			   (also: <End> key)
    |g0|	N  g0		to first character in screen line (differs from "0"
    			   when lines wrap)
    |g^|	N  g^		to first non-blank character in screen line (differs
    			   from "^" when lines wrap)
    |g$|	N  g$		to last character in screen line (differs from "$"
    			   when lines wrap)
    |gm|	N  gm		to middle of the screen line
    |bar|	N  |		to column N (default: 1)
    |f|	N  f{char}	to the Nth occurrence of {char} to the right
    |F|	N  F{char}	to the Nth occurrence of {char} to the left
    |t|	N  t{char}	till before the Nth occurrence of {char} to the right
    |T|	N  T{char}	till before the Nth occurrence of {char} to the left
    |;|	N  ;		repeat the last "f", "F", "t", or "T" N times
    |,|	N  ,		repeat the last "f", "F", "t", or "T" N times in
    			   opposite direction
    ------------------------------------------------------------------------------
de: |h|	N  h		links (auch: CTRL-H, <BS> oder <Links>)
    |l|	N  l		rechts (auch: <Leerzeichen> oder <Rechts>)
    |0|	   0		zum ersten Zeichen in der Zeile (auch <Pos1>)
    |^|	   ^		zum ersten nicht-leeren Zeichen in der Zeile
    |$|	N  $		zum letzten Zeichen in der Zeile
    			    (N-1 Zeilen nach unten; auch <Ende>)
    |g0|	N  g0		zum ersten Zeichen in der Bildschirmzeile
    			    (unterscheidet sich von »0«, wenn die Zeile
    			    umbricht)
    |g^|	N  g^		zum ersten nicht-leeren Zeichen in der Bildschirmzeile
    			    (unterscheidet sich von »^«, wenn die Zeile
    			    umbricht)
    |g$|	N  g$		zum letzten Zeichen in der Bildschirmzeile
    			    (unterscheidet sich von »$«, wenn die Zeile
    			    umbricht)
    |gm|	N  gm		zur Mitte der Bildschirmzeile
    |bar|	N  |		zu Spalte N (Voreinstellung: 1)
    |f|	N  f{zeich}	zum Nten Auftreten von {zeich} nach rechts
    |F|	N  F{zeich}	zum Nten Auftreten von {zeich} nach links
    |t|	N  t{zeich}	vor das Nte Auftreten von {zeich} nach rechts
    |T|	N  T{zeich}	vor das Nte Auftreten von {zeich} nach links
    |;|	N  ;		das letzte »f«, »F«, »t« oder »T« N-mal wiederholen
    |,|	N  ,		das letzte »f«, »F«, »t« oder »T« N-mal
    			    in entgegengesetzter Richtung wiederholen
    ------------------------------------------------------------------------------

en: *Q_ud*		Up-down motions
de: *Q_ud*		Bewegungen rauf-runter

en: |k|	N  k		up N lines (also: CTRL-P and <Up>)
    |j|	N  j		down N lines (also: CTRL-J, CTRL-N, <NL>, and <Down>)
    |-|	N  -		up N lines, on the first non-blank character
    |+|	N  +		down N lines, on the first non-blank character (also:
    			   CTRL-M and <CR>)
    |_|	N  _		down N-1 lines, on the first non-blank character
    |G|	N  G		goto line N (default: last line), on the first
    			   non-blank character
    |gg|	N  gg		goto line N (default: first line), on the first
    			   non-blank character
    |N%|	N  %		goto line N percentage down in the file.  N must be
    			   given, otherwise it is the |%| command.
    |gk|	N  gk		up N screen lines (differs from "k" when line wraps)
    |gj|	N  gj		down N screen lines (differs from "j" when line wraps)
    ------------------------------------------------------------------------------
de: |k|	N  k		N Zeilen hoch (auch: CTRL-P und <Hoch>)
    |j|	N  j		N Zeilen runter (auch: CTRL-J, CTRL-N, <NL> und
    			    <Runter>)
    |-|	N  -		N Zeilen hoch, auf das erste nicht-leere Zeichen
    |+|	N  +		N Zeilen runter, auf das erste nicht-leere Zeichen
    			    (auch: CTRL-M und <CR>)
    |_|	N  _		N-1 Zeilen runter, auf das erste nicht-leere Zeichen
    |G|	N  G		gehe zu Zeile N (Voreinstellung: letzte Zeile), auf das
    			    erste nicht-leere Zeichen
    |gg|	N  gg		gehe zu Zeile N (Voreinstellung: erste Zeile), auf das
    			    erste nicht-leere Zeichen
    |N%|	N  %		gehe zu Prozent % in der Datei.  N muss angegeben
    			    werden, sonst ist es der Befehl |%|.
    |gk|	N  gk		N Bildschirmzeilen hoch (unterscheidet sich von »k«,
    			    wenn die Zeile umbricht)
    |gj|	N  gj		N Bildschirmzeilen runter (unterscheidet sich von »j«,
    			    wenn die Zeile umbricht)
    ------------------------------------------------------------------------------

en: *Q_tm*		Text object motions
de: *Q_tm*		Textobjektbewegungen

en: |w|	N w		N words forward |W|	N W		N blank-separated |WORD|s forward |e|	N e		forward to the end of the Nth word |E|	N E		forward to the end of the Nth blank-separated |WORD| |b|	N b		N words backward |B|	N B		N blank-separated |WORD|s backward |ge|	N ge		backward to the end of the Nth word |gE|	N gE		backward to the end of the Nth blank-separated |WORD|
de: |w|	N w		N Worte vorwärts
    |W|	N W		N leerzeichen-getrennte |WORT|e vorwärts
    |e|	N e		vorwärts zum Ende des Nten Wortes
    |E|	N E		vorwärts zum Ende des Nten leerzeichen-getrennten
    			    |WORT|es
    |b|	N b		N Worte zurück
    |B|	N B		N leerzeichen-getrennte |WORT|e zurück
    |ge|	N ge		zurück zum Ende des Nten Wortes
    |gE|	N gE		zurück zum Ende des Nten leerzeichen-getrennten |WORT|es

en: |)|	N  )		N sentences forward
    |(|	N  (		N sentences backward
    |}|	N  }		N paragraphs forward
    |{|	N  {		N paragraphs backward
    |]]|	N  ]]		N sections forward, at start of section
    |[[|	N  [[		N sections backward, at start of section
    |][|	N  ][		N sections forward, at end of section
    |[]|	N  []		N sections backward, at end of section
    |[(|	N  [(		N times back to unclosed '('
    |[{|	N  [{		N times back to unclosed '{'
    |[m|	N  [m		N times back to start of method (for Java)
    |[M|	N  [M		N times back to end of method (for Java)
    |])|	N  ])		N times forward to unclosed ')'
    |]}|	N  ]}		N times forward to unclosed '}'
    |]m|	N  ]m		N times forward to start of method (for Java)
    |]M|	N  ]M		N times forward to end of method (for Java)
    |[#|	N  [#		N times back to unclosed "#if" or "#else"
    |]#|	N  ]#		N times forward to unclosed "#else" or "#endif"
    |[star|	N  [*		N times back to start of comment "/*"
    |]star|	N  ]*		N times forward to end of comment "*/"
    ------------------------------------------------------------------------------
de: |)|	N )		N Sätze vorwärts
    |(|	N (		N Sätze rückwärts
    |}|	N }		N Absätze vorwärts
    |{|	N {		N Absätze rückwärts
    |]]|	N ]]		N Abschnitte vorwärts, auf den Beginn des Abschnittes
    |[[|	N [[		N Abschnitte rückwärts, auf den Beginn des Abschnittes
    |][|	N ][		N Abschnitte vorwärts, auf das Ende des Abschnittes
    |[]|	N []		N Abschnitte rückwärts, auf das Ende des Abschnittes
    |[(|	N [(		N-mal zurück zu ungeschlossener »(«
    |[{|	N [{		N-mal zurück zu ungeschlossener »{«
    |[m|	N [m		N-mal zurück zu Methodenbeginn (für Java)
    |[M|	N [M		N-mal zurück zu Methodenende (für Java)
    |)]|	N )]		N-mal vorwärts zu ungeschlossener »)«
    |}]|	N }]		N-mal vorwärts zu ungeschlossener »}«
    |]m|	N ]m		N-mal vorwärts zu Methodenbeginn (für Java)
    |]M|	N ]M		N-mal vorwärts zu Methodenende (für Java)
    |[#|	N [#		N-mal zurück zu ungeschlossenem »#if« oder »#else«
    |]#|	N ]#		N-mal vorwärts zu ungeschlossenem »#else« oder »#endif«
    |[star|	N [*		N-mal zurück zum Kommentarbeginn »/*«
    |}star|	N ]*		N-mal vorwärts zum Kommentarende »*/«
    ------------------------------------------------------------------------------

en: *Q_pa*		Pattern searches
de: *Q_pa*		Mustersuchen

en: |/|	N  /{pattern}[/[offset]]<CR>
    			search forward for the Nth occurrence of {pattern}
    |?|	N  ?{pattern}[?[offset]]<CR>
    			search backward for the Nth occurrence of {pattern}
    |/<CR>|	N  /<CR>	repeat last search, in the forward direction
    |?<CR>|	N  ?<CR>	repeat last search, in the backward direction
    |n|	N  n		repeat last search
    |N|	N  N		repeat last search, in opposite direction
    |star|	N  *		search forward for the identifier under the cursor
    |#|	N  #		search backward for the identifier under the cursor
    |gstar|	N  g*		like "*", but also find partial matches
    |g#|	N  g#		like "#", but also find partial matches
    |gd|	   gd		goto local declaration of identifier under the cursor
    |gD|	   gD		goto global declaration of identifier under the cursor
de: |/|	N  /{Muster}[/[Offset]]<CR>
    			suche vorwärts nach dem N-ten Auftreten von {Muster}
    |?|	N  ?{Muster}[?[Offset]]<CR>
    			suche rückwärts nach dem N-ten Auftreten von {Muster}
    |/<CR>|	N  /<CR>	wiederhole letzte Suche, vorwärts gerichtet
    |?<CR>|	N  ?<CR>	wiederhole letzte Suche, rückwärts gerichtet
    |n|	N  n		wiederhole letzte Suche
    |N|	N  N		wiederhole letzte Suche, in Gegenrichtung
    |star|	N  *		Suche vorwärts nach dem Identifikator unter dem Cursor
    |#|	N  #		Suche rückwärts nach dem Identifikator unter dem Cursor
    |gstar|	N  *		wie »*«, finde aber auch teilweise Übereinstimmungen
    |g#|	N  #		wie »#«, finde aber auch teilweise Übereinstimmungen
    |gd|	   gd		gehe zu lokaler Deklaration des Identifikators unter
    			    dem Cursor
    |gD|	   gD		gehe zu globaler Deklaration des Identifikators unter
    			    dem Cursor

en: |pattern|		Special characters in search patterns
de: |pattern|		Spezielle Zeichen in Suchmustern

en: 			meaning		      magic   nomagic	~
    		matches any single character	.	\.
    		       matches start of line	^	^
    			       matches <EOL>	$	$
    		       matches start of word	\<	\<
    			 matches end of word	\>	\>
    	matches a single char from the range	[a-z]	\[a-z]
          matches a single char not in the range	[^a-z]	\[^a-z]
    		  matches an identifier char	\i	\i
    		   idem but excluding digits	\I	\I
    		 matches a keyword character	\k	\k
    		   idem but excluding digits	\K	\K
    	       matches a file name character	\f	\f
    		   idem but excluding digits	\F	\F
    	       matches a printable character	\p	\p
    		   idem but excluding digits	\P	\P
    	     matches a white space character	\s	\s
    	 matches a non-white space character	\S	\S
de: 			Bedeutung	magisch (magic) nichtmagisch (nomagic)	~
    	    passt auf jedes einzelne Zeichen	.	\.
    		      passt auf Zeilenanfang	^	^
    		passt auf <EOL> (Zeilenende)	$	$
    			passt auf Wortanfang	\<	\<
    			  passt auf Wortende	\>	\>
    	     passt auf ein einzelnes Zeichen
    			     aus dem Bereich	[a-z]	\[a-z]
    	    passt auf ein einzelnes Zeichen,
    		das nicht in dem Bereich ist	[^a-z]	\[^a-z]
    	  passt auf ein Identifikatorzeichen	\i	\i
    	   ebenso, schließt aber Ziffern aus	\I	\I
    	  passt auf ein Schlüsselwortzeichen	\k	\k
    	   ebenso, schließt aber Ziffern aus	\K	\K
    	     passt auf ein Dateinamenzeichen	\f	\f
    	   ebenso, schließt aber Ziffern aus	\F	\F
    	    passt auf ein druckbares Zeichen	\p	\p
    	   ebenso, schließt aber Ziffern aus	\P	\P
    		passt auf ein weißes Zeichen	\s	\s
    	  passt auf ein nicht-weißes Zeichen	\S	\S

en: 			       matches <Esc>	\e	\e
    			       matches <Tab>	\t	\t
    				matches <CR>	\r	\r
    				matches <BS>	\b	\b
de: 			     passt auf <Esc>	\e	\e
    			     passt auf <Tab>	\t	\t
    			      passt auf <CR>	\r	\r
    			      passt auf <BS>	\b	\b

en:      matches 0 or more of the preceding atom	*	\*
         matches 1 or more of the preceding atom	\+	\+
    	matches 0 or 1 of the preceding atom	\=	\=
    	matches 2 to 5 of the preceding atom	\{2,5}  \{2,5}
    		  separates two alternatives	\|	\|
    		group a pattern into an atom	\(\)	\(\)
de: passt auf 0 oder mehr des vorhergehenden Atoms	*	\*
    passt auf 1 oder mehr des vorhergehenden Atoms	\+	\+
      passt auf 0 oder 1 des vorhergehenden Atoms	\=	\=
       passt auf 2 bis 5 des vorhergehenden Atoms	\{2,5}  \{2,5}
    		     trennt zwei Alternativen	\|	\|
    	   gruppiert ein Muster zu einem Atom	\(\)	\(\)

en: |search-offset|		Offsets allowed after search command
de: |search-offset|		Erlaubte Offsets nach Suchbefehlen

en:     [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)
        ;{search-command}	execute {search-command} next
    ------------------------------------------------------------------------------
de:     [Num]	[Num] Zeilen abwärts, in Spalte 1
        +[Num]	[Num] Zeilen abwärts, in Spalte 1
        -[Num]	[Num] Zeilen aufwärts, in Spalte 1
        e[+Num]	[Num] Zeichen nach rechts vom Ende der Übereinstimmung
        e[-Num]	[Num] Zeichen nach links vom Ende der Übereinstimmung
        s[+Num]	[Num] Zeichen nach rechts vom Beginn der Übereinstimmung
        s[-Num]	[Num] Zeichen nach links vom Beginn der Übereinstimmung
        b[+Num]	wie s[+Num]
        b[-Num]	wie s[-Num]
        ;{Suchbefehl}	führe als nächstes {Suchbefehl} aus
    ------------------------------------------------------------------------------

en: *Q_ma*		Marks and motions
de: *Q_ma*		Markierungen und Bewegungen

en: |m|	   m{a-zA-Z}	mark current position with mark {a-zA-Z}
    |`a|	   `{a-z}	go to mark {a-z} within current file
    |`A|	   `{A-Z}	go to mark {A-Z} in any file
    |`0|	   `{0-9}	go to the position where Vim was previously exited
    |``|	   ``		go to the position before the last jump
    |`quote|   `"		go to the position when last editing this file
    |`[|	   `[		go to the start of the previously operated or put text
    |`]|	   `]		go to the end of the previously operated or put text
    |`<|	   `<		go to the start of the (previous) Visual area
    |`>|	   `>		go to the end of the (previous) Visual area
    |`.|	   `.		go to the position of the last change in this file
    |'|	   '{a-zA-Z0-9[]'"<>.}
    			same as `, but on the first non-blank in the line
    |:marks|  :marks	print the active marks
    |CTRL-O|  N  CTRL-O	go to Nth older position in jump list
    |CTRL-I|  N  CTRL-I	go to Nth newer position in jump list
    |:ju|	  :ju[mps]	print the jump list
    ------------------------------------------------------------------------------
de: |m|	   m{a-zA-Z}	markiere aktuelle Position mit Markierung {a-zA-Z}
    |`a|	   `{a-z}	gehe zur Markierung {a-z} in aktueller Datei
    |`A|	   `{A-Z}	gehe zur Markierung {A-Z} in jeglicher Datei
    |`0|	   `{0-9}	gehe zur Position, wo Vim zuvor beendet wurde
    |``|	   ``		gehe zur Position vor dem letzten Sprung
    |`quote|   `"		gehe zur Position wo diese Datei zuletzt editiert wurde
    |`[|	   `[		gehe zum Beginn des zuletzt bearbeiteten oder
    			eingefügten Textes
    |`]|	   `]		gehe zum Ende des zuletzt bearbeiteten oder
    			eingefügten Textes
    |`<|	   `<		gehe zum Beginn des (letzten) visuellen Bereiches
    |`>|	   `>		gehe zum Ende des (letzten) visuellen Bereiches
    |`.|	   `.		gehe zur Position der letzten Änderung in dieser Datei
    |'|	   '{a-zA-Z0-9[]'"<>.}
    			dasselbe wie »`«, aber auf das erste nichtleere Zeichen
    			in der Zeile
    |:marks|  :marks	gib die aktiven Markierungen aus
    |CTRL-O|  N  CTRL-O	gehe zur N-ten neueren Position in der Sprungliste
    |CTRL-I|  N  CTRL-I	gehe zur N-ten älteren Position in der Sprungliste
    |:ju|	  :ju[mps]	gib die Sprungliste aus
    ------------------------------------------------------------------------------

en: *Q_vm*		Various motions
de: *Q_vm*		Verschiedene Bewegungen

en: |%|	   %		find the next brace, bracket, comment, or "#if"/
    			   "#else"/"#endif" in this line and go to its match
    |H|	N  H		go to the Nth line in the window, on the first
    			   non-blank
    |M|	   M		go to the middle line in the window, on the first
    			   non-blank
    |L|	N  L		go to the Nth line from the bottom, on the first
    			   non-blank
de: |%|	   %		finde die nächste »{«, »}«, »(«, »)«, »[«, »]«, das
    			   nächste »/*«, »*/«, »#if«, »#else« oder »#endif«
    			   in dieser Zeile, und gehe zum Übereinstimmenden
    |H|	N  H		gehe zur N-ten Zeile im Fenster, auf das erste
    			   nicht-leere Zeichen
    |M|	   M		gehe zur mittleren Zeile im Fenster, auf das erste
    			   nicht-leere Zeichen
    |L|	N  L		gehe zur N-ten Zeile von unten, auf das erste
    			   nicht-leere Zeichen

en: |go|	N  go			go to Nth byte in the buffer
    |:go|	:[range]go[to] [off]	go to [off] byte in the buffer
    ------------------------------------------------------------------------------
de: |go|	N  go		gehe zum N-ten Byte im Puffer
    |:go|	:[Bereich]go[to] [off]	gehe zu Byte [off] im Puffer
    ------------------------------------------------------------------------------

en: *Q_ta*		Using tags
de: *Q_ta*		Tags benutzen

en: |:ta|	   :ta[g][!] {tag}	Jump to tag {tag}
    |:ta|	   :[count]ta[g][!]	Jump to [count]'th newer tag in tag list
    |CTRL-]|      CTRL-]		Jump to the tag under cursor, unless changes
    				   have been made
    |:ts|	   :ts[elect][!] [tag]	List matching tags and select one to jump to
    |:tjump|   :tj[ump][!] [tag]	Jump to tag [tag] or select from list when
    				   there are multiple matches
    |:ltag|	   :lt[ag][!] [tag]	Jump to tag [tag] and add matching tags to the
    				   location list.
de: |:ta|	   :ta[g][!] {Tag}	Springe zum Tag {Tag}
    |:ta|	   :[Anzahl]ta[g][!]	Springe zum [Anzahl]-ten neueren Tag in der
    				   Tagliste
    |CTRL-]|      CTRL-]		Springe zum Tag unter dem Cursor, solange
    				   keine Änderungen gemacht wurde
    |:ts|	   :ts[select][!] [Tag] Liste passende Tags auf und wähle
    				   einen zum Anspringen aus
    |:tjump|   :tj[ump][!] [Tag]	Springe zum Tag [Tag] oder wähle aus Liste,
    				   wenn es mehrere Übereinstimmungen gibt
    |:ltag|	   :lt[ag][!] [Tag]	Springe zum Tag [Tag] und füge passende Tags
    				   zur Lokationsliste hinzu

en: |:tags|	   :tags		Print tag list
    |CTRL-T|   N  CTRL-T		Jump back from Nth older tag in tag list
    |:po|	   :[count]po[p][!]	Jump back from [count]'th older tag in tag list
    |:tnext|   :[count]tn[ext][!]	Jump to [count]'th next matching tag
    |:tp|      :[count]tp[revious][!] Jump to [count]'th previous matching tag
    |:tr|	   :[count]tr[ewind][!] Jump to [count]'th matching tag
    |:tl|	   :tl[ast][!]		Jump to last matching tag
de: |:tags|	   :tags		Gebe Tagliste aus
    |CTRL-T|   N  CTRL-T		Springe zurück vom N-ten älteren Tag in der
    				   Tagliste
    |:po|	   :[Anzahl]po[p][!]	Springe zurück vom [Anzahl]-ten älteren Tag
    				   in der Tagliste
    |:tnext|   :[Anzahl]tn[ext][!]	Springe zum [Anzahl]-ten nächsten passenden
    				   Tag
    |:tp|      :[Anzahl]tp[previous][!] Springe zum [Anzahl]-ten vorigen passenden
    				   Tag
    |:tr|	   :[Anzahl]tr[ewind][!] Springe zum [Anzahl]-ten passenden Tag
    |:tl|	   :tl[ast][!]		Springe zum letzten passenden Tag

en: |:ptag|	   :pt[ag] {tag}	open a preview window to show tag {tag}
    |CTRL-W_}|     CTRL-W }		like CTRL-] but show tag in preview window
    |:pts|     :pts[elect]		like ":tselect" but show tag in preview window
    |:ptjump|  :ptj[ump]		like ":tjump" but show tag in preview window
    |:pclose|  :pc[lose]		close tag preview window
    |CTRL-W_z|     CTRL-W z		close tag preview window
    ------------------------------------------------------------------------------
de: |:ptag|	   :pt[ag] {Tag}	Öffne ein Vorschaufenster, um Tag {Tag}
    				   anzuzeigen
    |CTRL-W_}|     CTRL-W }		wie CTRL-], aber zeige Tag in Vorschaufenster
    |:pts|     :pts[elect]		wie »:tselect«, aber zeige Tag in
    				   Vorschaufenster
    |:ptjump|  :ptj[ump]		wie »:tjump«, aber zeige Tag in Vorschaufenster
    |:pclose|  :pc[lose]		schließe Tag-Vorschaufenster
    |CTRL-W_z|     CTRL-W z		schließe Tag-Vorschaufenster
    ------------------------------------------------------------------------------

en: *Q_sc*		Scrolling
de: *Q_sc*		Scrollen

en: |CTRL-E|	N  CTRL-E	window N lines downwards (default: 1)
    |CTRL-D|	N  CTRL-D	window N lines Downwards (default: 1/2 window)
    |CTRL-F|	N  CTRL-F	window N pages Forwards (downwards)
    |CTRL-Y|	N  CTRL-Y	window N lines upwards (default: 1)
    |CTRL-U|	N  CTRL-U	window N lines Upwards (default: 1/2 window)
    |CTRL-B|	N  CTRL-B	window N pages Backwards (upwards)
    |z<CR>|		   z<CR> or zt	redraw, current line at top of window
    |z.|		   z.	 or zz	redraw, current line at center of window
    |z-|		   z-	 or zb	redraw, current line at bottom of window
de: |CTRL-E|	N  CTRL-E	Fenster N Zeilen abwärts (ohne Anzahl: 1 Zeile)
    |CTRL-D|	N  CTRL-D	Fenster N Zeilen abwärts (ohne Anzahl: 1/2
    				   Fenster)
    |CTRL-F|	N  CTRL-F	Fenster N Seiten vorwärts (abwärts)
    |CTRL-Y|	N  CTRL-Y	Fenster N Zeilen aufwärts (ohne Anzahl: 1 Zeile)
    |CTRL-U|	N  CTRL-U	Fenster N Zeilen aufwärts (ohne Anzahl: 1/2
    				   Fenster)
    |CTRL-B|	N  CTRL-B	Fenster N Seiten zurück (aufwärts)
    |z<CR>|		   z<CR>oder zt	neuzeichnen, aktuelle Zeile an erste im Fenster
    |z.|		   z.	oder zz	neuzeichnen, aktuelle Zeile an Mitte vom Fenster
    |z-|		   z-	oder zb	neuzeichnen, aktuelle Zeile an letzte im Fenster

en: These only work when 'wrap' is off:
    |zh|		N  zh		scroll screen N characters to the right
    |zl|		N  zl		scroll screen N characters to the left
    |zH|		N  zH		scroll screen half a screenwidth to the right
    |zL|		N  zL		scroll screen half a screenwidth to the left
    ------------------------------------------------------------------------------
de: Die folgenden funktionieren nur, wenn 'wrap' deaktiviert ist:
    |zh|		N  zh		scrolle Bildschirm N Zeichen nach rechts
    |zl|		N  zl		scrolle Bildschirm N Zeichen nach links
    |zH|		N  zH		scrolle Bildschirm N halbe Bildschirmbreiten
    				   nach rechts
    |zL|		N  zL		scrolle Bildschirm N halbe Bildschirmbreiten
    				   nach links
    ------------------------------------------------------------------------------

en: *Q_in*		Inserting text
de: *Q_in*		Text einfügen

en: |a|	N a	append text after the cursor (N times)  |A|	N A	append text at the end of the line (N times)  |i|	N i	insert text before the cursor (N times) (also: <Insert>)  |I|	N I	insert text before the first non-blank in the line (N times)  |gI|	N gI	insert text in column 1 (N times)  |o|	N o	open a new line below the current line, append text (N times)  |O|	N O	open a new line above the current line, append text (N times)  |:startinsert| :star[tinsert][!] start Insert mode, append when [!] used |:startreplace| :startr[eplace][!] start Replace mode, at EOL when [!] used
de: |a|	N a	hänge Text nach dem Cursor an (N-mal)
    |A|	N A	hänge Text am Ende der Zeile an (N-mal)
    |i|	N i	füge Text vor dem Cursor ein (N-mal; auch: <Einfg>)
    |I|	N I	füge Text vor dem ersten nicht-leeren Zeichen
    		   in der Zeile ein (N-mal)
    |gI|	N gI	füge Text in Spalte 1 ein (N-mal)
    |o|	N o	öffne neue Zeile unter der aktuellen Zeile,
    		   hänge Text an (N-mal)
    |O|	N O	öffne neue Zeile über der aktuellen Zeile,
    		   hänge Text an (N-mal)
    |:startinsert| :star[tinsert][!] gehe in Einfügemodus,
    		   hänge an, wenn [!] benutzt wird
    |:startreplace| :startr[eplace][!] gehe in Ersetzungsmodus,
    		   am EOL, wenn [!] benutzt wird

en: in Visual block mode:
    |v_b_I|    I	insert the same text in front of all the selected lines
    |v_b_A|	   A	append the same text after all the selected lines
    ------------------------------------------------------------------------------
de: im visuellen Blockmodus:
    |v_b_I|    I	füge denselben Text vorn in allen ausgewählten Zeilen ein
    |v_b_A|	   A	hänge denselben Text hinten in allen ausgewählten Zeilen an
    ------------------------------------------------------------------------------

en: *Q_ai*		Insert mode keys
de: *Q_ai*		Tasten im Einfügemodus

en: |insert-index|	alphabetical index of Insert mode commands
de: |insert-index|	alphabetischer Index der Befehle im Einfügemodus

en: leaving Insert mode:
    |i_<Esc>|	<Esc>		  end Insert mode, back to Normal mode
    |i_CTRL-C|	CTRL-C		  like <Esc>, but do not use an abbreviation
    |i_CTRL-O|	CTRL-O {command}  execute {command} and return to Insert mode
de: Einfügemodus verlassen:
    |i_<Esc>|	<Esc>		  Einfügemodus beenden, zurück zum Normalmodus
    |i_CTRL-C|	CTRL-C		  wie <Esc>, aber benutze keine Abkürzung
    |i_CTRL-O|	CTRL-O {Befehl}   führe {Befehl} aus und kehre zum
    					Einfügemodus zurück

en: moving around:
    |i_<Up>|	cursor keys	  move cursor left/right/up/down
    |i_<S-Left>|	shift-left/right  one word left/right
    |i_<S-Up>|	shift-up/down	  one screenful backward/forward
    |i_<End>|	<End>		  cursor after last character in the line
    |i_<Home>|	<Home>		  cursor to first character in the line
    ------------------------------------------------------------------------------
de: Umher bewegen:
    |i_<Up>|	Cursortasten	  bewege Cursor nach links/rechts/oben/unten
    |i_<S-Left>|	Shift-links/rechts ein Wort nach links/rechts
    |i_<S-Up>|	Shift-hoch/runter eine Bildschirmhöhe rückwärts/vorwärts
    |i_<End>|	<Ende>		  Cursor nach letztes Zeichen in der Zeile
    |i_<Home>|	<Pos1>		  Cursor zu erstem Zeichen in der Zeile
    ------------------------------------------------------------------------------

en: *Q_ss*		Special keys in Insert mode
de: *Q_ss*		Spezielle Taste im Einfügemodus

en: |i_CTRL-V|	CTRL-V {char}..	  insert character literally, or enter decimal
    				     byte value
    |i_<NL>|	<NL> or <CR> or CTRL-M or CTRL-J
    				  begin new line
    |i_CTRL-E|	CTRL-E		  insert the character from below the cursor
    |i_CTRL-Y|	CTRL-Y		  insert the character from above the cursor
de: |i_CTRL-V|	CTRL-V {Zeich}..  füge Zeichen wörtlich ein,
    				     oder gebe dezimalen Byte-Wert ein
    |i_<NL>|	<NL> oder <CR> oder CTRL-M oder CTRL-J
    				  beginne neue Zeile
    |i_CTRL-E|	CTRL-E		  füge das Zeichen unterhalb des Cursors ein
    |i_CTRL-Y|	CTRL-Y		  füge das Zeichen oberhalb des Cursors ein

en: |i_CTRL-A|	CTRL-A		  insert previously inserted text
    |i_CTRL-@|	CTRL-@		  insert previously inserted text and stop
    				     Insert mode
    |i_CTRL-R|	CTRL-R {0-9a-z%#:.-="}  insert the contents of a register
de: |i_CTRL-A|	CTRL-A		  füge zuvor eingefügten Text ein
    |i_CTRL-@|	CTRL-@		  füge zuvor eingefügten Text ein und
    				     beende Einfügemodus
    |i_CTRL-R|	CTRL-R {0-0a-z%#:.-="}  füge den Inhalt eines Registers ein

en: |i_CTRL-N|	CTRL-N		  insert next match of identifier before the
    				     cursor
    |i_CTRL-P|	CTRL-P		  insert previous match of identifier before
    				     the cursor
    |i_CTRL-X|	CTRL-X ...	  complete the word before the cursor in
    				     various ways
de: |i_CTRL-N|	CTRL-N		  füge nächste Übereinstimmung des
    				     Identifikators vor dem Cursor ein
    |i_CTRL-P|	CTRL-P		  füge vorige Übereinstimmung des
    				     Identifikators vor dem Cursor ein
    |i_CTRL-X|	CTRL-X ...	  vervollständige das Wort vor dem Cursor auf
    				     verschiedene Weise

en: |i_<BS>|	<BS> or CTRL-H	  delete the character before the cursor
    |i_<Del>|	<Del>		  delete the character under the cursor
    |i_CTRL-W|	CTRL-W		  delete word before the cursor
    |i_CTRL-U|	CTRL-U		  delete all entered characters in the current
    				     line
    |i_CTRL-T|	CTRL-T		  insert one shiftwidth of indent in front of
    				       the current line
    |i_CTRL-D|	CTRL-D		  delete one shiftwidth of indent in front of
    				     the current line
    |i_0_CTRL-D|	0 CTRL-D	  delete all indent in the current line
    |i_^_CTRL-D|	^ CTRL-D	  delete all indent in the current line,
    				     restore indent in next line
    ------------------------------------------------------------------------------
de: |i_<BS>|	<BS> oder CTRL-H  lösche das Zeichen vor dem Cursor
    |i_<Del>|	<Entf>		  lösche das Zeichen unter dem Cursor
    |i_CTRL-W|	CTRL-W		  lösche das Wort vor dem Cursor
    |i_CTRL-U|	CTRL-U		  lösche alle eingegebenen Zeichen in der
    				     aktuellen Zeile
    |i_CTRL-T|	CTRL-T		  füge eine Schaltbreite Einrückung vor der
    				     aktuellen Zeile ein
    |i_CTRL-D|	CTRL-D		  lösche eine Schaltbreite Einrückung vor der
    				     aktuellen Zeile
    |i_0_CTRL-D|	0 CTRL-D	  lösche alle Einrückung in der aktuellen Zeile
    |i_^_CTRL-D|	^ CTRL-D	  lösche alle Einrückung in der aktuellen Zeile,
    				     stelle in der nächsten Zeile wieder her
    ------------------------------------------------------------------------------

en: *Q_di*		Digraphs
de: *Q_di*		Digraphen

en: |:dig|	   :dig[raphs]		show current list of digraphs
    |:dig|	   :dig[raphs] {char1}{char2} {number} ...
    				add digraph(s) to the list
de: |:dig|	   :dig[raphs]		zeige aktuelle Liste von Digraphen
    |:dig|	   :dig[raphs] {Zeich1}{Zeich2} {Nummer} ...
    				füge Digraph(en) zur Liste hinzu

en: In Insert or Command-line mode:
    |i_CTRL-K|	CTRL-K {char1} {char2}
    				  enter digraph
    |i_digraph|	{char1} <BS> {char2}
    				  enter digraph if 'digraph' option set
    ------------------------------------------------------------------------------
de: Im Einfügen- oder Befehlszeilenmodus:
    |i_CTRL-K|	CTRL-K {Zeich1} {Zeich2}
    				  gebe Digraph ein
    |i_digraph|	{Zeich1} <BS> {Zeich2}
    				  gebe Digraph ein, falls Option 'digraph'
    				  gesetzt ist
    ------------------------------------------------------------------------------

en: *Q_si*		Special inserts
de: *Q_si*		Spezielle Eingaben

en: |:r|	   :r [file]	   insert the contents of [file] below the cursor
    |:r!|	   :r! {command}   insert the standard output of {command} below the
    			      cursor
    ------------------------------------------------------------------------------
de: |:r|	   :r [Datei]	 füge den Inhalt von [Datei] unterhalb des Cursors ein
    |:r!|	   :r! {Befehl}  füge die Standardausgabe von {Befehl} unterhalb des
    			      Cursors ein
    ------------------------------------------------------------------------------

en: *Q_de*		Deleting text
de: *Q_de*		Text löschen

en: |x|	N  x		delete N characters under and after the cursor
    |<Del>| N  <Del>	delete N characters under and after the cursor
    |X|	N  X		delete N characters before the cursor
    |d|	N  d{motion}	delete the text that is moved over with {motion}
    |v_d|	{visual}d	delete the highlighted text
    |dd|	N  dd		delete N lines
    |D|	N  D		delete to the end of the line (and N-1 more lines)
    |J|	N  J		join N-1 lines (delete <EOL>s)
    |v_J|	{visual}J	join the highlighted lines
    |gJ|	N  gJ		like "J", but without inserting spaces
    |v_gJ|	{visual}gJ	like "{visual}J", but without inserting spaces
    |:d|	:[range]d [x]	delete [range] lines [into register x]
    ------------------------------------------------------------------------------
de: |x|	N  x		lösche N Zeichen unter und nach dem Cursor
    |<Del>| N  <Entf>	lösche N Zeichen unter und nach dem Cursor
    |X|	N  X		lösche N Zeichen vor dem Cursor
    |d|	N  d{Bewegung}	lösche den Text, über den {Bewegung} streicht
    |v_d|	{visuell}d	lösche den hervorgehobenen Text
    |dd|	N  dd		lösche N Zeilen
    |D|	N  D		lösche zum Zeilenende (und N-1 weitere Zeilen)
    |J|	N  J		füge N-1 Zeilen zusammen (lösche <EOL>s)
    |v_J|	{visuell}J	füge die hervorgehobenen Zeilen zusammen
    |gJ|	N  gJ		wie »J«, aber füge keine Leerzeichen ein
    |v_gJ|	{visuell}	wie »{visuell}J«, aber füge keine Leerzeichen ein
    |:d|	:[Bereich]d [x]	lösche Zeilen in [Bereich] [in Register x]
    ------------------------------------------------------------------------------

en: *Q_cm*		Copying and moving text
de: *Q_cm*		Text kopieren und bewegen

en: |quote|	  "{char}	use register {char} for the next delete, yank, or put
    |:reg|	  :reg		show the contents of all registers
    |:reg|	  :reg {arg}	show the contents of registers mentioned in {arg}
    |y|	  N  y{motion}	yank the text moved over with {motion} into a register
    |v_y|	     {visual}y	yank the highlighted text into a register
    |yy|	  N  yy		yank N lines into a register
    |Y|	  N  Y		yank N lines into a register
    |p|	  N  p		put a register after the cursor position (N times)
    |P|	  N  P		put a register before the cursor position (N times)
    |]p|	  N  ]p		like p, but adjust indent to current line
    |[p|	  N  [p		like P, but adjust indent to current line
    |gp|	  N  gp		like p, but leave cursor after the new text
    |gP|	  N  gP		like P, but leave cursor after the new text
    ------------------------------------------------------------------------------
de: |quote|	  "{Zeich}	benutze Register {Zeich} für das nächste Löschen,
    			    Kopieren oder Einfügen
    |:reg|	  :reg		zeige den Inhalt aller Register
    |:reg|	  :reg {Arg}	zeige den Inhalt der in {Arg} genannten Register
    |y|	  N  y{Bewegung} kopiere den mit {Bewegung} überstrichenen Text
    			    in ein Register
    |v_y|	    {visuell}y	kopiere den hervorgehobenen Text in ein Register
    |yy|	  N  yy		kopiere N Zeilen in ein Register
    |Y|	  N  Y		kopiere N Zeilen in ein Register
    |p|	  N  p		füge ein Register nach der Cursorposition ein (N-mal)
    |P|	  N  P		füge ein Register vor der Cursorposition ein (N-mal)
    |]p|	  N  ]p		wie p, aber passe Einrückung der aktuellen Zeile an
    |[p|	  N  [p		wie P, aber passe Einrückung der aktuellen Zeile an
    |gp|	  N  gp		wie p, aber lasse Cursor nach dem neuen Text
    |gP|	  N  gP		wie P, aber lasse Cursor nach dem neuen Text
    ------------------------------------------------------------------------------

en: *Q_ch*		Changing text
de: *Q_ch*		Text ändern

en: |r|	  N  r{char}	replace N characters with {char}
    |gr|	  N  gr{char}	replace N characters without affecting layout
    |R|	  N  R		enter Replace mode (repeat the entered text N times)
    |gR|	  N  gR		enter virtual Replace mode: Like Replace mode but
    			   without affecting layout
    |v_b_r|	  {visual}r{char}
    			in Visual block mode: Replace each char of the
    			   selected text with {char}
de: |r|	  N  r{Zeich}	ersetze N Zeichen durch {Zeich}
    |gr|	  N  gr{Zeich}	ersetze N Zeichen, ohne das Layout zu beeinflussen
    |R|	  N  R		gehe in Ersetzen-Modus (wiederhole den eingegebenen Text
    			   N-mal)
    |gR|	  N  gR		gehe in virtuellen Ersetzen-Modus: wie Ersetzen-Modus,
    			   aber ohne das Layout zu beeinflussen
    |v_b_r|	 {visuell}r{Zeich}
    			im blockweisen visuellen Modus: Ersetze jedes Zeichen
    			   des ausgewählten Textes durch {Zeich}

en: 	(change = delete text and enter Insert mode)
    |c|	  N  c{motion}	change the text that is moved over with {motion}
    |v_c|	     {visual}c	change the highlighted text
    |cc|	  N  cc		change N lines
    |S|	  N  S		change N lines
    |C|	  N  C		change to the end of the line (and N-1 more lines)
    |s|	  N  s		change N characters
    |v_b_c|	     {visual}c	in Visual block mode: Change each of the selected
    			   lines with the entered text
    |v_b_C|	     {visual}C	in Visual block mode: Change each of the selected
    			   lines until end-of-line with the entered text
de: 	(ändere = lösche Text und gehe in Einfügen-Modus)
    |c|	  N  c{Bewegung} ändere den Text, der mit {Bewegung} überstrichen wird
    |v_c|	     {visuell}c	ändere den hervorgehobenen Text
    |cc|	  N  cc		ändere N Zeilen
    |S|	  N  S		ändere N Zeilen
    |C|	  N  C		ändere bis zum Zeilenende (und N-1 weitere Zeilen)
    |s|	  N  s		ändere N Zeichen
    |v_b_c|	     {visuell}c	im blockweisen visuellen Modus: ändere jede der 
    			   ausgewählten Zeilen bis zum Zeilenende in den
    			   eingegebenen Text

en: |~|	  N  ~		switch case for N characters and advance cursor
    |v_~|	     {visual}~	switch case for highlighted text
    |v_u|	     {visual}u	make highlighted text lowercase
    |v_U|	     {visual}U	make highlighted text uppercase
    |g~|	     g~{motion} switch case for the text that is moved over with
    			   {motion}
    |gu|	     gu{motion} make the text that is moved over with {motion}
    			   lowercase
    |gU|	     gU{motion} make the text that is moved over with {motion}
    			   uppercase
    |v_g?|	     {visual}g? perform rot13 encoding on highlighted text
    |g?|	     g?{motion} perform rot13 encoding on the text that is moved over
    			   with {motion}
de: |~|	  N  ~		ändere Groß-/Kleinschreibung für N Zeichen und bewege
    			   Cursor weiter
    |v_~|	     {visuell}~	ändere Groß-/Kleinschreibung für hervorgehobenen Text
    |v_u|	     {visuell}u	ändere hervorgehobenen Text in Kleinschreibung
    |v_U|	     {visuell}U	ändere hervorgehobenen Text in Großschreibung
    |g~|	     g~{Bewegung} ändere Groß-/Kleinschreibung für den mit {Bewegung}
    			   überstrichenen Text
    |gu|	     gu{Bewegung} ändere den mit {Bewegung} überstrichenen Text in
    			   Kleinschreibung
    |gU|	     gU{Bewegung} ändere den mit {Bewegung} überstrichenen Text in
    			   Großschreibung
    |v_g?|	     {visuell}g? führe auf dem hervorgehobenen Text Rot13-Kodierung aus
    |g?|	     g?{Bewegung} führe auf dem von {Bewegung} überstrichenen Text
    			   Rot13-Kodierung aus

en: |CTRL-A| N CTRL-A	add N to the number at or after the cursor |CTRL-X| N CTRL-X	subtract N from the number at or after the cursor
de: |CTRL-A| N CTRL-A	addiere N zur Nummer an oder nach dem Cursor
    |CTRL-X| N CTRL-X	substrahiere N von der Nummer an oder nach dem Cursor

en: |<|	  N  <{motion}	move the lines that are moved over with {motion} one
    			   shiftwidth left
    |<<|	  N  <<		move N lines one shiftwidth left
    |>|	  N  >{motion}	move the lines that are moved over with {motion} one
    			   shiftwidth right
    |>>|	  N  >>		move N lines one shiftwidth right
    |gq|	  N  gq{motion}	format the lines that are moved over with {motion} to
    			   'textwidth' length
    |:ce|	  :[range]ce[nter] [width]
    			center the lines in [range]
    |:le|	  :[range]le[ft] [indent]
    			left-align the lines in [range] (with [indent])
    |:ri|	  :[range]ri[ght] [width]
    			right-align the lines in [range]
    ------------------------------------------------------------------------------
de: |<|	  N  <{Bewegung} bewege die von {Bewegung} überstrichenen Zeilen eine
    			   Schaltbreite nach links
    |<<|	  N  <<		bewege N Zeilen eine Schaltbreite nach links
    |>|	  N  <{Bewegung} bewege die von {Bewegung} überstrichenen Zeilen eine
    			   Schaltbreite nach rechts
    |>>|	  N  >>		bewege N Zeilen eine Schaltbreite nach rechts
    |gq|	  N  gq{Bewegung} formatiere die von {Bewegung} überstrichenen Zeilen
    			   zur Länge 'textwidth'
    |:ce|	  :[Bereich]ce[nter] [Breite]
    			zentriere die Zeile in [Bereich]
    |:le|	  :[Bereich]le[ft] [Einrückung]
    			richte die Zeilen in [Bereich] linksbündig aus
    			   (mit [Einrückung])
    |:ri|	  :[Bereich]ri[ght] [Breite]
    			richte die Zeilen in [Bereich] rechtsbündig aus
    ------------------------------------------------------------------------------

en: *Q_co*		Complex changes
de: *Q_co*		Komplexe Änderungen

en: |!|	   N  !{motion}{command}<CR>
    			filter the lines that are moved over through {command}
    |!!|	   N  !!{command}<CR>
    			filter N lines through {command}
    |v_!|	      {visual}!{command}<CR>
    			filter the highlighted lines through {command}
    |:range!|  :[range]! {command}<CR>
    			filter [range] lines through {command}
    |=|	   N  ={motion}
    			filter the lines that are moved over through 'equalprg'
    |==|	   N  ==	filter N lines through 'equalprg'
    |v_=|	      {visual}=
    			filter the highlighted lines through 'equalprg'
    |:s|	   :[range]s[ubstitute]/{pattern}/{string}/[g][c]
    			substitute {pattern} by {string} in [range] lines;
    			   with [g], replace all occurrences of {pattern};
    			   with [c], confirm each replacement
    |:s|	   :[range]s[ubstitute] [g][c]
    			repeat previous ":s" with new range and options
    |&|	      &		Repeat previous ":s" on current line without options
    |:ret|	   :[range]ret[ab][!] [tabstop]
    			set 'tabstop' to new value and adjust white space
    			   accordingly
    ------------------------------------------------------------------------------
de: |!|	   N  !{Bewegung}{Befehl}<CR>
    			filtere die überstrichenen Zeilen durch {Befehl}
    |!!|	   N  !!{Befehl}<CR>
    			filtere N Zeilen durch {Befehl}
    |v_!|	      {visuell}!{Befehl}<CR>
    			filtere die hervorgehobenen Zeilen durch {Befehl}
    |:range!|  :[Bereich]! {Befehl}<CR>
    			filtere die Zeilen im [Bereich] durch {Befehl}
    |=|	   N  ={Bewegung}
    			filtere die überstrichenen Zeilen durch 'equalprg'
    |==|	   N  ==	filtere N Zeilen durch 'equalprg'
    |v_=|	      {visuell}=
    			filtere die hervorgehobenen Zeilen durch 'equalprg'
    |:s|	   :[Bereich]s[ubstitute]/{Muster}/{Zeichenkette}/[g][c]
    			ersetze im [Bereich] {Muster} durch {Zeichenkette};
    			   mit [g] -- ersetze jedes Vorkommen von {Muster};
    			   mit [c] -- bestätige jede Ersetzung
    |:s|	   :[Bereich]s[ubstitute] [g][c]
    			wiederhole voriges »:s« mit neuem Bereich und Optionen
    |:ret|	   :[Bereich]ret[ab][!] [tabstop]
    			setze 'tabstop' auf neuen Wert und passe Einrückung
    			   entsprechend an
    ------------------------------------------------------------------------------

en: *Q_vi*		Visual mode
de: *Q_vi*		Visueller Modus

en: |visual-index|	list of Visual mode commands.
de: |visual-index|	Liste von Befehlen des visuellen Modus.

en: |v|	   v		start highlighting characters  }  move cursor and use
    |V|	   V		start highlighting linewise    }  operator to affect
    |CTRL-V|   CTRL-V	start highlighting blockwise   }  highlighted text
    |v_o|	   o		exchange cursor position with start of highlighting
    |gv|	   gv		start highlighting on previous visual area
    |v_v|	   v		highlight characters or stop highlighting
    |v_V|	   V		highlight linewise or stop highlighting
    |v_CTRL-V| CTRL-V	highlight blockwise or stop highlighting
    ------------------------------------------------------------------------------
de: |v|	   v		beginne zeichenweises Hervorheben }
    |V|	   V		beginne zeilenweises Hervorheben  }
    |CTRL-V|   CTRL-V	beginne blockweises Hervorheben   }
    			   -> bewegen Sie den Cursor und benutzen Sie einen
    			      Operator, um den hervorgehobenen Text zu
    			      beeinflussen
    |v_o|	   o		vertausche Cursorposition mit Beginn der Hervorhebung
    |gv|	   gv		beginne Hervorhebung mit vorigem visuellen Bereich
    |v_v|	   v		hebe Zeichen hervor oder beende Hervorhebung
    |v_V|	   V		hebe Zeilen hervor oder beende Hervorhebung
    |v_CTRL-V| CTRL-V	hebe blockweise hervor oder beende Hervorhebung
    ------------------------------------------------------------------------------

en: *Q_to*		Text objects (only in Visual mode or after an operator)
de: *Q_to*		Textobjekte (nur im visuellen Modus oder nach einem Operator)

en: |v_aw|	N  aw		Select "a word"
    |v_iw|	N  iw		Select "inner word"
    |v_aW|	N  aW		Select "a |WORD|"
    |v_iW|	N  iW		Select "inner |WORD|"
    |v_as|	N  as		Select "a sentence"
    |v_is|	N  is		Select "inner sentence"
    |v_ap|	N  ap		Select "a paragraph"
    |v_ip|	N  ip		Select "inner paragraph"
    |v_ab|	N  ab		Select "a block" (from "[(" to "])")
    |v_ib|	N  ib		Select "inner block" (from "[(" to "])")
    |v_aB|	N  aB		Select "a Block" (from "[{" to "]}")
    |v_iB|	N  iB		Select "inner Block" (from "[{" to "]}")
    ------------------------------------------------------------------------------
de: |v_aw|	N  aw		Wähle »ein (a) Wort«
    |v_iw|	N  iw		Wähle »inneres Wort«
    |v_aW|	N  aW		Wähle »ein (a) |WORT|«
    |v_iW|	N  iW		Wähle »inneres |WORT|«
    |v_as|	N  as		Wähle »einen (a) Satz«
    |v_is|	N  is		Wähle »inneren Satz«
    |v_ap|	N  ap		Wähle »einen Absatz (a paragraph)«
    |v_ip|	N  ip		Wähle »inneren Absatz (paragraph)«
    |v_ab|	N  ab		Wähle »einen (a) Block« (von »[(« bis »])«)
    |v_ib|	N  ib		Wähle »inneren Block« (von »[(« bis »])«)
    |v_aB|	N  aB		Wähle »einen (a) Block« (von »[{« bis »]})«
    |v_iB|	N  iB		Wähle »inneren Block« (von »[{« bis »]})«
    ------------------------------------------------------------------------------

en: *Q_re*		Repeating commands
de: *Q_re*		Befehle wiederholen

en: |.|	   N  .		repeat last change (with count replaced with N)
    |q|	      q{a-z}	record typed characters into register {a-z}
    |q|	      q{A-Z}	record typed characters, appended to register {a-z}
    |q|	      q		stop recording
    |@|	   N  @{a-z}	execute the contents of register {a-z} (N times)
    |@@|	   N  @@	   repeat previous @{a-z} (N times)
    |:@|	   :@{a-z}	execute the contents of register {a-z} as an Ex
    			   command
    |:@@|	   :@@		repeat previous :@{a-z}
    |:g|	   :[range]g[lobal]/{pattern}/[cmd]
    			Execute Ex command [cmd] (default: ":p") on the lines
    			   within [range] where {pattern} matches.
    |:g|	   :[range]g[lobal]!/{pattern}/[cmd]
    			Execute Ex command [cmd] (default: ":p") on the lines
    			   within [range] where {pattern} does NOT match.
    |:so|	   :so[urce] {file}
    			Read Ex commands from {file}.
    |:so|	   :so[urce]! {file}
    			Read Vim commands from {file}.
    |:sl|	   :sl[eep] [sec]
    			don't do anything for [sec] seconds
    |gs|	   N  gs	Goto Sleep for N seconds
    ------------------------------------------------------------------------------
de: |.|	   N  .		wiederhole letzte Änderung (mit durch N ersetzter
    			   Anzahl)
    |q|	      q{a-z}	zeichne getippte Zeichen nach Register {a-z} auf
    |q|	      q{A-Z}	zeichne getippte Zeichen auf, angehängt an
    			   Register {a-z}
    |q|	      q		beende Aufzeichnen
    |@|	   N  @{a-z}	führe den Inhalt von Register {a-z} (N-mal) aus
    |@@|	   N  @@	   wiederhole voriges @{a-z} (N-mal)
    |:@|	   :@{a-z}	führe den Inhalt von Register {a-z} als Ex-Befehl aus
    |:@@|	   :@@		wiederhole voriges :@{a-z}
    |:g|	   :[Bereich]g[lobal]/{Muster}/[Befehl]
    			führe Ex-[Befehl] aus (Voreinstellung: »:p«) auf den
    			   Zeilen in [Bereich] wo {Muster} passt
    |:g|	   :[Bereich]g[lobal]!/{Muster}/[Befehl]
    			führe Ex-[Befehl] aus (Voreinstellung: »:p«) auf den
    			   Zeilen in [Bereich] wo {Muster} NICHT passt
    |:so|	   :so[urce] {Datei}
    			Lese Ex-Befehle aus {Datei}
    |:so|	   :so[urce]! {Datei}
    			Lese Vim-Befehle aus {Datei}
    |:sl|	   :sl[eep] [sek]
    			tue nichts für [sek] Sekunden
    |gs|	   N  gs	gehe für N Sekunden schlafen
    ------------------------------------------------------------------------------

en: *Q_km*		Key mapping
de: *Q_km*		Tasten belegen

en: |:map|	     :ma[p] {lhs} {rhs}	  Map {lhs} to {rhs} in Normal and Visual
    				     mode.
    |:map!|	     :ma[p]! {lhs} {rhs}  Map {lhs} to {rhs} in Insert and Command-line
    				     mode.
    |:noremap|   :no[remap][!] {lhs} {rhs}
    				  Same as ":map", no remapping for this {rhs}
    |:unmap|     :unm[ap] {lhs}	  Remove the mapping of {lhs} for Normal and
    				     Visual mode.
    |:unmap!|    :unm[ap]! {lhs}	  Remove the mapping of {lhs} for Insert and
    				     Command-line mode.
    |:map_l|     :ma[p] [lhs]	  List mappings (starting with [lhs]) for
    				     Normal and Visual mode.
    |:map_l!|    :ma[p]! [lhs]	  List mappings (starting with [lhs]) for
    				     Insert and Command-line mode.
    |:cmap|	     :cmap/:cunmap/:cnoremap
    				  like ":map!"/":unmap!"/":noremap!" but for
    				     Command-line mode only
    |:imap|	     :imap/:iunmap/:inoremap
    				  like ":map!"/":unmap!"/":noremap!" but for
    				     Insert mode only
    |:nmap|	     :nmap/:nunmap/:nnoremap
    				  like ":map"/":unmap"/":noremap" but for
    				     Normal mode only
    |:vmap|	     :vmap/:vunmap/:vnoremap
    				  like ":map"/":unmap"/":noremap" but for
    				     Visual mode only
    |:omap|	     :omap/:ounmap/:onoremap
    				  like ":map"/":unmap"/":noremap" but only for
    				     when an operator is pending
    |:mapc|      :mapc[lear]	  remove mappings for Normal and Visual mode
    |:mapc|      :mapc[lear]!	  remove mappings for Insert and Cmdline mode
    |:imapc|     :imapc[lear]	  remove mappings for Insert mode
    |:vmapc|     :vmapc[lear]	  remove mappings for Visual mode
    |:omapc|     :omapc[lear]	  remove mappings for Operator-pending mode
    |:nmapc|     :nmapc[lear]	  remove mappings for Normal mode
    |:cmapc|     :cmapc[lear]	  remove mappings for Cmdline mode
    |:mkexrc|    :mk[exrc][!] [file]  write current mappings, abbreviations, and
    				     settings to [file] (default: ".exrc";
    				     use ! to overwrite)
    |:mkvimrc|   :mkv[imrc][!] [file]
    				  same as ":mkexrc", but with default ".vimrc"
    |:mksession| :mks[ession][!] [file]
    				  like ":mkvimrc", but store current files,
    				     windows, etc. too, to be able to continue
    				     this session later.
    ------------------------------------------------------------------------------
de: |:map|	     :ma[p] {lhs} {rhs}	  belege {lhs} mit {rhs} im normalen und
    				    visuellen Modus
    |:map!|	     :ma[p]! {lhs} {rhs}  belege {lhs} mit {rhs} im Einfüge- und
    				    Befehlszeilen-Modus
    |:noremap|   :no[remap][!] {lhs} {rhs}
    				  Dasselbe wie »:map«, ohne Neubelegen von {rhs}
    |:unmap|     :unm[ap] {lhs}	  entferne Belegung von {lhs} für normalen und
    				    visuellen Modus
    |:unmap!|    :unm[ap]! {lhs}	  entferne Belegung von {lhs} für Einfüge- und
    				    Befehlszeilen-Modus
    |:map_l|     :ma[p] [lhs]	  liste Belegungen für normalen und visuellen
    				    Modus auf (die mit [lhs] beginnen)
    |:map_l!|    :ma[p]! [lhs]	  liste Belegungen für Einfüge- und
    				    Befehlszeilen-Modus auf (die mit [lhs]
    				    beginnen)
    |:cmap|	     :cmap/:cunmap/:cnoremap
    				  wie »:map!«/»:unmap!«/»:noremap!«, aber nur
    				    für Befehlszeilen-Modus
    |:imap|	     :imap/:iunmap/:inoremap
    				  wie »:map!«/»:unmap!«/»:noremap!«, aber nur
    				    für Einfüge-Modus
    |:nmap|	     :nmap/:nunmap/:nnoremap
    				  wie »:map«/»:unmap«/»:noremap«, aber nur für
    				    normalen Modus
    |:vmap|	     :vmap/:vunmap/:vnoremap
    				  wie »:map«/»:unmap«/»:noremap«, aber nur für
    				    visuellen Modus
    |:omap|	     :omap/:ounmap/:onoremap
    				  wie »:map«/»:unmap«/»:noremap«, aber nur wenn
    				    ein Operator hängt
    |:mapc|      :mapc[lear]	  entferne Belegungen für normalen und
    				    visuellen Modus
    |:mapc|      :mapc[lear]!	  entferne Belegungen für Einfüge- und
    				    Befehlszeilen-Modus
    |:imapc|     :imapc[lear]	  entferne Belegungen für Einfüge-Modus
    |:vmapc|     :vmapc[lear]	  entferne Belegungen für visuellen Modus
    |:omapc|     :omapc[lear]	  entferne Belegungen für Operator-Modus
    |:nmapc|     :nmapc[lear]	  entferne Belegungen für normalen Modus
    |:cmapc|     :cmapc[lear]	  entferne Belegungen für Befehlszeilen-Modus
    |:mkexrc|    :mk[exrc][!] [Datei]  schreibe aktuelle Belegungen, Abkürzungen
    				    und Einstellungen in [Datei]
    				    (Voreinstellung: ».exrc«; benutzen Sie »!«
    				    zum Überschreiben)
    |:mkvimrc|   :mkv[imrc][!] [Datei]
    				  dasselbe wie »:mkexrc«, aber mit
    				    Voreinstellung ».vimrc«
    |:mksession| :mks[ession][!] [Datei]
    				  wie »:mkvimrc«, aber speichere auch aktuelle
    				    Dateien, Fenster, usw., um diese Sitzung
    				    später wieder aufnehmen zu können
    ------------------------------------------------------------------------------

en: *Q_ab*		Abbreviations
de: *Q_ab*		Abkürzungen

en: |:abbreviate|	:ab[breviate] {lhs} {rhs}  add abbreviation for {lhs} to {rhs}
    |:abbreviate|	:ab[breviate] {lhs}	   show abbr's that start with {lhs}
    |:abbreviate|	:ab[breviate]		   show all abbreviations
    |:unabbreviate|	:una[bbreviate] {lhs}	   remove abbreviation for {lhs}
    |:noreabbrev|	:norea[bbrev] [lhs] [rhs]  like ":ab", but don't remap [rhs]
    |:iabbrev|	:iab/:iunab/:inoreab	   like ":ab", but only for Insert mode
    |:cabbrev|	:cab/:cunab/:cnoreab	   like ":ab", but only for
    						Command-line mode
    |:abclear|	:abc[lear]		   remove all abbreviations
    |:cabclear|	:cabc[lear]		   remove all abbr's for Cmdline mode
    |:iabclear|	:iabc[lear]		   remove all abbr's for Insert mode
    ------------------------------------------------------------------------------
de: |:abbreviate|	:ab[breviate] {lhs} {rhs}  füge Abkürzung für {lhs} in {rhs}
    					     hinzu
    |:abbreviate|	:ab[breviate] {lhs}	   Zeige Abkürzungen, die mit {lhs}
    					     beginnen
    |:abbrevialte|	:ab[breviate]		   Zeige alle Abkürzungen
    |:noreabbrev|	:norea[bbrev] [lhs] [rhs]  wie »:ab«, aber belege [rhs]
    					     nicht neu
    |:iabbrev|	:iab/:iunab/:inoreab	   wie »:ab«, aber nur für
    					     Einfüge-Modus
    |:cabbrev|	:cab/:cunab/:cnoreab	   wie »:ab«, aber nur für
    					     Befehlszeilen-Modus
    |:abclear|	:abc[lear]		   entferne alle Abkürzungen
    |:cabclear|	:cabc[lear]		   entferne alle Abkürzungen für
    					     Befehlszeilen-Modus
    |:iabclear|	:iabc[lear]		   entferne alle Abkürzungen für
    					     Einfüge-Modus
    ------------------------------------------------------------------------------

en: *Q_op*		Options
de: *Q_op*		Optionen

en: |:set|		:se[t]			  Show all modified options.
    |:set|		:se[t] all		  Show all non-termcap options.
    |:set|		:se[t] termcap		  Show all termcap options.
    |:set|		:se[t] {option}		  Set boolean option (switch it on),
    					  show string or number option.
    |:set|		:se[t] no{option}	  Reset boolean option (switch it off).
    |:set|		:se[t] inv{option}	  invert boolean option.
    |:set|		:se[t] {option}={value}	  Set string/number option to {value}.
    |:set|		:se[t] {option}+={value}  append {value} to string option, add
    					  {value} to number option
    |:set|		:se[t] {option}-={value}  remove {value} to string option,
    					  subtract {value} from number option
    |:set|		:se[t] {option}?	  Show value of {option}.
    |:set|		:se[t] {option}&	  Reset {option} to its default value.
de: |:set|		:se[t]			  zeige alle modifizierten Optionen
    |:set|		:se[t] all		  zeige alle nicht-termcap-Optionen
    |:set|		:se[t] termcap		  zeige alle termcap-Optionen
    |:set|		:se[t] {Option}		  setze boolesche Option (schalte sie
    					  ein), zeige Zeichenketten- oder
    					  Nummern-Option
    |:set|		:se[t] no{Option}	  Lösche boolesche Option (schalte sie
    					  aus)
    |:set|		:se[t] inv{Option}	  invertiere boolesche Option
    |:set|		:se[t] {Option}={Wert}	  Setze Zeichenketten-/Nummern-Option
    					  auf {Wert}
    |:set|		:se[t] {Option}+={Wert}   hänge {Wert} an Zeichenketten-Option
    					  an, addiere {Wert} zu Nummern-Option
    |:set|		:se[t] {Option}-={Wert}   entferne {Wert} aus Zeichenketten-
    					  Option, ziehe {Wert} von Nummern-
    					  Option ab
    |:set|		:se[t] {Option}?	  zeige Wert von {Option} an
    |:set|		:se[t] {Option}&	  setze {Option} auf Voreinstellung

en: |:setlocal|	:setl[ocal]		  like ":set" but set the local value
    					  for options that have one
    |:setglobal|	:setg[lobal]		  like ":set" but set the global value
    					  of a local option
de: |:setlocal|	:setl[ocal]		  wie »:set«, aber setze den lokalen
    					  Wert für Optionen, die einen haben
    |:setglobal|	:setg[lobal]		  wie »:set«, aber setze den globalen
    					  Wert einer lokalen Option

en: |:fix|		:fix[del]		  Set value of 't_kD' according to
    					  value of 't_kb'.
    |:options|	:opt[ions]		  Open a new window to view and set
    					  options, grouped by functionality,
    					  a one line explanation and links to
    					  the help.
de: |:fix|		:fix[del]		  setze Wert von 't_kD' entsprechend
    					  Wert von 't_kb'
    |:options|	:opt[ions]		  öffne ein neues Fenster zum
    					  Betrachten und Setzen von Optionen,
    					  gruppiert nach Funktionalität, mit
    					  einzeiliger Erklärung und Verweisen
    					  in die Hilfe

en: *Q_ur*		Undo/Redo commands
de: *Q_ur*		Undo/Redo-Befehle

en: |u|	  N  u		undo last N changes
    |CTRL-R|  N  CTRL-R	redo last N undone changes
    |U|	     U		restore last changed line
    ------------------------------------------------------------------------------
de: |u|	  N  u		nehme letzte N Änderungen zurück
    |CTRL-R|  N  CTRL-R	stelle letzte N zurückgenommene Änderungen wieder her
    |U|	     U		stelle zuletzt geänderte Zeile wieder her
    ------------------------------------------------------------------------------

en: *Q_et*		External commands
de: *Q_et*		Externe Befehle

en: |:shell|	:sh[ell]	start a shell
    |:!|		:!{command}	execute {command} with a shell
    |K|		   K		lookup keyword under the cursor with
    				   'keywordprg' program (default: "man")
    ------------------------------------------------------------------------------
de: |:shell|	:sh[ell]	starte eine Shell
    |:!|		:!{Befehl}	führe {Befehl} in einer Shell aus
    |K|		   K		schlage Schlüsselwort unter dem Cursor mit dem
    				   Programm in 'keywordprg' nach
    				   (Voreinstellung: »man«)
    ------------------------------------------------------------------------------

en: *Q_qf*		Quickfix commands
de: *Q_qf*		Quickfix-Befehle

en: |:cc|		:cc [nr]	display error [nr] (default is the same again)
    |:cnext|	:cn		display the next error
    |:cprevious|	:cp		display the previous error
    |:clist|	:cl		list all errors
    |:cfile|	:cf		read errors from the file 'errorfile'
    |:cgetbuffer|	:cgetb		like :cbuffer but don't jump to the first error
    |:cgetfile|	:cg		like :cfile but don't jump to the first error
    |:cgetexpr|	:cgete		like :cexpr but don't jump to the first error
    |:caddfile|	:caddf		add errors from the error file to the current
    				   quickfix list
    |:caddexpr|	:cad		add errors from an expression to the current
    				   quickfix list
    |:cbuffer|	:cb		read errors from text in a buffer
    |:cexpr|	:cex		read errors from an expression
    |:cquit|	:cq		quit without writing and return error code (to
    				   the compiler)
    |:make|		:make [args]	start make, read errors, and jump to first
    				   error
    |:grep|		:gr[ep] [args]	execute 'grepprg' to find matches and jump to
    				   the first one.
    ------------------------------------------------------------------------------
de: |:cc|		:cc [nr]	zeige Fehler [nr] (Voreinstellung ist nochmal
    				   derselbe)
    |:cnext|	:cn		zeige den nächsten Fehler
    |:cprevious|	:cp		zeige den vorigen Fehler
    |:clist|	:cl		liste alle Fehler auf
    |:cfile|	:cf		lese Fehler auf der Datei in 'errorfile'
    |:cgetbuffer|	:cgetb		wie :cbuffer, springt aber nicht auf den ersten
    				   Fehler
    |:cgetfile|	:cg		wie :cfile, springt aber nicht auf den ersten
    				   Fehler
    |:cgetexpr|	:cgete		wie :cexpr, springt aber nicht auf den ersten
    				   Fehler
    |:caddfile|	:caddf		füge Fehler aus der Fehlerdatei der aktuellen
    				   Quickfix-Liste hinzu
    |:caddexpr|	:cad		füge Fehler von einem Ausdruck der aktuellen
    				   Quickfix-Liste hinzu
    |:cbuffer|	:cb		lese Fehler von Text in einem Puffer
    |:cexpr|	:cex		lese Fehler von einem Ausdruck
    |:cquit|	:cq		ohne Schreiben beenden und einen Fehlerkode (an
    				   den Compiler) zurückgeben
    |:make|		:make [args]	make starten, Fehler lesen und zum ersten
    				   Fehler springen
    |:grep|		:gr[ep] [args]	führe Programm in 'grepprg' aus, um
    				   Übereinstimmungen zu finden und zur ersten
    				   zu springen
    ------------------------------------------------------------------------------

en: *Q_vc*		Various commands
de: *Q_vc*		Verschiedene Befehle

en: |CTRL-L|	   CTRL-L	Clear and redraw the screen.
    |CTRL-G|	   CTRL-G	show current file name (with path) and cursor
    				   position
    |ga|		   ga		show ascii value of character under cursor in
    				   decimal, hex, and octal
    |g8|		   g8		for utf-8 encoding: show byte sequence for
    				   character under cursor in hex.
    |g_CTRL-G|	   g CTRL-G	show cursor column, line, and character
    				   position
    |CTRL-C|	   CTRL-C	during searches: Interrupt the search
    |dos-CTRL-Break|   CTRL-Break	MS-DOS: during searches: Interrupt the search
    |<Del>|		   <Del>	while entering a count: delete last character
    |:version|	:ve[rsion]	show version information
    |:mode|		:mode N		MS-DOS: set screen mode to N (number, C80,
    				   C4350, etc.)
    |:normal|	:norm[al][!] {commands}
    				Execute Normal mode commands.
    |Q|		Q		switch to "Ex" mode
de: |CTRL-L|	   CTRL-L	Bildschirm löschen und neuzeichnen
    |CTRL-G|	   CTRL-G	Zeige aktuellen Dateinamen (mit Pfad)
    				   und Cursor-Position
    |ga|		   ga		Zeige ASCII-Wert des Zeichens unter dem Cursor
    				   dezimal, hexadezimal und oktal
    |g8|		   g8		für UTF-8 Kodierung: zeige Byte-Sequenz des
    				   Zeichens unter dem Cursor hexadezimal
    |g_CTRL-G|	   g CTRL-G	zeige Cursor-Spalte, -Zeile und
    				   Zeichenposition
    |CTRL-C|	   CTRL-C	während Suchen: Unterbreche die Suche
    |dos-CTRL-Break|   CTRL-Break	MS-DOS: während Suchen: Unterbreche die Suche
    |<Del>|		   <Del>	beim Eingeben einer Anzahl: lösche letztes
    				   Zeichen
    |:version|	:ve[rsion]	zeige Versionsinformationen
    |:mode|		:mode N		MS-DOS: setze Bildschirmmodus auf N (Zahl, C80,
    				   C4350, usw.)
    |:normal|	:norm[al][!] {Befehle}
    				Führe Befehle des Normal-Modus aus
    |Q|		Q		schalte in den »Ex«-Modus

en: |:redir|	:redir >{file}		redirect messages to {file}
    |:silent|	:silent[!] {command}	execute {command} silently
    |:confirm|	:confirm {command}	quit, write, etc., asking about
    					unsaved changes or read-only files.
    |:browse|	:browse {command}	open/read/write file, using a
    					file selection dialog
    ------------------------------------------------------------------------------
de: |:redir|	:redir >{Datei}		leite Nachrichten in {Datei} um
    |:silent|	:silent[!] {Befehl}	führe {Befehl} still aus
    |:confirm|	:confirm {Befehl}	beende, schreibe, usw., mit Nachfrage
    					über ungesicherte Änderungen oder
    					nur-lese-Dateien
    |:browse|	:browse {Befehl}	öffne/lese/schreibe Datei unter
    					Benutzung eines Dialogs zur Dateiauswahl
    ------------------------------------------------------------------------------

en: *Q_ce*		Command-line editing
de: *Q_ce*		Editieren der Befehlszeile

en: |c_<Esc>|	<Esc>		   abandon command-line (if 'wildchar' is
    				      <Esc>, type it twice)
de: |c_<Esc>|	<Esc>		   verlasse Befehlszeile (wenn 'wildchar'
    				      <Esc> ist, tippen Sie es zweimal

en: |c_CTRL-V|	CTRL-V {char}	   insert {char} literally
    |c_CTRL-V|	CTRL-V {number}    enter decimal value of character (up to
    				      three digits)
    |c_CTRL-K|	CTRL-K {char1} {char2}
    				   enter digraph (See |Q_di|)
    |c_CTRL-R|	CTRL-R {0-9a-z"%#:-=}
    				   insert the contents of a register
de: |c_CTRL-V|	CTRL-V {Zeich}	   {Zeich} wörtlich einfügen
    |c_CTRL-V|	CTRL-V {Nummer}    dezimalen Wert eines Zeichens einfügen
    				      (bis zu drei Ziffern)
    |c_CTRL-K|	CTRL-K {Zeich1} {Zeich2}
    				   einen Digraphen eingeben (Siehe |Q_di|)
    |c_CTRL-R|	CTRL-R {0-9a-z"%#:-=}
    				   den Inhalt eines Registers einfügen

en: |c_<Left>|	<Left>/<Right>	   cursor left/right
    |c_<S-Left>|	<S-Left>/<S-Right> cursor one word left/right
    |c_CTRL-B|	CTRL-B/CTRL-E	   cursor to beginning/end of command-line
de: |c_<Left>|	<Links>/<Rechts>   Cursor nach links/rechts
    |c_<S-Left>|	<U-Links>/<U-Rechts> Cursor ein Wort nach links/rechts
    |c_CTRL-B|	CTRL-B/CTRL-E	   Cursor auf Anfang/Ende der Befehlszeile

en: |c_<BS>|	<BS>		   delete the character in front of the cursor
    |c_<Del>|	<Del>		   delete the character under the cursor
    |c_CTRL-W|	CTRL-W		   delete the word in front of the cursor
    |c_CTRL-U|	CTRL-U		   remove all characters
de: |c_<BS>|	<BS>		   lösche Zeichen vor dem Cursor
    |c_<Del>|	<Entf>		   lösche Zeichen unter dem Cursor
    |c_CTRL-W|	CTRL-W		   lösche das Wort vor dem Cursor
    |c_CTRL-U|	CTRL-U		   entferne alle Zeichen

en: |c_<Up>|	<Up>/<Down>	   recall older/newer command-line that starts
    				      with current command
    |c_<S-Up>|	<S-Up>/<S-Down>	   recall older/newer command-line from history
    |:history|	:his[tory]	   show older command-lines
de: |c_<Up>|	<Hoch>/<Runter>	   Hole ältere/neuere Befehlszeile, die mit dem
    				      aktuellen Befehl beginnt
    |c_<S-Up>|	<U-Hoch>/<S-Runter> Hole ältere/neuere Befehlszeile aus dem
    				    Verlauf
    |:history|	:his[tory]	   zeige ältere Befehlszeilen

en: Context-sensitive completion on the command-line:
de: Kontext-bezogene Vervollständigung auf der Befehlszeile:

en: |c_wildchar|	'wildchar'  (default: <Tab>)
    				do completion on the pattern in front of the
    				   cursor.  If there are multiple matches,
    				   beep and show the first one; further
    				   'wildchar' will show the next ones.
    |c_CTRL-D|	CTRL-D		list all names that match the pattern in
    				   front of the cursor
    |c_CTRL-A|	CTRL-A		insert all names that match pattern in front
    				   of cursor
    |c_CTRL-L|	CTRL-L		insert longest common part of names that
    				   match pattern
    |c_CTRL-N|	CTRL-N		after 'wildchar' with multiple matches: go
    				   to next match
    |c_CTRL-P|	CTRL-P		after 'wildchar' with multiple matches: go
    				   to previous match
    ------------------------------------------------------------------------------
de: |c_wildchar|	'wildchar'  (Voreinstellung: <Tab>)
    				führe auf dem Muster vor dem Cursor
    				   Vervollständigung aus.  Gib, falls es
    				   mehrere Übereinstimmungen gibt, einen
    				   Signalton aus und zeige erstere; weitere
    				   'wildchar' zeigen die nächsten.
    |c_CTRL-D|	CTRL-D		liste alle Namen auf, die mit
    				   dem Muster vor dem Cursor übereinstimmen
    |c_CTRL-A|	CTRL-A		füge alle Namen ein, die mit dem Muster vor
    				   dem Cursor übereinstimmen
    |c_CTRL-N|	CTRL-N		nach 'wildchar' mit Mehrfachübereinstimmung:
    				   gehe zur nächsten Übereinstimmung
    |c_CTRL-P|	CTRL-P		nach 'wildchar' mit Mehrfachübereinstimmung:
    				   gehe zur vorigen Übereinstimmung
    ------------------------------------------------------------------------------

en: *Q_ra*		Ex ranges
de: *Q_ra*		Ex Bereiche

en: |:range|	,		separates two line numbers
    |:range|	;		idem, set cursor to the first line number
    				before interpreting the second one
de: |:range|	,		trennt zwei Zeilennummern
    |:range|	;		ebenso, setzt den Cursor auf die erste
    				Zeilennummer, bevor die zweite ausgewertet wird

en: |:range|	{number}	an absolute line number |:range|	.		the current line |:range|	$		the last line in the file |:range|	%		equal to 1,$ (the entire file)  |:range|	*		equal to '<,'> (visual area)  |:range|	't		position of mark t |:range|	/{pattern}[/]	the next line where {pattern} matches |:range|	?{pattern}[?]	the previous line where {pattern} matches
de: |:range|	{Nummer}	eine absolute Zeilennummer
    |:range|	$		Die letzte Zeile der Datei
    |:range|	%		gleichbedeutend mit 1,$ (die ganze Datei)
    |:range|	*		gleichbedeutend mit '<,'> (visueller Bereich)
    |:range|	't		Position der Marke t
    |:range|	/{Muster}[/]	die nächste Zeile, auf der {Muster} passt
    |:range|	?{Muster}[?]	die vorige Zeile, auf der {Muster} passt

en: |:range|	+[num]		add [num] to the preceding line number
    				   (default: 1)
    |:range|	-[num]		subtract [num] from the preceding line
    				   number (default: 1)
    ------------------------------------------------------------------------------
de: |:range|	+[Num]		zähle [Num] zu der vorhergehenden Zeilennummer
    				   hinzu (Voreinstellung: 1)
    |:range|	-[Num]		ziehe [Num] von der vorhergehenden Zeilennummer
    				   ab (Voreinstellung: 1)
    ------------------------------------------------------------------------------

en: *Q_ex*		Special Ex characters
de: *Q_ex*		Ex Sonderzeichen

en: |:bar|	    |		separates two commands (not for ":global" and ":!")
    |:quote|    "		begins comment
de: |:bar|	    |		trennt zwei Befehle (nicht bei »:global« und »:!«)
    |:quote|    "		leitet einen Kommentar ein

en: |:_%|	    %		current file name (only where a file name is expected)
    |:_#|	    #[num]	alternate file name [num] (only where a file name is
    			   expected)
    	Note: The next four are typed literally; these are not special keys!
    |:<cword>|  <cword>	word under the cursor (only where a file name is
    			   expected)
    |:<cWORD>|  <cWORD>	WORD under the cursor (only where a file name is
    			   expected) (see |WORD|)
    |:<cfile>|  <cfile>	file name under the cursor (only where a file name is
    			   expected)
    |:<afile>|  <afile>	file name for autocommand (only where a file name is
    			   expected)
    |:<sfile>|  <sfile>	file name of a ":source"d file, within that file (only
    			   where a file name is expected)
de: |:_%|	    %		der aktuelle Dateiname (nur wo ein Dateiname erwartet
    			   wird)
    |:_#|	    #[Num]	alternativer Dateiname [Num] (nur wo ein Dateiname
    			   erwartet wird)
    	Anmerkung: Die nächsten vier werden wörtlich eingeben;
    		   dies sind keine Sondertasten!
    |:<cword>|  <cword>	Wort unter dem Cursor (nur wo ein Dateiname erwartet
    			   wird)
    |:<cWORD>|  <cWORD>	WORT unter dem Cursor (nur wo ein Dateiname erwartet
    			   wird)
    |:<cfile>|  <cfile>	Dateiname unter dem Cursor (nur wo ein Dateiname
    			   erwartet wird)
    |:<afile>|  <afile>	Dateiname bei einem automatischen Befehl (nur wo ein
    			   Dateiname erwartet wird)
    |:<sfile>|  <sfile>	Dateiname einer ge»:source«ten Datei, innerhalb dieser
    			   Datei (nur wo ein Dateiname erwartet wird)

en: 		After "%", "#", "<cfile>", "<sfile>" or "<afile>"
    		|::p|	    :p		full path
    		|::h|	    :h		head (file name removed)
    		|::t|	    :t		tail (file name only)
    		|::r|	    :r		root (extension removed)
    		|::e|	    :e		extension
    		|::s|	    :s/{pat}/{repl}/	substitute {pat} with {repl}
    ------------------------------------------------------------------------------
de: 		Nach »%«, »#«, »<cfile>«, »<sfile>« oder »<afile>«
    		|::p|	    :p		voller Pfad
    		|::h|	    :h		Kopf (head, Dateiname entfernt)
    		|::t|	    :t		Schwanz (tail, nur der Dateiname)
    		|::r|	    :r		Wurzel (root, Erweiterung entfernt)
    		|::e|	    :e		Erweiterung
    		|::s|	    :s/{Muster}/{Ersetzung}/
    					ersetze {Muster} durch {Ersetzung}
    ------------------------------------------------------------------------------

en: *Q_st*		Starting VIM
de: *Q_st*		VIM starten

en: |-vim|	   vim [options]		start editing with an empty buffer
    |-file|	   vim [options] {file} ..	start editing one or more files
    |--|	   vim [options] -		read file from stdin
    |-tag|	   vim [options] -t {tag}	edit the file associated with {tag}
    |-qf|	   vim [options] -q [fname]	start editing in QuickFix mode,
    					   display the first error
de: |-vim|	   vim [Optionen]		Editieren mit einem leeren Puffer
    					    beginnen
    |-file|	   vim [Optionen] {Datei} ...	Editieren mit einer oder mehreren
    					    Dateien beginnen
    |--|	   vim [Optionen] -		Datei von der Standardeingabe lesen
    |-tag|	   vim [Optionen] -t {Tag}	editiere die mit {Tag} verbundene Datei
    |-qf|	   vim [Optionen] -q [FName]	Editieren im QuickFix-Modus beginnen,
    					    den ersten Fehler anzeigen

en: 	Most useful Vim arguments (for full list see |startup-options|)
de: 	Die nützlichsten Vim-Argumente
    	(Für eine vollständige Liste siehe |startup-options|)

en: |-gui|	-g		    start GUI (also allows other options)
de: |-gui|	-g		    GUI starten (erlaubt auch andere Optionen

en: |-+|	+[num]		    put the cursor at line [num] (default: last line)
    |-+c|	+{command}	    execute {command} after loading the file
    |-+/|	+/{pat} {file} ..   put the cursor at the first occurrence of {pat}
    |-v|	-v		    Vi mode, start ex in Normal mode
    |-e|	-e		    Ex mode, start vim in Ex mode
    |-R|	-R		    Read-only mode, implies -n
    |-m|	-m		    modifications not allowed (resets 'write' option)
    |-d|	-d		    diff mode |diff|
    |-b|	-b		    binary mode
    |-l|	-l		    lisp mode
    |-A|	-A		    Arabic mode ('arabic' is set)
    |-F|	-F		    Farsi mode ('fkmap' and 'rightleft' are set)
    |-H|	-H		    Hebrew mode ('hkmap' and 'rightleft' are set)
    |-V|	-V		    Verbose, give informative messages
    |-C|	-C		    Compatible, set the 'compatible' option
    |-N|	-N		    Nocompatible, reset the 'compatible' option
    |-r|	-r		    give list of swap files
    |-r|	-r {file} ..	    recover aborted edit session
    |-n|	-n		    do not create a swap file
    |-o|	-o [num]	    open [num] windows (default: one for each file)
    |-f|	-f		    GUI: foreground process, don't fork
    			    Amiga: do not restart VIM to open a window (for
    				e.g., mail)
    |-s|	-s {scriptin}	    first read commands from the file {scriptin}
    |-w|	-w {scriptout}	    write typed chars to file {scriptout} (append)
    |-W|	-W {scriptout}	    write typed chars to file {scriptout} (overwrite)
    |-T|	-T {terminal}	    set terminal name
    |-d|	-d {device}	    Amiga: open {device} to be used as a console
    |-u|	-u {vimrc}	    read inits from {vimrc} instead of other inits
    |-U|	-U {gvimrc}	    idem, for when starting the GUI
    |-i|	-i {viminfo}	    read info from {viminfo} instead of other files
    |---|	--		    end of options, other arguments are file names
    |--help|    --help	    show list of arguments and exit
    |--version| --version	    show version info and exit
    |--|	-		    Read file from stdin.
    ------------------------------------------------------------------------------
de: |-+|	+[Num]		    setze Cursor auf Zeile [Num] (Voreinstellung:
    				letzte Zeile)
    |-+c|	+{Befehl}	    führe {Befehl} nach Laden der Datei aus
    |-+/|	+/{Muster} {Datei} ... setze Cursor auf erstes Auftreten von {Muster}
    |-v|	-v		    Vi-Modus, starte ex im normalen Modus
    |-e|	-e		    Ex-Modus, starte vim im Ex-Modus
    |-R|	-R		    Nur-Lese-Modus, impliziert -n
    |-m|	-m		    Modifikationen nicht erlaubt (löscht Option 'write')
    |-d|	-d		    Diff-Modus |diff|
    |-b|	-b		    Binär-Modus
    |-l|	-l		    Lisp-Modus
    |-A|	-A		    Arabisch-Modus ('arabic' wird gesetzt)
    |-F|	-F		    Farsi-Modus ('fkmap' und 'rightleft' werden gesetzt)
    |-H|	-H		    Hebräisch-Modus ('hkmap' und 'righleft' werden
    				gesetzt)
    |-V|	-V		    Wortreich, gebe informative Nachrichten
    |-C|	-C		    Kompatibel (zu Vi), setze Option 'compatible'
    |-N|	-N		    Nicht-kompatibel, lösche Option 'compatible'
    |-r|	-r		    liste Auslagerungsdateien auf
    |-r|	-r {Datei} ...	    stelle abgebrochene Sitzung wieder her
    |-n|	-n		    erzeuge keine Auslagerungsdatei
    |-o|	-o [Num]	    öffne [Num] Fenster (Voreinstellung: eines für jede
    				Datei)
    |-f|	-f		    GUI: Vordergrund-Prozess, nicht forken
    			    Amiga: VIM nicht neu starten, um ein Fenster zu
    				öffnen (z.B. für Mail)
    |-s|	-s {ScriptIn}	    lese zuerst die Befehle aus der Datei {ScriptIn}
    |-w|	-w {ScriptOut}	    schreibe getippte Zeichen in Datei {ScriptOut}
    				(anhängend)
    |-W|	-W {ScriptOut}	    schreibe getippte Zeichen in Datei {ScriptOut}
    				(überschreibend)
    |-T|	-T {Terminal}	    setze Namen des Terminals
    |-d|	-d {Gerät}	     Amiga: öffne {Gerät} als zu benutzende Konsole
    |-u|	-u {vimrc}	    lese Einstellungen aus {vimrc} anstelle von anderen
    				Einstellungsdateien
    |-U|	-U {gvimrc}	    ebenso, beim Starten der GUI
    |---|	--		    Ende der Optionen, übrige Argumente sind Dateinamen
    |--help|    --help	    Liste der Argumente zeigen und beenden
    |--version| --version	    Versions-Info zeigen und beenden
    |--|	-		    Datei von der Standardeingabe lesen
    ------------------------------------------------------------------------------

en: *Q_ed*		Editing a file
de: *Q_ed*		Eine Datei editieren

en: 	   Without !: Fail if changes has been made to the current buffer.
    	      With !: Discard any changes to the current buffer.
    |:edit_f|  :e[dit][!] {file}	Edit {file}.
    |:edit|	   :e[dit][!]		Reload the current file.
    |:enew|	   :ene[w][!]		Edit a new, unnamed buffer.
    |:find|    :fin[d][!] {file}	Find {file} in 'path' and edit it.
de: 	      Ohne !: Abbrechen, wenn im aktuellen Puffer Änderungen
    		      vorgenommen wurden.
    	       Mit !: Alle Änderungen im aktuellen Puffer löschen.
    |:edit_f|  :e[dit][!] {Datei}	Editiere {Datei}.
    |:edit|	   :e[dit][!]		Aktuelle Datei erneut laden.
    |:enew|	   :ene[w][!]		Einen neuen, unbenannten Puffer editieren.
    |:find|    :fin[d][!] {Datei}	{Datei} in 'path' finden und editieren.

en: |CTRL-^|   N   CTRL-^		Edit alternate file N (equivalent to ":e #N").
    |gf|	       gf  or ]f	Edit the file whose name is under the cursor
    |:pwd|	   :pwd			Print the current directory name.
    |:cd|	   :cd [path]		Change the current directory to [path].
    |:cd-|	   :cd -		Back to previous current directory.
    |:file|	   :f[ile]		Print the current file name and the cursor
    				   position.
    |:file|	   :f[ile] {name}	Set the current file name to {name}.
    |:files|   :files		Show alternate file names.
    ------------------------------------------------------------------------------
de: |CTRL-^|   N   CTRL-^		Editiere alternative Datei N
    				    (entspricht »:e #N«).
    |gf|	       gf oder ]f	Editiere Datei, deren Namen unter dem Cursor ist
    |:pwd|	   :pwd			gebe Namen des aktuellen Verzeichnis aus
    |:cd|	   :cd [path]		ändere das aktuelle Verzeichnis in [Pfad]
    |:cd-|	   :cd -		gehe zum vorigen aktuellen Verzeichnis zurück
    |:file|	   :f[ile]		gebe aktuellen Dateinamen und die
    				     Cursor-Position aus
    |:file|	   :f[ile] {Name}	setze aktuellen Dateinamen auf {Name}
    |:files|   :files		zeige alternative Dateinamen
    ------------------------------------------------------------------------------

en: *Q_fl*		Using the argument list			|argument-list|
de: *Q_fl*		Die Argumenten-Liste benutzen		|argument-list|

en: |:args|	   :ar[gs]		Print the argument list, with the current file
    				   in "[]".
    |:all|	   :all  or :sall	Open a window for every file in the arg list.
    |:wn|	   :wn[ext][!]		Write file and edit next file.
    |:wn|	   :wn[ext][!] {file}	Write to {file} and edit next file, unless
    				   {file} exists.  With !, overwrite existing
    				   file.
    |:wN|	   :wN[ext][!] [file]	Write file and edit previous file.
de: |:args|	   :ar[gs]		gebe die Argumenten-Liste aus, mit der aktuellen
    				   Datei in »[]«
    |:all|	   :all oder :sall	öffne ein Fenster für jede Datei in der
    				   Argumenten-Liste
    |:wn|	   :wn[ext][!]		schreibe Datei und editiere nächste Datei
    |:wn|	   :wn[ext][!] {Datei}	schreibe in {Datei} und editiere nächste Datei,
    				   außer {Datei} existiert; »!« überschreibt
    				   existierende Datei
    |:wN|	   :wN[ext][!] [Datei]	schreibe Datei und editiere vorige Datei

en: 	     in current window    in new window	~
    |:argument|  :argu[ment] N	  :sar[gument] N	Edit file N
    |:next|	     :n[ext]		  :sn[ext]		Edit next file
    |:next_f|    :n[ext] {arglist}	  :sn[ext] {arglist}	define new arg list
    							   and edit first file
    |:Next|	     :N[ext]		  :sN[ext]		Edit previous file
    |:first|     :fir[st]		  :sfir[st]		Edit first file
    |:last|	     :la[st]		  :sla[st]		Edit last file
    ------------------------------------------------------------------------------
de: 	     im aktuellen Fenster in neuem Fenster	~
    |:argument|  :argu[ment] N	  :sar[gument] N
    |:next|	     :n[ext]		  :sn[ext]		editiere nächste Datei
    |:next_f|    :n[ext] {ArgListe}	  :sn[ext] {ArgListe}	definiere neue Argu-
    							   menten-Liste und
    							   editiere die erste
    							   Datei
    |:Next|	     :N[ext]		  :sN[ext]		editiere vorige Datei
    |:first|     :fir[st]		  :sfir[st]		editiere erste Datei
    |:last|	     :la[st]		  :sla[st]		editiere letzte Datei
    ------------------------------------------------------------------------------

en: *Q_wq*		Writing and quitting
de: *Q_wq*		Schreiben und schließen

en: |:w|	  :[range]w[rite][!]		Write to the current file.
    |:w_f|	  :[range]w[rite] {file}	Write to {file}, unless it already
    					   exists.
    |:w_f|	  :[range]w[rite]! {file}	Write to {file}.  Overwrite an existing
    					   file.
    |:w_a|	  :[range]w[rite][!] >>		Append to the current file.
    |:w_a|	  :[range]w[rite][!] >> {file}	Append to {file}.
    |:w_c|	  :[range]w[rite] !{cmd}	Execute {cmd} with [range] lines as
    					   standard input.
    |:up|	  :[range]up[date][!]		write to current file if modified
    |:wall|	  :wa[ll][!]			write all changed buffers
de: |:w|	  :[Bereich]w[rite][!]		schreibe in die aktuelle Datei
    |:w_f|	  :[Bereich]w[rite] {Datei}	schreibe in {Datei}, außer sie
    					   existiert bereits
    |:w_f|	  :[Bereich]w[rite]! {Datei}	schreibe in {Datei}; überschreibe eine
    					   existierende Datei
    |:w_a|	  :[Bereich]w[rite][!] >>		hänge an aktuelle Datei an
    |:w_a|	  :[Bereich]w[rite][!] >> {Datei}	hänge an {Datei} an
    |:w_c|	  :[Bereich]w[rite] !{Befehl}	führe {Befehl} mit [Bereich] als
    					   Standardeingabe aus
    |:up|	  :[Bereich]up[date][!]		schreibe, wenn modifiziert, in
    					   aktuelle Datei
    |:wall|	  :wa[ll][!]			schreibe alle geänderten Puffer

en: |:q|	  :q[uit]		Quit current buffer, unless changes have been
    				   made.  Exit Vim when there are no other
    				   non-help buffers
    |:q|	  :q[uit]!		Quit current buffer always, discard any
    				   changes.  Exit Vim when there are no other
    				   non-help buffers
    |:qa|	  :qa[ll]		Exit Vim, unless changes have been made.
    |:qa|	  :qa[ll]!		Exit Vim always, discard any changes.
    |:cq|	  :cq			Quit without writing and return error code.
de: |:q|	  :q[uit]		schließe aktuellen Puffer, außer es wurden
    				   Änderungen gemacht; schließe Vim, wenn es
    				   keine anderen Puffer gibt, die nicht eine
    				   Hilfe enthalten
    |:q|	  :q[uit]!		schließe stets aktuellen Puffer; schließe Vim,
    				   wenn es keine anderen Puffer gibt, die nicht
    				   eine Hilfe enthalten
    |:qa|	  :qa[ll]		schließe Vim, außer es wurden Änderungen gemacht
    |:qa|	  :qa[ll]!		schließe Vim stets, verwerfe alle Änderungen
    |:cq|	  :cq			schließen ohne Schreiben unter Rückgabe eines
    				   Fehlerkodes

en: |:wq|	  :wq[!]		Write the current file and exit.
    |:wq|	  :wq[!] {file}		Write to {file} and exit.
    |:xit|	  :x[it][!] [file]	Like ":wq" but write only when changes have
    				   been made
    |ZZ|	     ZZ			Same as ":x".
    |ZQ|	     ZQ			Same as ":q!".
    |:xall|	  :xa[ll][!]  or :wqall[!]
    				Write all changed buffers and exit
de: |:wq|	  :wq[!]		aktuelle Datei schreiben und beenden
    |:wq|	  :wq[!] {Datei}	in {Datei} schreiben und beenden
    |:xit|	  :x[it][!] [Datei]	wie »:wq«, schreibt aber nur, wenn es
    				   Änderungen gibt
    |ZZ|	     ZZ			dasselbe wie »:x«
    |ZQ|	     ZQ			dasselbe wie »:q!«
    |:xall|	  :xa[ll][!] oder :wqall[!]
    				alle geänderten Puffer schreiben und beenden

en: |:stop|	  :st[op][!]		Suspend VIM or start new shell.  If 'aw' option
    				   is set and [!] not given write the buffer.
    |CTRL-Z|     CTRL-Z		Same as ":stop"
    ------------------------------------------------------------------------------
de: |:stop|	  :st[op][!]		VIM suspendieren oder eine neue Shell starten;
    				   falls die Option 'aw' gesetzt und [!] nicht
    				   gegeben ist, schreibe den Puffer
    |CTRL-Z|     CTRL-Z		dasselbe wie »:stop«
    ------------------------------------------------------------------------------

en: *Q_ac*		Automatic Commands
de: *Q_ac*		Automatische Befehle

en: |viminfo-file|	Read registers, marks, history at startup, save when exiting.
de: |viminfo-file|	Register, Markierungen, Befehlsgeschichte beim Starten lesen, beim Beenden sichern

en: |:rviminfo|	:rv[iminfo] [file]	Read info from viminfo file [file] |:rviminfo|	:rv[iminfo]! [file]	idem, overwrite existing info |:wviminfo|	:wv[iminfo] [file]	Add info to viminfo file [file] |:wviminfo|	:wv[iminfo]! [file]	Write info to viminfo file [file]
de: |:rviminfo|	:rv[iminfo] [Datei]	Lese Info aus VimInfo-Datei [Datei]
    |:rviminfo|	:rv[iminfo]! [Datei]	ebenso, überschreibe bestehende Info
    |:wviminfo|	:wv[iminfo] [Datei]	füge Info zu VimInfo-Datei [Datei] hinzu
    |:wviminfo|	:wv[iminfo]! [Datei]	schreibe Info in VimInfo-Datei [Datei]

en: |modeline|	Automatic option setting when editing a file
de: |modeline|	automatisches Setzen von Optionen beim Editieren einer Datei

en: |modeline|	vim:{set-arg}: ..	In the first and last lines of the
    					file (see 'ml' option), {set-arg} is
    					given as an argument to ":set"
de: |modeline|	vim:{set-arg}: ...	in den ersten und letzten Zeilen (siehe
    					Option 'ml') der Datei wird {set-arg}
    					als ein Argument an »:set« gegeben

en: |autocommand|	Automatic execution of commands on certain events.
de: |autocommand|	automatische Ausführung von Befehlen bei bestimmten Ereignissen

en: |:autocmd|	:au			List all autocommands
    |:autocmd|	:au {event}		List all autocommands for {event}
    |:autocmd|	:au {event} {pat}	List all autocommands for {event} with
    					{pat}
    |:autocmd|	:au {event} {pat} {cmd}	Enter new autocommands for {event}
    					with {pat}
    |:autocmd|	:au!			Remove all autocommands
    |:autocmd|	:au! {event}		Remove all autocommands for {event}
    |:autocmd|	:au! * {pat}		Remove all autocommands for {pat}
    |:autocmd|	:au! {event} {pat}	Remove all autocommands for {event}
    					with {pat}
    |:autocmd|	:au! {event} {pat} {cmd}  Remove all autocommands for {event}
    					with {pat} and enter new one
    ------------------------------------------------------------------------------
de: |:autocmd|	:au			liste alle automatischen Befehle auf
    |:autocmd|	:au {Ereignis}		liste alle automatischen Befehle für
    					   {Ereignis} auf
    |:autocmd|	:au {Ereignis} {Muster}	liste alle automatischen Befehle für
    					   {Ereignis} mit dem {Muster} auf
    |:autocmd|	:au {Ereignis} {Muster} {Befehl}
    					gebe neuen automatischen Befehl für
    					   {Ereignis} mit {Muster}
    |:autocmd|	:au!			entferne alle automatischen Befehle
    |:autocmd|	:au! {Ereignis}		entferne alle automatischen Befehle für
    					   {Ereignis}
    |:autocmd|	:au! * {Muster}		entferne alle automatischen Befehle für
    					   {Muster}
    |:autocmd|	:au! {Ereignis} {Muster}
    					entferne alle automatischen Befehle für
    					   {Ereignis} mit {Muster}
    |:autocmd|	:au! {Ereignis} {Muster} {Befehl}
    					entferne alle automatischen Befehle für
    					   {Ereignis} mit {Muster} und gebe
    					   einen neuen
    ------------------------------------------------------------------------------

en: *Q_wi*		Multi-window commands
de: *Q_wi*		Befehle für mehrere Fenster

en: |CTRL-W_s|	CTRL-W s  or  :split	Split window into two parts
    |:split_f|	:split {file}		Split window and edit {file} in one of
    					   them
    |:vsplit|	:vsplit {file}		Same, but split vertically
    |:vertical|	:vertical {cmd}		Make {cmd} split vertically
de: |CTRL-W_s|	CTRL-W s oder :split	Teile Fenster in zwei Hälften
    |:split_f|	:split {Datei}		Teile Fenster und editiere {Datei} in
    					   einer Hälfte
    |:vsplit|	:vsplit {Datei}		dasselbe, aber vertikal teilen
    |:vertical|	:vertical {Befehl}	Lasse {Befehl} vertikal teilen

en: |:sfind|	:sf[ind] {file}		Split window, find {file} in 'path'
    					   and edit it.
    |CTRL-W_]|	CTRL-W ]		Split window and jump to tag under
    					   cursor
    |CTRL-W_f|	CTRL-W f		Split window and edit file name under
    					   the cursor
    |CTRL-W_^|	CTRL-W ^		Split window and edit alternate file
    |CTRL-W_n|	CTRL-W n  or  :new	Create new empty window
    |CTRL-W_q|	CTRL-W q  or  :q[uit]	Quit editing and close window
    |CTRL-W_c|	CTRL-W c  or  :cl[ose]	Make buffer hidden and close window
    |CTRL-W_o|	CTRL-W o  or  :on[ly]	Make current window only one on the
    					   screen
de: |:sfind|	:sf[ind] {Datei}	teile Fenster, finde {Datei} im Pfad in
    					   'path' und editiere sie
    |CTRL-W_]|	CTRL-W ]		teile Fenster und springe zum Tag unter
    					   dem Cursor
    |CTRL-W_f|	CTRL-W f		teile Fenster und editiere Dateinamen
    					   unter dem Cursor
    |CTRL-W_^|	CTRL-W ^		teile Fenster und editiere alternative
    					   Datei
    |CTRL-W_n|	CTRL-W n oder :new	erzeuge neues leeres Fenster
    |CTRL-W_q|	CTRL-W q oder :q[uit]	beende Editieren und schließe Fenster
    |CTRL-W_c|	CTRL-W c oder :cl[ose]	verstecke Puffer und schließe Fenster
    |CTRL-W_o|	CTRL-W o oder :on[ly]	mache aktuelles Fenster zum einzigen
    					   auf dem Bildschirm

en: |CTRL-W_j|	CTRL-W j		Move cursor to window below |CTRL-W_k|	CTRL-W k		Move cursor to window above |CTRL-W_CTRL-W|	CTRL-W CTRL-W		Move cursor to window below (wrap)  |CTRL-W_W|	CTRL-W W		Move cursor to window above (wrap)  |CTRL-W_t|	CTRL-W t		Move cursor to top window |CTRL-W_b|	CTRL-W b		Move cursor to bottom window |CTRL-W_p|	CTRL-W p		Move cursor to previous active window
de: |CTRL-W_j|	CTRL-W j		bewege Cursor ins Fenster unterhalb
    |CTRL-W_k|	CTRL-W k		bewege Cursor ins Fenster oberhalb
    |CTRL-W_CTRL-W|	CTRL-W CTRL-W		bewege Cursor ins Fenster unterhalb
    					   (umbrechen)
    |CTRL-W_W|	CTRL-W W		bewege Cursor ins Fenster oberhalb
    					   (umbrechen)
    |CTRL-W_t|	CTRL-W t		bewege Cursor in oberstes Fenster
    |CTRL-W_b|	CTRL-W b		bewege Cursor in unterstes Fenster
    |CTRL-W_p|	CTRL-W p		bewege Cursor in vorher aktives Fenster

en: |CTRL-W_r|	CTRL-W r		Rotate windows downwards |CTRL-W_R|	CTRL-W R		Rotate windows upwards |CTRL-W_x|	CTRL-W x		Exchange current window with next one
de: |CTRL-W_r|	CTRL-W r		rotiere Fenster nach unten
    |CTRL-W_R|	CTRL-W R		rotiere Fenster nach oben
    |CTRL-W_x|	CTRL-W x		vertausche nächstes und aktuelles
    					   Fenster

en: |CTRL-W_=|	CTRL-W =		Make all windows equal height
    |CTRL-W_-|	CTRL-W -		Decrease current window height
    |CTRL-W_+|	CTRL-W +		Increase current window height
    |CTRL-W__|	CTRL-W _		Set current window height (default:
    					   very high)
    ------------------------------------------------------------------------------
de: |CTRL-W_=|	CTRL-W =		mache alle Fenster gleich hoch
    |CTRL-W_-|	CTRL-W -		verringere Höhe des aktuellen Fensters
    |CTRL-W_+|	CTRL-W +		vergrößere Höhe des aktuellen Fensters
    |CTRL-W__|	CTRL-W _		setze Höhe des aktuellen Fensters
    					   (Voreinstellung: sehr hoch)
    ------------------------------------------------------------------------------

en: *Q_bu*		Buffer list commands
de: *Q_bu*		Pufferlistenbefehle

en: |:buffers|	:buffers or :files	list all known buffer and file names
de: |:buffers|	:buffers oder :files	liste alle bekannten Puffer und
    					   Dateinamen auf

en: |:ball|		:ball	  or  :sball	edit all args/buffers
    |:unhide|	:unhide   or  :sunhide	edit all loaded buffers
de: |:ball|		:ball oder :sball	editiere alle Argumente/Puffer
    |:unhide|	:unhide oder :sunhide	editiere alle geladenen Puffer

en: |:badd|		:badd {fname}		add file name {fname} to the list
    |:bunload|	:bunload[!] [N]		unload buffer [N] from memory
    |:bdelete|	:bdelete[!] [N]		unload buffer [N] and delete it from
    					   the buffer list
de: |:badd|		:badd {Datei}		füge Dateinamen {Datei} zu der Liste
    					   hinzu
    |:bunload|	:bunload[!] [N]		entlade Puffer [N] aus dem Speicher
    |:bdelete|	:bdelete[!] [N]		entlade Puffer [N] und lösche ihn aus
    					   der Pufferliste

en: 	      in current window   in new window	~
    |:buffer|     :[N]buffer [N]	  :[N]sbuffer [N]     to arg/buf N
    |:bnext|      :[N]bnext [N]	  :[N]sbnext [N]      to Nth next arg/buf
    |:bNext|      :[N]bNext [N]	  :[N]sbNext [N]      to Nth previous arg/buf
    |:bprevious|  :[N]bprevious [N]   :[N]sbprevious [N]  to Nth previous arg/buf
    |:bfirst|     :bfirst		  :sbfirst	      to first arg/buf
    |:blast|      :blast		  :sblast	      to last arg/buf
    |:bmodified|  :[N]bmod [N]	  :[N]sbmod [N]	      to Nth modified buf
    ------------------------------------------------------------------------------
de: 	      im aktuellen Fenster in neuem Fenster	~
    |:buffer|     :[N]buffer [N]	  :[N]sbuffer [N]     zu Argument/Puffer N
    |:bnext|      :[N]bnext [N]	  :[N]sbnext [N]      zum N-ten nächsten
    							   Argument/Puffer
    |:bNext|      :[N]bNext [N]	  :[N]sbNext [N]      zum N-ten vorigen
    							   Argument/Puffer
    |:bprevious|  :[N]bprevious [N]   :[N]sbprevious [N]  zum N-ten vorigen
    							   Argument/Puffer
    |:bfirst|     :bfirst		  :sbfirst	      zum ersten Argument/Puffer
    |:blast|      :blast		  :sblast	      zum letzten
    							   Argument/Puffer
    |:bmodified|  :[N]bmod [N]	  :[N]sbmod [N]	      zum N-ten modifizierten
    							   Puffer
    ------------------------------------------------------------------------------

en: *Q_sy*		Syntax Highlighting
de: *Q_sy*		Syntaxhervorhebung

en: |:syn-on|	:syntax on		start using syntax highlighting |:syn-off|	:syntax off		stop using syntax highlighting
de: |:syn-on|	:syntax on		beginne Benutzung von Syntaxhervorhebung
    |:syn-off|	:syntax off		beende Benutzung von Syntaxhervorhebung

en: |:syn-keyword|	:syntax keyword {group-name} {keyword} ..
    					add a syntax keyword item
    |:syn-match|	:syntax match {group-name} {pattern} ...
    					add syntax match item
    |:syn-region|	:syntax region {group-name} {pattern} ...
    					add syntax region item
    |:syn-sync|	:syntax sync [ccomment | lines {N} | ...]
    					tell syntax how to sync
    |:syntax|	:syntax [list]		list current syntax items
    |:syn-clear|	:syntax clear		clear all syntax info
de: |:syn-keyword|	:syntax keyword {Gruppenname} {Schlüsselwort} ...
    					füge ein Syntax-Schlüsselwort-Element
    					   hinzu
    |:syn-match|	:syntax match {Gruppenname} {Muster} ...
    					füge Syntax-Übereinstimmungs-Element
    					   hinzu
    |:syn-region|	:syntax region {Gruppenname} {Muster} ...
    					füge Syntax-Bereichs-Element hinzu
    |:syn-sync|	:syntax sync [ccoment | lines {N} | ... ]
    					sage Syntax, wie synchronisiert werden
    					  soll
    |:syntax|	:syntax [list]		liste aktuelle Syntax-Elemente auf
    |:syn-clear|	:syntax clear		lösche alle Syntax-Info

en: |:highlight|	:highlight clear	clear all highlight info
    |:highlight|	:highlight {group-name} {key}={arg} ..
    					set highlighting for {group-name}
de: |:highlight|	:highlight clear	lösche alle Hervorhebungs-Info
    |:highlight|	:highlight {Gruppenname} {Schlüssel}={Argument} ...
    					setze Hervorhebung für {Gruppenname}

en: |:filetype|	:filetype on		switch on file type detection, without
    					syntax highlighting
    |:filetype|	:filetype plugin indent on
    					switch on file type detection, with
    					automatic indenting and settings
    ------------------------------------------------------------------------------
de: |:filetype|	:filetype on		schalte Dateityperkennung ein, ohne
    					   Syntaxhervorhebung
    |:filetype|	:filetype plugin indent on
    					schalte Dateityperkennung ein, mit
    					  automatischer Einrückung und
    					  Einstellungen
    ------------------------------------------------------------------------------

en: *Q_gu*		GUI commands
de: *Q_qu*		GUI Befehle

en: |:gui|		:gui			UNIX: start the GUI
    |:gui|		:gui {fname} ..		idem, and edit {fname} ..
de: |:gui|		:gui			UNIX: GUI starten
    |:gui|		:gui {Datei} ...	ebenso, und editiere {Datei} ...

en: |:menu|		:menu			list all menus
    |:menu|		:menu {mpath}		list menus starting with {mpath}
    |:menu|		:menu {mpath} {rhs}	add menu {mpath}, giving {lhs}
    |:menu|		:menu {pri} {mpath} {rhs}
    					idem, with priorities {pri}
    |:menu|		:menu ToolBar.{name} {rhs}
    					add toolbar item, giving {lhs}
    |:tmenu|	:tmenu {mpath} {text}	add tooltip to menu {mpath}
    |:unmenu|	:unmenu {mpath}		remove menu {mpath}
    ------------------------------------------------------------------------------
de: |:menu|		:menu			liste alle Menüs auf
    |:menu|		:menu {MPfad}		liste Menüs auf, die mit {MPfad}
    					   beginnen
    |:menu|		:menu {MPfad} {rechteSeite}
    					füge Menü {MPfad} hinzu, {linkeSeite}
    					   gebend
    |:menu|		:menu {Pri} {MPfad} {rechteSeite}
    					ebenso, mit Prioritäten {Pri}
    |:menu|		:menu ToolBar.{Name} {rechteSeite}
    					füge Werkzeugleistenelement hinzu,
    					   {linkeSeite} gebend
    |:tmenu|	:tmenu {MPfad} {Text}	füge Menü {MPfad} eine Textblase hinzu
    |:unmenu|	:unmenu {MPfad}		entferne Menü {MPfad}
    ------------------------------------------------------------------------------

en: *Q_fo*		Folding
de: *Q_fo*		Falten

en: |'foldmethod'|	set foldmethod=manual	manual folding
    		set foldmethod=indent	folding by indent
    		set foldmethod=expr	folding by 'foldexpr'
    		set foldmethod=syntax	folding by syntax regions
    		set foldmethod=marker	folding by 'foldmarkers'
de: |'foldmethod'|	set foldmethod=manual	Falten von Hand
    		set foldmethod=indent	Falten nach Einrückung
    		set foldmethod=expr	Falten nach 'foldexpr'
    		set foldmethod=syntax	Falten nach Syntax-Bereichen
    		set foldmethod=marker	Falten nach 'foldmarkers'

en: |zf|		zf{motion}		operator: Define a fold manually
    |:fold|		:{range}fold		define a fold for {range} lines
    |zd|		zd			delete one fold under the cursor
    |zD|		zD			delete all folds under the cursor
de: |zf|		zf{Bewegung}		Operator: Definiere eine Faltung von
    					   Hand
    |:fold|		:{Bereich}fold		definiere eine Faltung über {Bereich}
    					   Zeilen
    |zd|		zd			lösche eine Faltung unter dem Cursor
    |zD|		zD			lösche alle Faltungen unter dem Cursor

en: |zo|		zo			open one fold under the cursor
    |zO|		zO			open all folds under the cursor
    |zc|		zc			close one fold under the cursor
    |zC|		zC			close all folds under the cursor
de: |zo|		zo			öffne eine Faltung unter dem Cursor
    |zO|		zO			öffne alle Faltungen unter dem Cursor
    |zc|		zc			schließe eine Faltung unter dem Cursor
    |zC|		zC			schließe alle Faltungen unter dem Cursor

en: |zm|		zm			fold more: decrease 'foldlevel'
    |zM|		zM			close all folds: make 'foldlevel' zero
    |zr|		zr			reduce folding: increase 'foldlevel'
    |zR|		zR			open all folds: make 'foldlevel' max.
de: |zm|		zm			mehr falten: setze 'foldlevel' herunter
    |zM|		zM			schließe alle Faltungen: setze
    					   'foldlevel' auf null
    |zr|		zr			reduziere Faltungen: erhöhe 'foldlevel'
    |zR|		zR			öffne alle Faltungen: setze 'foldlevel'
    					   aufs Maximum

en: |zn|		zn			fold none: reset 'foldenable'
    |zN|		zN			fold normal set 'foldenable'
    |zi|		zi			invert 'foldenable'
de: |zn|		zn			nichts falten: lösche 'foldenable'
    |zN|		zN			normal falten: setze 'foldenable'
    |zi|		zi			invertiere 'foldenable'
