# Finnish translation for Vim.
# Copyright (C) 2003-2006 Free Software Foundation, Inc.
# 2007-2016, Flammie Pirinen <flammie@iki.fi>
#
# Jargonia ei ole yritetty suotta kotoperäistää missä teknisempi lainasanasto
# tulee paremmin kyseeseen.
#
# Sanastosta:
# * Fold on sellainen moderneissa ohjelmointi-IDE:issä oleva toiminto, jolla
#   lohko koodia esim. funktio piilotetaan näkymästä: suom. taitos alkup.
#   analogian mukaan
# * source, v. lataa tiedoston, kuten bash-komento source (tai .)
# * dictionary (dict) on vaihtelevasti sanakirja tai tietorakenne
#
msgid ""
msgstr ""
"Project-Id-Version: Vim 7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-08-23 12:27+0200\n"
"PO-Revision-Date: 2016-08-29 11:27+0200\n"
"Last-Translator: Flammie A Pirinen <flammie@iki.fi>\n"
"Language-Team: Finnish <laatu@lokalisointi.org>\n"
"Language: fi\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

msgid "E831: bf_key_init() called with empty password"
msgstr "E831: bf_key_init() tyhjällä salasanalla"

msgid "E820: sizeof(uint32_t) != 4"
msgstr "E820: sizeof(uint32_t) != 4"

msgid "E817: Blowfish big/little endian use wrong"
msgstr "E817: Blowfishin tavujärjestys väärä"

msgid "E818: sha256 test failed"
msgstr "E818: sha256-testi epäonnistui failed"

msgid "E819: Blowfish test failed"
msgstr "E819: Blowfish-testi epäonnistui"

msgid "[Location List]"
msgstr "[Sijaintiluettelo]"

msgid "[Quickfix List]"
msgstr "[Pikakorjausluettelo]"

msgid "E855: Autocommands caused command to abort"
msgstr "E855: Autocommands lopetti komennon"

msgid "E82: Cannot allocate any buffer, exiting..."
msgstr "E82: Mitään puskuria ei voitu varata, lopetetaan..."

msgid "E83: Cannot allocate buffer, using other one..."
msgstr "E83: Puskuria ei voitu varata, käytetään toista..."

msgid "E931: Buffer cannot be registered"
msgstr "E931: Puskuria ei voi rekisteröidä"

msgid "E515: No buffers were unloaded"
msgstr "E515: Puskureita ei vapautettu"

msgid "E516: No buffers were deleted"
msgstr "E516: Puskureita ei poistettu"

msgid "E517: No buffers were wiped out"
msgstr "E517: Puskureita ei pyyhitty"

msgid "1 buffer unloaded"
msgstr "1 puskuri vapautettiin"

#, c-format
msgid "%d buffers unloaded"
msgstr "%d puskuria vapautettiin"

msgid "1 buffer deleted"
msgstr "1 puskuri poistettu"

#, c-format
msgid "%d buffers deleted"
msgstr "%d puskuria poistettu"

msgid "1 buffer wiped out"
msgstr "1 puskuri pyyhitty"

#, c-format
msgid "%d buffers wiped out"
msgstr "%d puskuria pyyhitty"

msgid "E90: Cannot unload last buffer"
msgstr "E90: Ei voi vapauttaa viimeistä puskuria"

msgid "E84: No modified buffer found"
msgstr "E84: Ei muokattuja puskureita"

#. back where we started, didn't find anything.
msgid "E85: There is no listed buffer"
msgstr "E85: Luetteloitua puskuria ei ole"

msgid "E87: Cannot go beyond last buffer"
msgstr "E87: Viimeisen puskurin ohi ei voi edetä"

msgid "E88: Cannot go before first buffer"
msgstr "E88: Ensimmäisen puskurin ohi ei voi edetä"

#, c-format
msgid "E89: No write since last change for buffer %ld (add ! to override)"
msgstr ""
"E89: Puskurin %ld muutoksia ei ole tallennettu (lisää komentoon ! "
"ohittaaksesi)"

msgid "W14: Warning: List of file names overflow"
msgstr "W14: Varoitus: Tiedostonimiluettelon ylivuoto"

#, c-format
msgid "E92: Buffer %ld not found"
msgstr "E92: Puskuria %ld ei löydy"

#, c-format
msgid "E93: More than one match for %s"
msgstr "E93: %s täsmää useampaan kuin yhteen puskuriin"

#, c-format
msgid "E94: No matching buffer for %s"
msgstr "E94: %s ei täsmää yhteenkään puskuriin"

#, c-format
msgid "line %ld"
msgstr "rivi %ld"

msgid "E95: Buffer with this name already exists"
msgstr "E95: Samanniminen puskuri on jo olemassa"

msgid " [Modified]"
msgstr " [Muokattu]"

msgid "[Not edited]"
msgstr "[Muokkaamaton]"

msgid "[New file]"
msgstr "[Uusi tiedosto]"

msgid "[Read errors]"
msgstr "[Lukuvirheitä]"

msgid "[RO]"
msgstr "[Luku]"

msgid "[readonly]"
msgstr "[kirjoitussuojattu]"

#, c-format
msgid "1 line --%d%%--"
msgstr "1 rivi --%d %%--"

#, c-format
msgid "%ld lines --%d%%--"
msgstr "%ld riviä --%d %%--"

#, c-format
msgid "line %ld of %ld --%d%%-- col "
msgstr "rivi %ld/%ld --%d %%-- sarake "

msgid "[No Name]"
msgstr "[Nimetön]"

#. must be a help buffer
msgid "help"
msgstr "ohje"

msgid "[Help]"
msgstr "[Ohje]"

msgid "[Preview]"
msgstr "[Esikatselu]"

# sijainti tiedostossa -indikaattoreja:
# 4 merkkiä sais riittää
msgid "All"
msgstr "Kaik"

msgid "Bot"
msgstr "Loppu"

msgid "Top"
msgstr "Alku"

msgid ""
"\n"
"# Buffer list:\n"
msgstr ""
"\n"
"# Puskuriluettelo:\n"

msgid "[Scratch]"
msgstr "[Raapust]"

msgid ""
"\n"
"--- Signs ---"
msgstr ""
"\n"
"--- Merkit ---"

#, c-format
msgid "Signs for %s:"
msgstr "Merkit kohteelle %s:"

#, c-format
msgid "    line=%ld  id=%d  name=%s"
msgstr "    rivi=%ld  id=%d  nimi=%s"

msgid "E902: Cannot connect to port"
msgstr "E902: Ei voi yhdistää porttiin"

#, c-format
msgid "E917: Cannot use a callback with %s()"
msgstr "E917: Ei voitu käyttää callbackia %s()"

msgid "E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"
msgstr "E912: ei voida käyttää funktioita ch_evalexpr(), ch_sendexpr()"
" raa'an tai nl-kanavan kanssa"

msgid "E906: not an open channel"
msgstr "E906: ei ole avoin kanava"

msgid "E920: _io file requires _name to be set"
msgstr "E920: _io-tiedostolla pitää olla _name asetettu"

msgid "E915: in_io buffer requires in_buf or in_name to be set"
msgstr "E915: in_io-puskurilla pitää olla in_buf tai in_name asetettu"

#, c-format
msgid "E918: buffer must be loaded: %s"
msgstr "E918: puskuria ei voi ladata: %s"

msgid "E821: File is encrypted with unknown method"
msgstr "E821: Tiedoston salaus on tuntematon"

msgid "Warning: Using a weak encryption method; see :help 'cm'"
msgstr "Varoitus: Käytetään heikkoa salausmenetelmää, ks. :help 'cm'"

msgid "Enter encryption key: "
msgstr "Anna salausavain: "

msgid "Enter same key again: "
msgstr "Anna sama avain uudestaan: "

msgid "Keys don't match!"
msgstr "Avaimet eivät täsmää!"

msgid "[crypted]"
msgstr "[salattu]"

#, c-format
msgid "E720: Missing colon in Dictionary: %s"
msgstr "E720: Sanakirjasta puuttuu kaksoispiste: %s"

#, c-format
msgid "E721: Duplicate key in Dictionary: \"%s\""
msgstr "E721: Kaksi samaa avainta sanakirjassa: %s"

#, c-format
msgid "E722: Missing comma in Dictionary: %s"
msgstr "E722: Sanakirjasta puuttuu pilkku: %s"

#, c-format
msgid "E723: Missing end of Dictionary '}': %s"
msgstr "E723: Sanakirjan lopusta puuttuu }: %s"

msgid "extend() argument"
msgstr "extend()-argumentti"

#, c-format
msgid "E737: Key already exists: %s"
msgstr "E737: Avain on jo olemassa: %s"

#, c-format
msgid "E96: Cannot diff more than %ld buffers"
msgstr "E96: Ei voi diffata enempää kuin %ld puskuria"

msgid "E810: Cannot read or write temp files"
msgstr "E810: Ei voi lukea tai kirjoittaa väliaikaistiedostoja"

msgid "E97: Cannot create diffs"
msgstr "E97: Ei voi luoda diffejä"

msgid "Patch file"
msgstr "Patch-tiedosto"

msgid "E816: Cannot read patch output"
msgstr "E816: Ei voi lukea patchin tulostetta"

msgid "E98: Cannot read diff output"
msgstr "E98: Ei voi lukea diffin tulostetta"

msgid "E99: Current buffer is not in diff mode"
msgstr "E99: Tämä puskuri ei ole diff-tilassa"

msgid "E793: No other buffer in diff mode is modifiable"
msgstr "E793: Yksikään muu diff-tilan puskurit ei ole muokattavissa"

msgid "E100: No other buffer in diff mode"
msgstr "E100: Yksikään muu puskuri ei ole diff-tilassa"

msgid "E101: More than two buffers in diff mode, don't know which one to use"
msgstr "E101: Monta puskuria on diff-tilassa, käytettävän valinta ei onnistu"

#, c-format
msgid "E102: Can't find buffer \"%s\""
msgstr "E102: Puskuria %s ei löydy"

#, c-format
msgid "E103: Buffer \"%s\" is not in diff mode"
msgstr "E103: Puskuri %s ei ole diff-tilassa"

msgid "E787: Buffer changed unexpectedly"
msgstr "E787: Puskuri vaihtui odottamatta"

msgid "E104: Escape not allowed in digraph"
msgstr "E104: Escapea ei voi käyttää digraafissa"

msgid "E544: Keymap file not found"
msgstr "E544: Näppäinkarttaa ei löydy"

msgid "E105: Using :loadkeymap not in a sourced file"
msgstr "E105: Käytetään :loadkeymapia ladatun tiedoston ulkopuolella"

msgid "E791: Empty keymap entry"
msgstr "E791: Tyhjä keymap-kenttä"

msgid " Keyword completion (^N^P)"
msgstr " Avainsanatäydennys (^N^P)"

#. ctrl_x_mode == 0, ^P/^N compl.
msgid " ^X mode (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)"
msgstr " ^X-tila (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)"

msgid " Whole line completion (^L^N^P)"
msgstr " Täysrivitäydennys (^L^N^P)"

msgid " File name completion (^F^N^P)"
msgstr " Tiedostonimitäydennys (^F^N^P)"

msgid " Tag completion (^]^N^P)"
msgstr " Tägitäydennys (^]^N^P)"

msgid " Path pattern completion (^N^P)"
msgstr " Polkukuviotäydennys (^N^P)"

msgid " Definition completion (^D^N^P)"
msgstr " Määritelmätäydennys (^D^N^P)"

msgid " Dictionary completion (^K^N^P)"
msgstr " Sanakirjatäydennys (^K^N^P)"

msgid " Thesaurus completion (^T^N^P)"
msgstr " Thesaurus-täydennys (^T^N^P)"

msgid " Command-line completion (^V^N^P)"
msgstr " Komentorivitäydennys (^V^N^P)"

msgid " User defined completion (^U^N^P)"
msgstr " Käyttäjän määrittelemä täydennys (^U^N^P)"

msgid " Omni completion (^O^N^P)"
msgstr " Omnitäydennys (^O^N^P)"

msgid " Spelling suggestion (s^N^P)"
msgstr " Oikaisulukuehdotus (s^N^P)"

msgid " Keyword Local completion (^N^P)"
msgstr " Avainsanan paikallinen täydennys (^N^P)"

msgid "Hit end of paragraph"
msgstr "Kappaleen loppu tuli vastaan"

msgid "E839: Completion function changed window"
msgstr "E839: Täydennys vaihtoi ikkunaa"

msgid "E840: Completion function deleted text"
msgstr "E840: Täydennys poisti tekstiä"

msgid "'dictionary' option is empty"
msgstr "dictionary-asetus on tyhjä"

msgid "'thesaurus' option is empty"
msgstr "thesaurus-asetus on tyhjä"

#, c-format
msgid "Scanning dictionary: %s"
msgstr "Luetaan sanakirjaa: %s"

msgid " (insert) Scroll (^E/^Y)"
msgstr " (syöttö) Vieritys (^E/^Y)"

msgid " (replace) Scroll (^E/^Y)"
msgstr " (korvaus) Vieritys (^E/^Y)"

#, c-format
msgid "Scanning: %s"
msgstr "Luetaan: %s"

msgid "Scanning tags."
msgstr "Luetaan tägejä."

msgid " Adding"
msgstr " Lisätään"

#. showmode might reset the internal line pointers, so it must
#. * be called before line = ml_get(), or when this address is no
#. * longer needed.  -- Acevedo.
#.
msgid "-- Searching..."
msgstr "-- Haetaan..."

msgid "Back at original"
msgstr "Takaisin lähtöpisteessä"

msgid "Word from other line"
msgstr "Sana toisella rivillä"

msgid "The only match"
msgstr "Ainoa täsmäys"

#, c-format
msgid "match %d of %d"
msgstr "täsmäys %d/%d"

#, c-format
msgid "match %d"
msgstr "täsmäys %d"

#. maximum nesting of lists and dicts
msgid "E18: Unexpected characters in :let"
msgstr "E18: Odottamattomia merkkejä komennossa :let"

#, c-format
msgid "E121: Undefined variable: %s"
msgstr "E121: Määrittelemätön muuttuja: %s"

msgid "E111: Missing ']'"
msgstr "E111: ] puuttuu"

msgid "E719: Cannot use [:] with a Dictionary"
msgstr "E719: Sanakirjassa ei voi käyttää merkintää [:]"

#, c-format
msgid "E734: Wrong variable type for %s="
msgstr "E734: Väärä muuttujatyyppi muuttujalle %s="

#, c-format
msgid "E461: Illegal variable name: %s"
msgstr "E461: Virheellinen muuttujanimi: %s"

msgid "E806: using Float as a String"
msgstr "E806: Float ei käy merkkijonosta"

msgid "E687: Less targets than List items"
msgstr "E687: Kohteita on vähemmän kuin listan alkioita"

msgid "E688: More targets than List items"
msgstr "E688: Kohteita on enemmän kuin listan alkioita"

msgid "Double ; in list of variables"
msgstr "Kaksi ;:ttä listan muuttujissa"

#, c-format
msgid "E738: Can't list variables for %s"
msgstr "E738: Kohteen %s muuttujia ei voi listata"

msgid "E689: Can only index a List or Dictionary"
msgstr "E689: Vain listalla ja sanakirjalla voi olla indeksejä"

msgid "E708: [:] must come last"
msgstr "E708: [:]:n pitää olla viimeisenä"

msgid "E709: [:] requires a List value"
msgstr "E709: [:] toimii vain listalla"

msgid "E710: List value has more items than target"
msgstr "E710: Listalla on enemmän alkioita kuin kohteella"

msgid "E711: List value has not enough items"
msgstr "E711: Listalla ei ole tarpeeksi alkioita"

msgid "E690: Missing \"in\" after :for"
msgstr "E690: :for-kommenolta puuttuu in"

#, c-format
msgid "E108: No such variable: \"%s\""
msgstr "E108: Muuttujaa %s ei ole"

msgid "E743: variable nested too deep for (un)lock"
msgstr "E743: muuttujassa liian monta tasoa lukituksen käsittelyyn"

msgid "E109: Missing ':' after '?'"
msgstr "E109: ?:n jälkeen puuttuu :"

msgid "E691: Can only compare List with List"
msgstr "E691: Listaa voi verrata vain listaan"

msgid "E692: Invalid operation for List"
msgstr "E692: Virheellinen toiminto listalle"

msgid "E735: Can only compare Dictionary with Dictionary"
msgstr "E735: Sanakirjaa voi verrata vain sanakirjaan"

msgid "E736: Invalid operation for Dictionary"
msgstr "E736: Virheellinen toiminto sanakirjalle"

msgid "E694: Invalid operation for Funcrefs"
msgstr "E694: Virheellinen toiminto funcrefille"

msgid "E804: Cannot use '%' with Float"
msgstr "E804: Ei voi käyttää '%':a Floatin kanssa"

msgid "E110: Missing ')'"
msgstr "E110: ) puuttuu"

msgid "E695: Cannot index a Funcref"
msgstr "E695: Funcrefiä ei voi indeksoida"

msgid "E909: Cannot index a special variable"
msgstr "E909: erikoismuuttujaa ei voi indeksoida"

#, c-format
msgid "E112: Option name missing: %s"
msgstr "E112: Asetuksen nimi puuttuu: %s"

#, c-format
msgid "E113: Unknown option: %s"
msgstr "E113: Tuntematon asetus: %s"

#, c-format
msgid "E114: Missing quote: %s"
msgstr "E114: Puuttuva lainausmerkki: %s"

#, c-format
msgid "E115: Missing quote: %s"
msgstr "E115: Puuttuva lainausmerkki: %s"

msgid "Not enough memory to set references, garbage collection aborted!"
msgstr "Ei tarpeeksi muistia viitteiden asettamista varten, roskiekeruu "
"peruttiin."

msgid "E724: variable nested too deep for displaying"
msgstr "E724: muuttuja on upotettu liian syvälle näytettäväksi"

msgid "E805: Using a Float as a Number"
msgstr "E805: Float ei käy Numberista"

msgid "E703: Using a Funcref as a Number"
msgstr "E703: Funcref ei käy Numberista"

msgid "E745: Using a List as a Number"
msgstr "E745: Lista ei käy Numberista"

msgid "E728: Using a Dictionary as a Number"
msgstr "E728: Sanakirja ei käy Numberista"

msgid "E910: Using a Job as a Number"
msgstr "E910: Job ei käy Numberista"

msgid "E913: Using a Channel as a Number"
msgstr "E913: Channel ei käy Numberista"

msgid "E891: Using a Funcref as a Float"
msgstr "E891: Funcref ei käy Floatista"

msgid "E892: Using a String as a Float"
msgstr "E892: String ei käy Floatista"

msgid "E893: Using a List as a Float"
msgstr "E893: Lista ei käy Floatista"

msgid "E894: Using a Dictionary as a Float"
msgstr "E894: Sanakirja ei käy Floatista"

msgid "E907: Using a special value as a Float"
msgstr "E907: Käytettiin erikoisarvoa Floattina"

msgid "E911: Using a Job as a Float"
msgstr "E911: Job ei käy Floatista"

msgid "E914: Using a Channel as a Float"
msgstr "E914: Käytettiin Channelia Floattina"

msgid "E729: using Funcref as a String"
msgstr "E729: Funcref ei käy merkkijonosta"

msgid "E730: using List as a String"
msgstr "E730: Lista ei käy merkkijonosta"

msgid "E731: using Dictionary as a String"
msgstr "E731: Sanakirja ei käy merkkijonosta"

msgid "E908: using an invalid value as a String"
msgstr "E908: huono arvo merkkijonolle"

#, c-format
msgid "E795: Cannot delete variable %s"
msgstr "E795: Muuttujaa %s ei voi poistaa"

#, c-format
msgid "E704: Funcref variable name must start with a capital: %s"
msgstr "E704: Funcrefin muuttujanimen pitää alkaa suuraakkosella: %s"

#, c-format
msgid "E705: Variable name conflicts with existing function: %s"
msgstr "E705: Muuttujanimi on sama kuin olemassaolevan funktion: %s"

#, c-format
msgid "E741: Value is locked: %s"
msgstr "E741: Arvo on lukittu: %s"

msgid "Unknown"
msgstr "Tuntematon"

#, c-format
msgid "E742: Cannot change value of %s"
msgstr "E742: Ei voi muuttaa muuttujan %s arvoa"

msgid "E698: variable nested too deep for making a copy"
msgstr "E698: muuttuja on upotettu liian syvälle kopioitavaksi"

msgid ""
"\n"
"# global variables:\n"
msgstr ""
"\n"
"# globaalit muuttujat:\n"

msgid ""
"\n"
"\tLast set from "
msgstr ""
"\n"
"\tViimeksi asetettu kohteesta "

msgid "map() argument"
msgstr "map()-argumentti"

msgid "filter() argument"
msgstr "filter()-argumentti"

#, c-format
msgid "E686: Argument of %s must be a List"
msgstr "E686: Argumentin %s pitää olla lista"

msgid "E928: String required"
msgstr "E928: Merkkijono puuttuu"

msgid "E808: Number or Float required"
msgstr "E808: Number tai Float vaaditaan"

msgid "add() argument"
msgstr "add()-argumentti"

msgid "E785: complete() can only be used in Insert mode"
msgstr "E785: complete() toimii vain syöttötilassa"

#.
#. * Yes this is ugly, I don't particularly like it either.  But doing it
#. * this way has the compelling advantage that translations need not to
#. * be touched at all.  See below what 'ok' and 'ync' are used for.
#.
msgid "&Ok"
msgstr "&Ok"

#, c-format
msgid "+-%s%3ld line: "
msgid_plural "+-%s%3ld lines: "
msgstr[0] "+-%s%3ld rivi: "
msgstr[1] "+-%s%3ld riviä: "

#, c-format
msgid "E700: Unknown function: %s"
msgstr "E700: Tuntematon funktio: %s"

msgid "E922: expected a dict"
msgstr "E922: odotettiin dictiä"

# datarakenteita
msgid "E923: Second argument of function() must be a list or a dict"
msgstr "E923: toisen function()-argumentin pitää olla lista tai sanakirja"

msgid ""
"&OK\n"
"&Cancel"
msgstr ""
"&OK\n"
"&Peru"

msgid "called inputrestore() more often than inputsave()"
msgstr "inputrestore() suoritettu useammin kuin inputsave()"

msgid "insert() argument"
msgstr "insert()-argumentti"

msgid "E786: Range not allowed"
msgstr "E786: Aluetta ei voi käyttää"

msgid "E916: not a valid job"
msgstr "E916: ei ole job"

msgid "E701: Invalid type for len()"
msgstr "E701: Virheellinen tyyppi funktiolle len()"

msgid "E726: Stride is zero"
msgstr "E726: Stride on nolla"

msgid "E727: Start past end"
msgstr "E727: Alku on lopun jälkeen"

msgid "<empty>"
msgstr "<tyhjä>"

msgid "E240: No connection to Vim server"
msgstr "E240: Ei yhteyttä vim-palvelimeen"

#, c-format
msgid "E241: Unable to send to %s"
msgstr "E241: Kohteeseen %s lähettäminen ei onnistunut"

msgid "E277: Unable to read a server reply"
msgstr "E277: Palvelimen vastauksen lukeminen ei onnistunut"

msgid "remove() argument"
msgstr "remove()-argumentti"

msgid "E655: Too many symbolic links (cycle?)"
msgstr "E655: Liikaa symbolisia linkkejä (mahdollinen sykli)"

msgid "reverse() argument"
msgstr "reverse()-argumentti"

msgid "E258: Unable to send to client"
msgstr "E258: Asiakkaalle lähetys ei onnistunut"

#, c-format
msgid "E927: Invalid action: '%s'"
msgstr "E927: Viallinen toiminto: %s"

msgid "sort() argument"
msgstr "sort()-argumentti"

msgid "uniq() argument"
msgstr "uniq()-argumentti"

msgid "E702: Sort compare function failed"
msgstr "E702: Lajittelun vertausfunktio ei onnistunut"

msgid "E882: Uniq compare function failed"
msgstr "E882: Uniqin vertausfunktio ei onnistunut"

msgid "(Invalid)"
msgstr "(Virheellinen)"

#, c-format
msgid "E935: invalid submatch number: %d"
msgstr "E935: Virheellinen alitäsmäyksen numero: %d"

msgid "E677: Error writing temp file"
msgstr "E677: Väliaikaistiedostoon kirjoittaminen ei onnistunut"

msgid "E921: Invalid callback argument"
msgstr "E921: Virheellinen callback-argumentti"

# puhutaan merkin ulkoasusta snprintf(..., c, c, c, c)
#, c-format
msgid "<%s>%s%s  %d,  Hex %02x,  Octal %03o"
msgstr "<%s>%s%s  %d, heksana %02x, oktaalina %03o"

#, c-format
msgid "> %d, Hex %04x, Octal %o"
msgstr "> %d, heksana %04x, oktaalina %o"

#, c-format
msgid "> %d, Hex %08x, Octal %o"
msgstr "> %d, hekdana %08x, oktaalina %o"

msgid "E134: Move lines into themselves"
msgstr "E134: Rivien siirto itsejensä päälle"

msgid "1 line moved"
msgstr "1 rivi siirretty"

#, c-format
msgid "%ld lines moved"
msgstr "%ld riviä siirretty"

#, c-format
msgid "%ld lines filtered"
msgstr "%ld riviä suodatettu"

msgid "E135: *Filter* Autocommands must not change current buffer"
msgstr "E135: *Filter*-autocommand ei voi vaihtaa puskuria"

msgid "[No write since last change]\n"
msgstr "[Viimeisintä muutosta ei ole kirjoitettu]\n"

#, c-format
msgid "%sviminfo: %s in line: "
msgstr "%sviminfo: %s rivillä: "

msgid "E136: viminfo: Too many errors, skipping rest of file"
msgstr "E136: viminfo: liikaa virheitä, ohitetaan lopputiedosto"

#, c-format
msgid "Reading viminfo file \"%s\"%s%s%s"
msgstr "Luetaan viminfo-tiedostoa \"%s\"%s%s%s"

msgid " info"
msgstr " info"

msgid " marks"
msgstr " merkit"

msgid " oldfiles"
msgstr " vanhaatiedostoa"

msgid " FAILED"
msgstr " EPÄONNISTUI"

#. avoid a wait_return for this message, it's annoying
#, c-format
msgid "E137: Viminfo file is not writable: %s"
msgstr "E137: Viminfo-tiedostoon ei voitu kirjoittaa: %s"

#, c-format
msgid "E929: Too many viminfo temp files, like %s!"
msgstr "E929: liikaa viminfo-väliaikaistiedostoja, kuten %s."

#, c-format
msgid "E138: Can't write viminfo file %s!"
msgstr "E138: Viminfo-tiedoston kirjoittaminen ei onnistu %s"

#, c-format
msgid "Writing viminfo file \"%s\""
msgstr "Kirjoitetaan viminfo-tiedostoa %s"

#, c-format
msgid "E886: Can't rename viminfo file to %s!"
msgstr "E886: Viminfo-tiedostoa ei voit uudelleennimetä nimelle %s"

#. Write the info:
#, c-format
msgid "# This viminfo file was generated by Vim %s.\n"
msgstr "# Vimin %s generoima viminfo-tiedosto.\n"

msgid ""
"# You may edit it if you're careful!\n"
"\n"
msgstr ""
"# Muokkaa varovasti!\n"
"\n"

msgid "# Value of 'encoding' when this file was written\n"
msgstr "# encoding-muuttujan arvo tiedostoa kirjoitettaessa\n"

msgid "Illegal starting char"
msgstr "Virheellinen aloitusmerkki"

msgid ""
"\n"
"# Bar lines, copied verbatim:\n"
msgstr ""
"\n"
"# Bar-rivit, kopiotu sellaisenaan:\n"

msgid "Save As"
msgstr "Tallenna nimellä"

msgid "Write partial file?"
msgstr "Kirjoita osittainen tiedosto"

msgid "E140: Use ! to write partial buffer"
msgstr "E140: Käytä !-komentoa osittaisen puskurin kirjoittamiseen"

#, c-format
msgid "Overwrite existing file \"%s\"?"
msgstr "Ylikirjoitetaanko olemassaoleva tiedosto %s?"

#, c-format
msgid "Swap file \"%s\" exists, overwrite anyway?"
msgstr "Swap-tiedosto %s on olemassa, ylikirjoitetaanko?"

#, c-format
msgid "E768: Swap file exists: %s (:silent! overrides)"
msgstr "E768: Swap-tiedosto on jo olemassa: %s (komento :silent! ohittaa)"

#, c-format
msgid "E141: No file name for buffer %ld"
msgstr "E141: Ei tiedostonimeä puskurille %ld"

msgid "E142: File not written: Writing is disabled by 'write' option"
msgstr ""
"E142: Tiedostoa ei kirjoitettu; write-asetus poistaa kirjoituksen käytöstä"

#, c-format
msgid ""
"'readonly' option is set for \"%s\".\n"
"Do you wish to write anyway?"
msgstr ""
"readonly asetettu tiedostolle \"%s\".\n"
"Kirjoitetaanko?"

#, c-format
msgid ""
"File permissions of \"%s\" are read-only.\n"
"It may still be possible to write it.\n"
"Do you wish to try?"
msgstr ""
"Tiedosto %s on kirjoitussuojattu.\n"
"Siihen saattaa voida silti kirjoittaa.\n"
"Yritetäänkö?"

#, c-format
msgid "E505: \"%s\" is read-only (add ! to override)"
msgstr "E505: %s on kirjoitussuojattu (lisää komentoon ! ohittaaksesi)"

msgid "Edit File"
msgstr "Muokkaa tiedostoa"

#, c-format
msgid "E143: Autocommands unexpectedly deleted new buffer %s"
msgstr "E143: Autocommand poisti uuden puskurin odotuksen vastaisesti %s"

msgid "E144: non-numeric argument to :z"
msgstr "E144: :z:n argumentti ei ole numero"

msgid "E145: Shell commands not allowed in rvim"
msgstr "E145: Kuoren komennot eivät toimi rvimissä"

msgid "E146: Regular expressions can't be delimited by letters"
msgstr "E146: Säännöllistä ilmausta ei voi rajata kirjaimilla"

#, c-format
msgid "replace with %s (y/n/a/q/l/^E/^Y)?"
msgstr "korvaa kohteella %s (y/n/a/q/l/^E/^Y)?"

msgid "(Interrupted) "
msgstr "(Keskeytetty)"

msgid "1 match"
msgstr "1 täsmäys"

msgid "1 substitution"
msgstr "1 korvaus"

#, c-format
msgid "%ld matches"
msgstr "%ld täsmäystä"

#, c-format
msgid "%ld substitutions"
msgstr "%ld korvausta"

msgid " on 1 line"
msgstr " 1 rivillä"

#, c-format
msgid " on %ld lines"
msgstr " %ld rivillä"

msgid "E147: Cannot do :global recursive"
msgstr "E147: :globalia ei voi suorittaa rekursiivisesti"

msgid "E148: Regular expression missing from global"
msgstr "E148: Säännöllinen ilmaus puuttuu globaalista"

#, c-format
msgid "Pattern found in every line: %s"
msgstr "Kuvio löytyi joka riviltä: %s"

#, c-format
msgid "Pattern not found: %s"
msgstr "Kuviota ei löydy: %s"

msgid ""
"\n"
"# Last Substitute String:\n"
"$"
msgstr ""
"\n"
"# Viimeisin korvausmerkkijono:\n"
"$"

msgid "E478: Don't panic!"
msgstr "E478: Älä panikoi."

#, c-format
msgid "E661: Sorry, no '%s' help for %s"
msgstr "E661: ei löydy %s-ohjetta kohteelle %s"

#, c-format
msgid "E149: Sorry, no help for %s"
msgstr "E149: ei löydy ohjetta kohteelle %s"

#, c-format
msgid "Sorry, help file \"%s\" not found"
msgstr "ohjetiedostoa %s ei löydy"

#, c-format
msgid "E152: Cannot open %s for writing"
msgstr "E152: Ei voi avata tiedostoa %s kirjoittamista varten"

#, c-format
msgid "E153: Unable to open %s for reading"
msgstr "E153: Ei voi avata tiedostoa %s lukemista varten"

#, c-format
msgid "E670: Mix of help file encodings within a language: %s"
msgstr "E670: Monia ohjetiedostokoodauksia kielessä: %s"

#, c-format
msgid "E154: Duplicate tag \"%s\" in file %s/%s"
msgstr "E154: Kaksoiskappale tägistä %s tiedostossa %s/%s"

#, c-format
msgid "E150: Not a directory: %s"
msgstr "E150: Ei ole hakemisto: %s"

#, c-format
msgid "E160: Unknown sign command: %s"
msgstr "E160: Tuntematon merkkikomento: %s"

msgid "E156: Missing sign name"
msgstr "E156: Merkki puuttuu"

msgid "E612: Too many signs defined"
msgstr "E612: Liikaa merkkejä määritelty"

#, c-format
msgid "E239: Invalid sign text: %s"
msgstr "E239: Virheellinen merkkiteksti: %s"

#, c-format
msgid "E155: Unknown sign: %s"
msgstr "E155: Tuntematon merkki: %s"

msgid "E159: Missing sign number"
msgstr "E159: Merkin numero puuttuu"

#, c-format
msgid "E158: Invalid buffer name: %s"
msgstr "E158: Virheellinen puskurin nimi: %s"

msgid "E934: Cannot jump to a buffer that does not have a name"
msgstr "E934: Ei voida hypätä puskuriin jolla ei ole nimeä"

#, c-format
msgid "E157: Invalid sign ID: %ld"
msgstr "E157: Virheellinen merkin tunnus: %ld"

#, c-format
msgid "E885: Not possible to change sign %s"
msgstr "E885: Ei voida muuttaa merkkiä %s"

msgid " (NOT FOUND)"
msgstr " (EI LÖYTYNYT)"

msgid " (not supported)"
msgstr " (ei tuettu)"

msgid "[Deleted]"
msgstr "[Poistettu]"

msgid "No old files"
msgstr "Ei vanhoja tiedostoja"

msgid "Entering Debug mode.  Type \"cont\" to continue."
msgstr "Siirrytään vianetsintätilaan, kirjoita cont jatkaaksesi."

#, c-format
msgid "line %ld: %s"
msgstr "rivi %ld: %s"

#, c-format
msgid "cmd: %s"
msgstr "kmnt: %s"

msgid "frame is zero"
msgstr "kehys on nolla"

#, c-format
msgid "frame at highest level: %d"
msgstr "kehys ylimmällä tasolla: %d"

#, c-format
msgid "Breakpoint in \"%s%s\" line %ld"
msgstr "Katkaisukohta %s%s rivillä %ld"

#, c-format
msgid "E161: Breakpoint not found: %s"
msgstr "E161: Katkaisukohta puuttuu: %s"

msgid "No breakpoints defined"
msgstr "Ei katkaisukohtia"

#, c-format
msgid "%3d  %s %s  line %ld"
msgstr "%3d  %s %s  rivi %ld"

msgid "E750: First use \":profile start {fname}\""
msgstr "E750: Aloita käskyllä :profile start {fname}"

#, c-format
msgid "Save changes to \"%s\"?"
msgstr "Tallennetaanko muutokset tiedostoon %s?"

msgid "Untitled"
msgstr "Nimetön"

#, c-format
msgid "E162: No write since last change for buffer \"%s\""
msgstr "E162: Muutoksia ei ole kirjoitettu puskurin %s viime muutoksen jälkeen"

msgid "Warning: Entered other buffer unexpectedly (check autocommands)"
msgstr "Varoitus: Puskuri vaihtui odottamatta (tarkista autocommands)"

msgid "E163: There is only one file to edit"
msgstr "E163: Vain yksi tiedosto muokattavana"

msgid "E164: Cannot go before first file"
msgstr "E164: Ensimmäisen tiedoston ohi ei voi mennä"

msgid "E165: Cannot go beyond last file"
msgstr "E165: Viimeisen tiedoston ohi ei voi mennä"

#, c-format
msgid "E666: compiler not supported: %s"
msgstr "E666: kääntäjää ei tueta: %s"

#, c-format
msgid "Searching for \"%s\" in \"%s\""
msgstr "Etsitään ilmausta %s kohteesta %s"

#, c-format
msgid "Searching for \"%s\""
msgstr "Etsitään ilmausta %s"

#, c-format
msgid "not found in '%s': \"%s\""
msgstr "'%s' ei löydy kohteesta: %s"

msgid "Source Vim script"
msgstr "Lataa vim-skripti"

#, c-format
msgid "Cannot source a directory: \"%s\""
msgstr "Hakemistoa ei voi ladata: %s"

#, c-format
msgid "could not source \"%s\""
msgstr "ei voitu ladata %s"

#, c-format
msgid "line %ld: could not source \"%s\""
msgstr "rivi %ld: ei voitu ladata %s"

#, c-format
msgid "sourcing \"%s\""
msgstr "ladataan %s"

#, c-format
msgid "line %ld: sourcing \"%s\""
msgstr "rivi %ld: ladataan %s"

#, c-format
msgid "finished sourcing %s"
msgstr "ladattu %s"

#, c-format
msgid "continuing in %s"
msgstr "jatkaa kohdassa %s"

msgid "modeline"
msgstr "mode-rivi"

msgid "--cmd argument"
msgstr "--cmd-argumentti"

msgid "-c argument"
msgstr "-c-argumentti"

msgid "environment variable"
msgstr "ympäristömuuttuja"

msgid "error handler"
msgstr "virhekäsittelin"

msgid "W15: Warning: Wrong line separator, ^M may be missing"
msgstr "W15: Varoitus: Väärä rivierotin, ^M saattaa puuttua"

msgid "E167: :scriptencoding used outside of a sourced file"
msgstr "E167: :scriptencoding ladatun tiedoston ulkopuolella"

msgid "E168: :finish used outside of a sourced file"
msgstr "E168: :finish ladatun tiedoston ulkopuolella"

#, c-format
msgid "Current %slanguage: \"%s\""
msgstr "Käytössä oleva %skieli: %s"

#, c-format
msgid "E197: Cannot set language to \"%s\""
msgstr "E197: Kieleksi ei voitu asettaa kieltä %s"

msgid "Entering Ex mode.  Type \"visual\" to go to Normal mode."
msgstr "Siirrytään Ex-tilaan, kirjoita visual palataksesi normaaliin tilaan."

msgid "E501: At end-of-file"
msgstr "E501: Tiedoston lopussa"

msgid "E169: Command too recursive"
msgstr "E169: Liian rekursiivinen komento"

#, c-format
msgid "E605: Exception not caught: %s"
msgstr "E605: Kiinniottamaton poikkeus: %s"

msgid "End of sourced file"
msgstr "Ladatun tiedoston loppu"

msgid "End of function"
msgstr "Funktion loppu"

msgid "E464: Ambiguous use of user-defined command"
msgstr "E464: Käyttäjän määrittelemän komennon monimerkityksinen käyttö"

msgid "E492: Not an editor command"
msgstr "E492: Ei ole editorikomento"

msgid "E493: Backwards range given"
msgstr "E493: Takaperoinen arvoalue annettu"

msgid "Backwards range given, OK to swap"
msgstr "Takaperoinen arvoalue annettu, OK kääntää"

msgid "E494: Use w or w>>"
msgstr "E494: Käytä w:tä tai w>>:aa"

msgid "E319: Sorry, the command is not available in this version"
msgstr "E319: Komento ei ole käytettävissä tässä versiossa"

msgid "E172: Only one file name allowed"
msgstr "E172: Vain yksi tiedostonimi sallitaan"

msgid "1 more file to edit.  Quit anyway?"
msgstr "vielä 1 tiedosto muokattavana, lopetaanko silti?"

#, c-format
msgid "%d more files to edit.  Quit anyway?"
msgstr "vielä %d tiedostoa muokattavana, lopetetaanko silti?"

msgid "E173: 1 more file to edit"
msgstr "E173: vielä 1 tiedosto muokattavana"

#, c-format
msgid "E173: %ld more files to edit"
msgstr "E173: vielä %ld tiedostoa muokattavana"

msgid "E174: Command already exists: add ! to replace it"
msgstr "E174: Komento on jo olemassa, käytä !:ä korvataksesi"

msgid ""
"\n"
"    Name        Args       Address   Complete  Definition"
msgstr ""
"\n"
"    Nimi        Argumentit Osoite    Valmis    Määritelmä"

msgid "No user-defined commands found"
msgstr "Ei käyttäjän määrittelemiä komentoja"

msgid "E175: No attribute specified"
msgstr "E175: Ei attribuutteja määriteltynä"

msgid "E176: Invalid number of arguments"
msgstr "E176: Väärä määrä attribuutteja"

msgid "E177: Count cannot be specified twice"
msgstr "E177: Lukumäärää ei voi määritellä kahdesti"

msgid "E178: Invalid default value for count"
msgstr "E178: Lukumäärän oletusarvo on väärä"

msgid "E179: argument required for -complete"
msgstr "E179: -complete vaatii argumentin"

msgid "E179: argument required for -addr"
msgstr "E179: -addr vaatii argumentin"

#, c-format
msgid "E181: Invalid attribute: %s"
msgstr "E181: Virheellinen attribuutti: %s"

msgid "E182: Invalid command name"
msgstr "E182: Virheellinen komennon nimi"

msgid "E183: User defined commands must start with an uppercase letter"
msgstr "E183: Käyttäjän määrittelemän komennon pitää alkaa suuraakkosella"

msgid "E841: Reserved name, cannot be used for user defined command"
msgstr "E841: Varattua nimeä ei voi käyttää käyttäjän määrittelemänä komentona"

#, c-format
msgid "E184: No such user-defined command: %s"
msgstr "E184: Käyttäjän komentoa ei ole olemassa: %s"

#, c-format
msgid "E180: Invalid address type value: %s"
msgstr "E180: Virheellinen osoitetyyppiarvo: %s"

#, c-format
msgid "E180: Invalid complete value: %s"
msgstr "E180: Virheellinen täydennysarvo: %s"

msgid "E468: Completion argument only allowed for custom completion"
msgstr "E468: Täydennysargumentti sopii vain itse määriteltyyn täydennykseen"

msgid "E467: Custom completion requires a function argument"
msgstr "E467: Itse määritelty täydennys vaatii funktioargumentin"

msgid "unknown"
msgstr "tuntematon"

#, c-format
msgid "E185: Cannot find color scheme '%s'"
msgstr "E185: Väriteemaa %s ei löydy"

msgid "Greetings, Vim user!"
msgstr "Tervehdys, Vimin käyttäjä."

msgid "E784: Cannot close last tab page"
msgstr "E784: Viimeistä välilehteä ei voi sulkea"

msgid "Already only one tab page"
msgstr "Vain yksi välilehti jäljellä enää"

msgid "Edit File in new window"
msgstr "Muokkaa uudessa ikkunassa"

#, c-format
msgid "Tab page %d"
msgstr "Tabisivu %d"

msgid "No swap file"
msgstr "Ei swap-tiedostoa"

msgid "Append File"
msgstr "Lisää tiedostoon"

msgid "E747: Cannot change directory, buffer is modified (add ! to override)"
msgstr ""
"E747: Hakemistoa ei voida muuttaa, puskuria on muokattu (lisää komentoon ! "
"ohittaaksesi"

msgid "E186: No previous directory"
msgstr "E186: Ei edellistä hakemistoa"

msgid "E187: Unknown"
msgstr "E187: Tuntematon"

msgid "E465: :winsize requires two number arguments"
msgstr "E465: :winsize vaatii kaksi numeroargumenttia"

#, c-format
msgid "Window position: X %d, Y %d"
msgstr "Ikkunan sijainti: X %d, Y %d"

msgid "E188: Obtaining window position not implemented for this platform"
msgstr "E188: Ikkunan sijainnin selvitys ei toimi tällä alustalla"

msgid "E466: :winpos requires two number arguments"
msgstr "E466: :winpos vaatii kaksi lukuargumenttia"

msgid "E930: Cannot use :redir inside execute()"
msgstr "E930: Komentoa :redir ei voi käyttää funktion execute() sisällä"

msgid "Save Redirection"
msgstr "Tallenna uudelleenosoitus"

msgid "Save View"
msgstr "Tallenna näkymä"

msgid "Save Session"
msgstr "Tallenna sessio"

msgid "Save Setup"
msgstr "Tallenna asetukset"

#, c-format
msgid "E739: Cannot create directory: %s"
msgstr "E739: hakemistoa ei voi luoda: %s"

#, c-format
msgid "E189: \"%s\" exists (add ! to override)"
msgstr "E189: %s on jo olemassa (lisää komentoon ! ohittaaksesi)"

#, c-format
msgid "E190: Cannot open \"%s\" for writing"
msgstr "E190: Tiedostoa %s ei voitu avata kirjoittamista varten"

#. set mark
msgid "E191: Argument must be a letter or forward/backward quote"
msgstr "E191: Argumentin eteen- tai taaksepäin lainaukseen pitää olla kirjain"

msgid "E192: Recursive use of :normal too deep"
msgstr "E192: :normalin liian syvä rekursio"

msgid "E809: #< is not available without the +eval feature"
msgstr "E809: #< ei ole käytössä jollei +eval ole päällä"

msgid "E194: No alternate file name to substitute for '#'"
msgstr "E194: Ei vaihtoehtoista tiedostonimeä #:lle"

msgid "E495: no autocommand file name to substitute for \"<afile>\""
msgstr "E495: ei autocommand-tiedostoa kohteelle <afile>"

msgid "E496: no autocommand buffer number to substitute for \"<abuf>\""
msgstr "E496: ei autocommand-puskurinumeroa kohteelle <abuf>"

msgid "E497: no autocommand match name to substitute for \"<amatch>\""
msgstr "E497: ei autocommand-täsmäysnimeä kohteella <amatch>"

msgid "E498: no :source file name to substitute for \"<sfile>\""
msgstr "E498: ei :source-tiedostonimeä kohteelle <sfile>"

msgid "E842: no line number to use for \"<slnum>\""
msgstr "E842: ei rivinumeroa kohteelle <slnum>"

#, no-c-format
msgid "E499: Empty file name for '%' or '#', only works with \":p:h\""
msgstr "E499: Tyhjä tiedostonimi kohteissa % tai #  toimii vain :p:h"

msgid "E500: Evaluates to an empty string"
msgstr "E500: Loppuarvo on tyhjä merkkijono"

msgid "E195: Cannot open viminfo file for reading"
msgstr "E195: Viminfoa ei voi avata lukemista varten"

msgid "E196: No digraphs in this version"
msgstr "E196: Digraafeja ei ole tässä versiossa"

msgid "E608: Cannot :throw exceptions with 'Vim' prefix"
msgstr "E608: Vim-alkuisia poikkeuksia ei voi heittää :throw-komennolla"

#. always scroll up, don't overwrite
#, c-format
msgid "Exception thrown: %s"
msgstr "Poikkeus heitetty: %s"

#, c-format
msgid "Exception finished: %s"
msgstr "Poikkeus lopeteltu: %s"

#, c-format
msgid "Exception discarded: %s"
msgstr "Poikkeus poistettu: %s"

#, c-format
msgid "%s, line %ld"
msgstr "%s, rivi %ld"

#. always scroll up, don't overwrite
#, c-format
msgid "Exception caught: %s"
msgstr "Poikkeus otettu kiinni: %s"

#, c-format
msgid "%s made pending"
msgstr "%s odotutettu"

#, c-format
msgid "%s resumed"
msgstr "%s palautettu"

#, c-format
msgid "%s discarded"
msgstr "%s poistettu"

msgid "Exception"
msgstr "Poikkeus"

msgid "Error and interrupt"
msgstr "Virhe ja keskeytys"

msgid "Error"
msgstr "Virhe"

#. if (pending & CSTP_INTERRUPT)
msgid "Interrupt"
msgstr "Keskeytys"

msgid "E579: :if nesting too deep"
msgstr "E579: liian monta kerrosta :if-komennossa"

msgid "E580: :endif without :if"
msgstr "E580: :endif ilman komentoa :if"

msgid "E581: :else without :if"
msgstr "E581: :else ilman komentoa :if"

msgid "E582: :elseif without :if"
msgstr "E582: :elseif ilman komentoa :if"

msgid "E583: multiple :else"
msgstr "E583: :else monta kertaa"

msgid "E584: :elseif after :else"
msgstr "E584: :elseif komennon :else jälkeen"

msgid "E585: :while/:for nesting too deep"
msgstr "E585: liian monta tasoa :while- tai :for-komennoissa"

msgid "E586: :continue without :while or :for"
msgstr "E586: :continue ilman komentoa :while tai :for"

msgid "E587: :break without :while or :for"
msgstr "E587: :break ilman komentoa :while tai :for"

msgid "E732: Using :endfor with :while"
msgstr "E732: :endfor ilman komentoa :while"

msgid "E733: Using :endwhile with :for"
msgstr "E733: :endwhile ilman komentoa :for"

msgid "E601: :try nesting too deep"
msgstr "E601: liian monta tasoa :try-komennossa"

msgid "E603: :catch without :try"
msgstr "E603: :catch ilman komentoa :try"

#. Give up for a ":catch" after ":finally" and ignore it.
#. * Just parse.
msgid "E604: :catch after :finally"
msgstr "E604: :catch ilman komentoa :finally"

msgid "E606: :finally without :try"
msgstr "E606: :finally ilman komentoa :try"

#. Give up for a multiple ":finally" and ignore it.
msgid "E607: multiple :finally"
msgstr "E607: :finally monta kertaa"

msgid "E602: :endtry without :try"
msgstr "E602: :endtry ilman komentoa :try"

msgid "E193: :endfunction not inside a function"
msgstr "E193: :endfunction funktion ulkopuolella"

msgid "E788: Not allowed to edit another buffer now"
msgstr "E788: Puskuria ei voi muokata nyt"

msgid "E811: Not allowed to change buffer information now"
msgstr "E811: Puskuria ei voi vaihtaa nyt"

msgid "tagname"
msgstr "täginimi"

msgid " kind file\n"
msgstr " -tiedostotyyppi\n"

msgid "'history' option is zero"
msgstr "history-asetus on nolla"

#, c-format
msgid ""
"\n"
"# %s History (newest to oldest):\n"
msgstr ""
"\n"
"# %s Historia (uusimmasta alkaen):\n"

msgid "Command Line"
msgstr "Komentorivi"

msgid "Search String"
msgstr "Hakujono"

msgid "Expression"
msgstr "Ilmaus"

msgid "Input Line"
msgstr "Syöterivi"

msgid "Debug Line"
msgstr "Vianetsintärivi"

msgid "E198: cmd_pchar beyond the command length"
msgstr "E198: cmd_pchar komennon pituuden ulkopuolella"

msgid "E199: Active window or buffer deleted"
msgstr "E199: Aktiivinen ikkuna tai puskuri poistettu"

msgid "E812: Autocommands changed buffer or buffer name"
msgstr "E812: Autocommands muutti puskurin tai sen nimen"

msgid "Illegal file name"
msgstr "Virheellinen tiedostonimi"

msgid "is a directory"
msgstr "on hakemisto"

msgid "is not a file"
msgstr "ei ole tiedosto"

msgid "is a device (disabled with 'opendevice' option)"
msgstr "on laite (ei käytössä opendevice-asetuksen takia)"

msgid "[New File]"
msgstr "[Uusi tiedosto]"

msgid "[New DIRECTORY]"
msgstr "[uusi HAKEMISTO]"

msgid "[File too big]"
msgstr "[Liian iso tiedosto]"

msgid "[Permission Denied]"
msgstr "[Lupa kielletty]"

msgid "E200: *ReadPre autocommands made the file unreadable"
msgstr ""
"E200: *ReadPre-autocommand-komennot tekivät tiedostosta lukukelvottoman"

msgid "E201: *ReadPre autocommands must not change current buffer"
msgstr "E201: *ReadPre-autocommand-komennot eivät saa muuttaa puskuria"

msgid "Vim: Reading from stdin...\n"
msgstr "Vim: Luetaan vakiosyötteestä...\n"

msgid "Reading from stdin..."
msgstr "Luetaan vakiosyötteestä"

#. Re-opening the original file failed!
msgid "E202: Conversion made file unreadable!"
msgstr "E202: Muunnos teki tiedostosta lukukelvottoman."

msgid "[fifo/socket]"
msgstr "[fifo t. soketti]"

msgid "[fifo]"
msgstr "[fifo]"

msgid "[socket]"
msgstr "[soketti]"

msgid "[character special]"
msgstr "[merkki erikoinen]"

# Carriage Return elikkä rivinvaihtomerkin eräs muoto/osa (vrt. LF)
msgid "[CR missing]"
msgstr "[CR puuttuu]"

msgid "[long lines split]"
msgstr "[pitkät rivit hajotettu]"

msgid "[NOT converted]"
msgstr "[EI muunnettu]"

msgid "[converted]"
msgstr "[muunnettu]"

#, c-format
msgid "[CONVERSION ERROR in line %ld]"
msgstr "[MUUNNOSVIRHE rivillä %ld]"

#, c-format
msgid "[ILLEGAL BYTE in line %ld]"
msgstr "[VIRHEELLINEN OKTETTI rivillä %ld]"

msgid "[READ ERRORS]"
msgstr "[LUKUVIRHEITÄ]"

msgid "Can't find temp file for conversion"
msgstr "Ei voi löytää väliaikaistiedstoa muuntamiseksi"

msgid "Conversion with 'charconvert' failed"
msgstr "Muunnos charconvert epäonnistui"

msgid "can't read output of 'charconvert'"
msgstr "charconvertin tulostetta ei voida lukea"

msgid "E676: No matching autocommands for acwrite buffer"
msgstr "E676: Ei autocommand-komentoa acwrite-puskurille"

msgid "E203: Autocommands deleted or unloaded buffer to be written"
msgstr ""
"E203: Autocommand-komennot poistivat tai vapauttivat puskurin, johon piti "
"kirjoittaa"

msgid "E204: Autocommand changed number of lines in unexpected way"
msgstr "E204: Autocommand-komento muutti rivien määrä odottamatta"

msgid "NetBeans disallows writes of unmodified buffers"
msgstr "NetBeans ei salli kirjoittaa muokkaamattomiin puskureihin"

msgid "Partial writes disallowed for NetBeans buffers"
msgstr "Osittaiset kirjoitukset kielletty NetBeans-puskureissa"

msgid "is not a file or writable device"
msgstr "ei ole tiedosto tai kirjoitettava laite"

msgid "writing to device disabled with 'opendevice' option"
msgstr "laitteeseen kirjoittaminen pois käytöstä opendevice-asetuksella"

msgid "is read-only (add ! to override)"
msgstr "on kirjoitussuojattu (lisää komentoon ! ohittaaksesi)"

msgid "E506: Can't write to backup file (add ! to override)"
msgstr ""
"E506: Ei voi kirjoittaa varmuuskopiotiedostoon (lisää komentoon ! "
"ohittaaksesi)"

msgid "E507: Close error for backup file (add ! to override)"
msgstr ""
"E507: Varmuuskopiotiedoston sulkeminen ei onnistu (lisää komentoon ! "
"ohittaaksesi)"

msgid "E508: Can't read file for backup (add ! to override)"
msgstr ""
"E508: Varmuuskopiotiedostoa ei voi lukea (lisää komentoon ! ohittaaksesi)"

msgid "E509: Cannot create backup file (add ! to override)"
msgstr ""
"E509: Ei voi luoda varmuuskopiotiedostoa (lisää komentoon ! ohittaaksesi)"

msgid "E510: Can't make backup file (add ! to override)"
msgstr ""
"E510: Ei voi tehdä varmuuskopiotiedostoa (lisää komentoon ! ohittaaksesi)"

# tietääkseni resurssiforkki on applen tiedostojärjestelmän tunnistejuttujuttu
msgid "E460: The resource fork would be lost (add ! to override)"
msgstr "E460: resurssiosa häviäisi (lisää komentoon ! ohittaaksesi)"

msgid "E214: Can't find temp file for writing"
msgstr "E214: Ei voi löytää väliaikaistiedostoa kirjoitettavaksi"

msgid "E213: Cannot convert (add ! to write without conversion)"
msgstr ""
"E213: Muunnos ei onnistu (lisää komentoon ! kirjoittaaksesi muuntamatta)"

msgid "E166: Can't open linked file for writing"
msgstr "E166: Linkitetyn tiedoston avaus kirjoittamista varten ei onnistu"

msgid "E212: Can't open file for writing"
msgstr "E212: Tiedoston avaus kirjoittamista varten ei onnistu"

msgid "E667: Fsync failed"
msgstr "E667: Fsync ei onnistunut"

msgid "E512: Close failed"
msgstr "E512: Sulkeminen ei onnistunut"

msgid "E513: write error, conversion failed (make 'fenc' empty to override)"
msgstr "E513: kirjoitusvirhe, muunnos epäonnistui (tyhjää fenc ohittaaksesi)"

#, c-format
msgid ""
"E513: write error, conversion failed in line %ld (make 'fenc' empty to "
"override)"
msgstr ""
"E513: kirjoitusvirhe, muunnos epäonnistui rivillä %ld(tyhjää fenc "
"ohittaaksesi)"

msgid "E514: write error (file system full?)"
msgstr "E514: kirjoitusvirhe (tiedostojärjestelmä täysi)"

msgid " CONVERSION ERROR"
msgstr " MUUNNOSVIRHE"

#, c-format
msgid " in line %ld;"
msgstr " rivillä %ld"

msgid "[Device]"
msgstr "[Laite]"

msgid "[New]"
msgstr "[Uusi]"

msgid " [a]"
msgstr " [a]"

msgid " appended"
msgstr " lisätty"

msgid " [w]"
msgstr " [w]"

msgid " written"
msgstr " kirjoitettu"

msgid "E205: Patchmode: can't save original file"
msgstr "E205: Patch-tilassa ei voi tallentaa alkuperäistiedostoa"

msgid "E206: patchmode: can't touch empty original file"
msgstr "E206: patch-tilassa ei voi muuttaa tyhjää alkuperäistiedostoa"

msgid "E207: Can't delete backup file"
msgstr "E207: Ei voi poistaa varmuuskopiota"

msgid ""
"\n"
"WARNING: Original file may be lost or damaged\n"
msgstr ""
"\n"
"VAROITUS: Alkuperäistiedosto voi hävitä tai vahingoittua\n"

msgid "don't quit the editor until the file is successfully written!"
msgstr "älä lopeta editoria kesken tallentamisen."

msgid "[dos]"
msgstr "[dos]"

msgid "[dos format]"
msgstr "[dos-muoto]"

msgid "[mac]"
msgstr "[mac]"

msgid "[mac format]"
msgstr "[mac-muoto]"

msgid "[unix]"
msgstr "[unix]"

msgid "[unix format]"
msgstr "[unix-muoto]"

msgid "1 line, "
msgstr "1 rivi, "

#, c-format
msgid "%ld lines, "
msgstr "%ld riviä, "

msgid "1 character"
msgstr "1 merkki"

#, c-format
msgid "%lld characters"
msgstr "%lld merkkiä"

# ei rivinvaihtoja
msgid "[noeol]"
msgstr "[eiriviv.]"

msgid "[Incomplete last line]"
msgstr "[Vajaa viimeinen rivi]"

# Jos aukiolevaa tiedostoa sörkkii toisella ohjelmalla
#. don't overwrite messages here
#. must give this prompt
#. don't use emsg() here, don't want to flush the buffers
msgid "WARNING: The file has been changed since reading it!!!"
msgstr "VAROITUS: tiedosto on muuttunut viime lukukerran jälkeen!"

msgid "Do you really want to write to it"
msgstr "Kirjoitetaanko"

#, c-format
msgid "E208: Error writing to \"%s\""
msgstr "E208: Virhe kirjoitettaessa tiedostoon %s"

#, c-format
msgid "E209: Error closing \"%s\""
msgstr "E209: Virhe suljettaessa tiedostoa %s"

#, c-format
msgid "E210: Error reading \"%s\""
msgstr "E210: Virhe luettaessa tiedostoa %s"

msgid "E246: FileChangedShell autocommand deleted buffer"
msgstr "E246: FileChangedShell-autocommand poisti puskurin"

#, c-format
msgid "E211: File \"%s\" no longer available"
msgstr "E211: Tiedostoa %s ei ole enää"

#, c-format
msgid ""
"W12: Warning: File \"%s\" has changed and the buffer was changed in Vim as "
"well"
msgstr ""
"W12: Varoitus: Tiedostoa %s on muutettu ja Vimin puskurissa on muutoksia "
"tiedostoon"

msgid "See \":help W12\" for more info."
msgstr ":help W12 kertoo lisätietoja."

#, c-format
msgid "W11: Warning: File \"%s\" has changed since editing started"
msgstr "W11: Varoitus: Tiedostoa %s on muutettu muokkauksen aloituksen jälkeen"

msgid "See \":help W11\" for more info."
msgstr ":help W11 kertoo lisätietoja."

#, c-format
msgid "W16: Warning: Mode of file \"%s\" has changed since editing started"
msgstr ""
"W16: Varoitus: Tiedoston %s oikeuksia on muutettu muokkauksen aloituksen "
"jälkeen"

msgid "See \":help W16\" for more info."
msgstr ":help W16 kertoo lisätietoja."

#, c-format
msgid "W13: Warning: File \"%s\" has been created after editing started"
msgstr "W13: Varoitus: Tiedosto %s on luotu muokkauksen aloituksen jälkeen"

msgid "Warning"
msgstr "Varoitus"

# yllä olevien varoitusten ratkaisut
msgid ""
"&OK\n"
"&Load File"
msgstr ""
"&OK\n"
"&Avaa tiedosto uudelleen"

#, c-format
msgid "E462: Could not prepare for reloading \"%s\""
msgstr "E462: Ei voitu valmistella uudelleen avausta %s"

#, c-format
msgid "E321: Could not reload \"%s\""
msgstr "E321: Ei voitu uudelleenavata %s"

#, c-format
msgid "auto-removing autocommand: %s <buffer=%d>"
msgstr "poistetaan autocommand automaattisesti: %s <puskuri=%d>"

#. the group doesn't exist
#, c-format
msgid "E367: No such group: \"%s\""
msgstr "E367: Ryhmää ei ole: %s"

msgid "W19: Deleting augroup that is still in use"
msgstr "W19: käytössä oleva augroup poistetaan"

msgid "--Deleted--"
msgstr "--Poistettu--"

#, c-format
msgid "E215: Illegal character after *: %s"
msgstr "E215: Virheellinen merkki *:n jälkeen: %s"

#, c-format
msgid "E216: No such event: %s"
msgstr "E216: Eventtiä ei ole: %s"

#, c-format
msgid "E216: No such group or event: %s"
msgstr "E216: Ryhmää tai eventtiä ei ole: %s"

#. Highlight title
msgid ""
"\n"
"--- Auto-Commands ---"
msgstr ""
"\n"
"--- Autocommandit ---"

#, c-format
msgid "E680: <buffer=%d>: invalid buffer number "
msgstr "E680: <puskuri=%d>: virheellinen puskurinumero"

msgid "E217: Can't execute autocommands for ALL events"
msgstr "E217: Ei voi suorittaa autocommandsia kaikille eventeille"

msgid "No matching autocommands"
msgstr "Ei täsmääviä autocommandsia"

msgid "E218: autocommand nesting too deep"
msgstr "E218: liian monta tasoa autocommandissa"

#, c-format
msgid "%s Auto commands for \"%s\""
msgstr "%s Autocommands kohteelle %s"

#, c-format
msgid "Executing %s"
msgstr "Suoritetaan %s"

#, c-format
msgid "autocommand %s"
msgstr "autocommand %s"

msgid "E219: Missing {."
msgstr "E219: { puuttuu."

msgid "E220: Missing }."
msgstr "E220: } puuttuu."

msgid "E490: No fold found"
msgstr "E490: taitos puuttuu"

msgid "E350: Cannot create fold with current 'foldmethod'"
msgstr "E350: Taitoksia ei voi tehdä tällä foldmethodilla"

msgid "E351: Cannot delete fold with current 'foldmethod'"
msgstr "E351: Taitosta ei voi poistaa tällä foldmethodilla"

#, c-format
msgid "+--%3ld line folded "
msgid_plural "+--%3ld lines folded "
msgstr[0] "+--%3ld rivi taitettu pois "
msgstr[1] "+--%3ld riviä taitettu pois "

msgid "E222: Add to read buffer"
msgstr "E222: Lisää lukupuskuriin"

msgid "E223: recursive mapping"
msgstr "E223: rekursiivinen kuvaus"

#, c-format
msgid "E224: global abbreviation already exists for %s"
msgstr "E224: globaali lyhenne merkinnälle %s on jo olemassa"

#, c-format
msgid "E225: global mapping already exists for %s"
msgstr "E225: globaali kuvaus merkinnälle %s on jo olemassa"

#, c-format
msgid "E226: abbreviation already exists for %s"
msgstr "E226: lyhenne on jo olemassa %s"

#, c-format
msgid "E227: mapping already exists for %s"
msgstr "E227: kuvaus on jo olemassa %s"

msgid "No abbreviation found"
msgstr "Lyhennettä ei löydy"

msgid "No mapping found"
msgstr "Kuvausta ei löydy"

msgid "E228: makemap: Illegal mode"
msgstr "E228: makemap: Virheellinen tila"

msgid "E851: Failed to create a new process for the GUI"
msgstr "E851: Ei voitu luoda uutta prosessia käyttöliittymälle"

msgid "E852: The child process failed to start the GUI"
msgstr "E852: Lapsiprosesi ei voinut käynnistää käyttöliittymää"

msgid "E229: Cannot start the GUI"
msgstr "E229: GUIn käynnistys ei onnistu"

#, c-format
msgid "E230: Cannot read from \"%s\""
msgstr "E230: Ei voi lukea kohteesta %s"

msgid "E665: Cannot start GUI, no valid font found"
msgstr "E665: Ei voi avata GUIta, sopivaa fonttia ei löydy"

msgid "E231: 'guifontwide' invalid"
msgstr "E231: guifontwide virheellinen"

msgid "E599: Value of 'imactivatekey' is invalid"
msgstr "E599: imactivatekeyn arvo on virheellinen"

#, c-format
msgid "E254: Cannot allocate color %s"
msgstr "E254: Väriä %s ei voi määritellä"

msgid "No match at cursor, finding next"
msgstr "Ei täsmäystä kursorin alla, etsitään seuraava"

msgid "<cannot open> "
msgstr "<ei voi avata> "

#, c-format
msgid "E616: vim_SelFile: can't get font %s"
msgstr "E616: vim_SelFile: ei saada fonttia %s"

msgid "E614: vim_SelFile: can't return to current directory"
msgstr "E614: vim_SelFile: nykyiseen hakemistoon ei voi palata"

msgid "Pathname:"
msgstr "Polku:"

msgid "E615: vim_SelFile: can't get current directory"
msgstr "E615: vim_SelFile: nykyistä hakemistoa ei saada selville"

msgid "OK"
msgstr "OK"

msgid "Cancel"
msgstr "Peru"

msgid "Scrollbar Widget: Could not get geometry of thumb pixmap."
msgstr "Vierityspalkki: Pixmapin geometria ei selviä"

msgid "Vim dialog"
msgstr "Vim-ikkuna"

msgid "E232: Cannot create BalloonEval with both message and callback"
msgstr "E232: Ei voi luoda BalloonEvalia viestille ja callbackille"

msgid "_Cancel"
msgstr "_Peru"

msgid "_Save"
msgstr "_Tallenna"

msgid "_Open"
msgstr "_Avaa"

msgid "_OK"
msgstr "_OK"

msgid ""
"&Yes\n"
"&No\n"
"&Cancel"
msgstr ""
"&Kyllä\n"
"&Ei\n"
"&Peru"

msgid "Yes"
msgstr "Kyllä"

msgid "No"
msgstr "Ei"

msgid "Input _Methods"
msgstr "Syöte_menetelmät"

msgid "VIM - Search and Replace..."
msgstr "VIM - Etsi ja korvaa..."

msgid "VIM - Search..."
msgstr "VIM - Etsi..."

msgid "Find what:"
msgstr "Etsi:"

msgid "Replace with:"
msgstr "Korvaa:"

#. whole word only button
msgid "Match whole word only"
msgstr "Korvaa kokonaisia sanoja"

#. match case button
msgid "Match case"
msgstr "Kirjaintaso"

msgid "Direction"
msgstr "Suunta"

#. 'Up' and 'Down' buttons
msgid "Up"
msgstr "Ylös"

msgid "Down"
msgstr "Alas"

msgid "Find Next"
msgstr "Etsi seuraava"

msgid "Replace"
msgstr "Korvaa"

msgid "Replace All"
msgstr "Korvaa kaikki"

msgid "_Close"
msgstr "_Sulje"

msgid "Vim: Received \"die\" request from session manager\n"
msgstr "Vim: sessiomanageri lähetti die-pyynnön\n"

msgid "Close tab"
msgstr "Sulje välilehti"

msgid "New tab"
msgstr "Uusi välilehti"

msgid "Open Tab..."
msgstr "Avaa välilehti..."

msgid "Vim: Main window unexpectedly destroyed\n"
msgstr "Vim: Pääikkuna tuhoutui odottamatta\n"

msgid "&Filter"
msgstr "&Suodata"

msgid "&Cancel"
msgstr "&Peru"

msgid "Directories"
msgstr "Hakemistot"

msgid "Filter"
msgstr "Suodatus"

msgid "&Help"
msgstr "O&hje"

msgid "Files"
msgstr "Tiedostot"

msgid "&OK"
msgstr "&Ok"

msgid "Selection"
msgstr "Valinta"

msgid "Find &Next"
msgstr "Hae &seuraava"

msgid "&Replace"
msgstr "Ko&rvaa"

msgid "Replace &All"
msgstr "Korvaa k&aikki"

msgid "&Undo"
msgstr "&Kumoa"

msgid "Open tab..."
msgstr "Avaa välilehti..."

msgid "Find string (use '\\\\' to find  a '\\')"
msgstr "Etsi merkkijonoa (\\\\:llä löytää \\:t)"

msgid "Find & Replace (use '\\\\' to find  a '\\')"
msgstr "Etsi ja korvaa (\\\\:llä löytää \\:t)"

#. We fake this: Use a filter that doesn't select anything and a default
#. * file name that won't be used.
msgid "Not Used"
msgstr "Ei käytössä"

msgid "Directory\t*.nothing\n"
msgstr "Hakemisto\t*.nothing\n"

#, c-format
msgid "E671: Cannot find window title \"%s\""
msgstr "E671: Ikkunan otsikkoa ei löydy %s"

# OLE on object linking and embedding på windowska
#, c-format
msgid "E243: Argument not supported: \"-%s\"; Use the OLE version."
msgstr "E243: Argumenttia ei tueta: -%s, käytä OLE-versiota"

# MDI eli windowsin moni-ikkunasovellus
msgid "E672: Unable to open window inside MDI application"
msgstr "E672: Ikkunaa ei voitu avata MDI-sovellukseen"

msgid "Vim E458: Cannot allocate colormap entry, some colors may be incorrect"
msgstr "Vim E458: Ei voi varata värikartan alkiota, värit voivat mennä väärin"

#, c-format
msgid "E250: Fonts for the following charsets are missing in fontset %s:"
msgstr "E250: Seuraavien merkistöjoukkojen fontit puuttuvat fontsetistä %s:"

#, c-format
msgid "E252: Fontset name: %s"
msgstr "E252: Fontsetin nimi: %s"

#, c-format
msgid "Font '%s' is not fixed-width"
msgstr "Fontti %s ei ole tasavälinen"

#, c-format
msgid "E253: Fontset name: %s"
msgstr "E253: Fontsetin nimi: %s"

#, c-format
msgid "Font0: %s"
msgstr "Fontti0: %s"

#, c-format
msgid "Font1: %s"
msgstr "Fontti1: %s"

#, c-format
msgid "Font%ld width is not twice that of font0"
msgstr "Fontti%ld:n leveys ei ole kaksi kertaa fontti0:n"

#, c-format
msgid "Font0 width: %ld"
msgstr "Fontti0:n leveys: %ld"

#, c-format
msgid "Font1 width: %ld"
msgstr ""
"Fontti1:n leveys: %ld"


msgid "Invalid font specification"
msgstr "Virheellinen fonttimääritys"

msgid "&Dismiss"
msgstr "&Ohita"

msgid "no specific match"
msgstr "ei tarkkaa täsmäystä"

msgid "Vim - Font Selector"
msgstr "Vim - fonttivalitsin"

msgid "Name:"
msgstr "Nimi:"

#. create toggle button
msgid "Show size in Points"
msgstr "Näytä koko pisteinä"

msgid "Encoding:"
msgstr "Koodaus:"

msgid "Font:"
msgstr "Fontti:"

msgid "Style:"
msgstr "Tyyli:"

msgid "Size:"
msgstr "Koko:"

msgid "E256: Hangul automata ERROR"
msgstr "E256: Hangu-automaattivirhe"

msgid "E550: Missing colon"
msgstr "E550: kaksoispiste puuttuu"

msgid "E551: Illegal component"
msgstr "E551: Virheellinen komponentti"

msgid "E552: digit expected"
msgstr "E552: pitäisi olla numero"

#, c-format
msgid "Page %d"
msgstr "Sivu %d"

msgid "No text to be printed"
msgstr "Ei tekstiä tulostettavaksi"

#, c-format
msgid "Printing page %d (%d%%)"
msgstr "Tulostetaan sivua %d (%d %%)"

#, c-format
msgid " Copy %d of %d"
msgstr " Kopio %d/%d"

#, c-format
msgid "Printed: %s"
msgstr "Tulostettu: %s"

msgid "Printing aborted"
msgstr "Tulostus peruttu"

msgid "E455: Error writing to PostScript output file"
msgstr "E455: Virhe kirjoitettaessa PostScriptiä tiedostoon"

#, c-format
msgid "E624: Can't open file \"%s\""
msgstr "E624: Ei voi avata tiedostoa %s"

#, c-format
msgid "E457: Can't read PostScript resource file \"%s\""
msgstr "E457: Ei voi lukea PostScript-resurssitiedostoa %s"

#, c-format
msgid "E618: file \"%s\" is not a PostScript resource file"
msgstr "E618: tiedosto %s ei ole PostScript-resurssitiedosto"

#, c-format
msgid "E619: file \"%s\" is not a supported PostScript resource file"
msgstr "E619: tiedosto %s ei ole tuettu PostScript-resurssitiedosto"

#, c-format
msgid "E621: \"%s\" resource file has wrong version"
msgstr "E621: resurssitiedoston %s versio on väärä"

msgid "E673: Incompatible multi-byte encoding and character set."
msgstr "E673: Tukematon monitvauinen merkistökoodaus ja merkistö."

msgid "E674: printmbcharset cannot be empty with multi-byte encoding."
msgstr "E674: printmbcharset ei voi olla tyhjä monitavuiselle koodaukselle."

msgid "E675: No default font specified for multi-byte printing."
msgstr "E675: Ei oletusfonttia monitavuiseen tulostukseen"

msgid "E324: Can't open PostScript output file"
msgstr "E324: PostScript-tulostetiedoston avaus ei onnistu"

#, c-format
msgid "E456: Can't open file \"%s\""
msgstr "E456: Tiedoston %s avaus ei onnistu"

msgid "E456: Can't find PostScript resource file \"prolog.ps\""
msgstr "E456: PostScript-resurssitiedostoa prolog.ps ei löydy"

msgid "E456: Can't find PostScript resource file \"cidfont.ps\""
msgstr "E456: PostScript-resurssitiedostoa cidfont.ps ei löydy"

#, c-format
msgid "E456: Can't find PostScript resource file \"%s.ps\""
msgstr "E456: Postscript-resurssitiedosta %s.ps ei löydy"

#, c-format
msgid "E620: Unable to convert to print encoding \"%s\""
msgstr "E620: Tulostuskoodaukseen %s muunto ei onnistu"

msgid "Sending to printer..."
msgstr "Lähetetään tulostimelle..."

msgid "E365: Failed to print PostScript file"
msgstr "E365: PostScript-tiedoston tulostus epäonnistui"

msgid "Print job sent."
msgstr "Tulostustyö lähetetty."

msgid "Add a new database"
msgstr "Lisää uusi tietokanta"

msgid "Query for a pattern"
msgstr "Hae kuviota"

msgid "Show this message"
msgstr "Näytä tämä viesti"

msgid "Kill a connection"
msgstr "Tapa yhteys"

msgid "Reinit all connections"
msgstr "Alusta uudelleen yhteydet"

msgid "Show connections"
msgstr "Näytä yhteydet"

#, c-format
msgid "E560: Usage: cs[cope] %s"
msgstr "E560: Käyttö: cs[cope] %s"

msgid "This cscope command does not support splitting the window.\n"
msgstr "Tämä cscope-komento ei tue ikkunan jakamista.\n"

msgid "E562: Usage: cstag <ident>"
msgstr "E562: Käyttö: cstag <ident>"

msgid "E257: cstag: tag not found"
msgstr "E257: cstag: tägia ei löydy"

#, c-format
msgid "E563: stat(%s) error: %d"
msgstr "E563: stat(%s)-virhe: %d"

msgid "E563: stat error"
msgstr "E563: stat-virhe"

#, c-format
msgid "E564: %s is not a directory or a valid cscope database"
msgstr "E564: %s ei ole hakemisto eikä cscope-tietokanta"

#, c-format
msgid "Added cscope database %s"
msgstr "Lisätty cscope-tietokanta %s"

#, c-format
msgid "E262: error reading cscope connection %ld"
msgstr "E262: Virhe luettaessa cscope-yhteyttä %ld"

msgid "E561: unknown cscope search type"
msgstr "E561: tuntematon cscope-hakutyyppi"

msgid "E566: Could not create cscope pipes"
msgstr "E566: Ei voitu luoda cscope-putkia"

msgid "E622: Could not fork for cscope"
msgstr "E622: Ei voitu haarauttaa cscopea"

msgid "cs_create_connection setpgid failed"
msgstr "cs_create_connection setpgid epäonnistui"

msgid "cs_create_connection exec failed"
msgstr "cs_create_connection epäonnistui"

msgid "cs_create_connection: fdopen for to_fp failed"
msgstr "cs_create_connection: fdopen to_fp epäonnistui"

msgid "cs_create_connection: fdopen for fr_fp failed"
msgstr "cs_create_connection: fdopen fr_fp epäonnistui"

msgid "E623: Could not spawn cscope process"
msgstr "E623: Cscope-prosessin luonti epäonnistui"

msgid "E567: no cscope connections"
msgstr "E567: ei cscope-yhteyksiä"

#, c-format
msgid "E469: invalid cscopequickfix flag %c for %c"
msgstr "E469: virheellinen cscopequickfix-asetus %c kohteelle %c"

#, c-format
msgid "E259: no matches found for cscope query %s of %s"
msgstr "E259: ei täsmäyksiä cscope-hakuun %s/%s"

msgid "cscope commands:\n"
msgstr "cscope-komennot:\n"

#, c-format
msgid "%-5s: %s%*s (Usage: %s)"
msgstr "%-5s: %s%*s (Käyttö: %s)"

msgid ""
"\n"
"       a: Find assignments to this symbol\n"
"       c: Find functions calling this function\n"
"       d: Find functions called by this function\n"
"       e: Find this egrep pattern\n"
"       f: Find this file\n"
"       g: Find this definition\n"
"       i: Find files #including this file\n"
"       s: Find this C symbol\n"
"       t: Find this text string\n"
msgstr ""
"\n"
"       a: Etsi sijotukset tähän symboliin\n"
"       c: Etsi tätä funktiota kutsuvat funktiot\n"
"       d: Etsi tämän funktion kutsumat funktiot\n"
"       e: Etsi tämä egrep-lauseke\n"
"       f: Etsi tämä tiedosto\n"
"       g: Etsi tämä määritys\n"
"       i: Etsi tiedostoja jotka #inkluudaavat tämän\n"
"       s: Etsi tämä C-symboli\n"
"       t: Etsi sijoitukset muuttujaan \n"

#, c-format
msgid "E625: cannot open cscope database: %s"
msgstr "E625: ei voi avata cscope-tietokantaa: %s"

msgid "E626: cannot get cscope database information"
msgstr "E626: ei voi hakea cscope-tietokannan tietoja"

msgid "E568: duplicate cscope database not added"
msgstr "E568: kaksoiskappaletta cscope-tietokannasta ei lisätty"

#, c-format
msgid "E261: cscope connection %s not found"
msgstr "E261: cscope-yhteys %s puuttuu"

#, c-format
msgid "cscope connection %s closed"
msgstr "cscope-yhteys %s on katkaistu"

#. should not reach here
msgid "E570: fatal error in cs_manage_matches"
msgstr "E570: kriittinen virhe cs_manage_matches-funktiossa"

#, c-format
msgid "Cscope tag: %s"
msgstr "Cscope-tägi: %s"

msgid ""
"\n"
"   #   line"
msgstr ""
"\n"
"   #   rivi"

msgid "filename / context / line\n"
msgstr "tiedosto / konteksti / rivi\n"

#, c-format
msgid "E609: Cscope error: %s"
msgstr "E609: Cscope-virhe: %s"

msgid "All cscope databases reset"
msgstr "Kaikki cscope-tietokannat nollattu"

msgid "no cscope connections\n"
msgstr "ei cscope-yhteyksiä\n"

msgid " # pid    database name                       prepend path\n"
msgstr " # pid    tietokanta                          lisäyspolku\n"

msgid "Lua library cannot be loaded."
msgstr "Luan kirjastoa ei voitu ladata."

msgid "cannot save undo information"
msgstr "ei voitu tallentaa kumoustietoja"

msgid ""
"E815: Sorry, this command is disabled, the MzScheme libraries could not be "
"loaded."
msgstr "E815: komento ei toimi, MzScheme-kirjastoa ei voitu ladata."

msgid ""
"E895: Sorry, this command is disabled, the MzScheme's racket/base module "
"could not be loaded."
msgstr "E895: Komento ei toimi, MzScheme-moduulia racket/base ei voitu ladata."

msgid "invalid expression"
msgstr "virheellinen ilmaus"

msgid "expressions disabled at compile time"
msgstr "ilmaukset poistettu käytöstä käännösaikana"

msgid "hidden option"
msgstr "piilotettu asetus"

msgid "unknown option"
msgstr "tuntematon asetus"

msgid "window index is out of range"
msgstr "ikkunan indeksi alueen ulkopuolella"

msgid "couldn't open buffer"
msgstr "ei voitu avata puskuria"

msgid "cannot delete line"
msgstr "ei voitu poistaa riviä"

msgid "cannot replace line"
msgstr "ei voitu korvata riviä"

msgid "cannot insert line"
msgstr "ei voitu lisätä riviä"

msgid "string cannot contain newlines"
msgstr "merkkijono ei saa sisältää rivinvaihtoja"

msgid "error converting Scheme values to Vim"
msgstr "virhe Schemestä Vimiin konversiossa"

msgid "Vim error: ~a"
msgstr "Vim-virhe: ~a"

msgid "Vim error"
msgstr "Vim-virhe"

msgid "buffer is invalid"
msgstr "puskuri on virheellinen"

msgid "window is invalid"
msgstr "ikkuna on virheellinen"

msgid "linenr out of range"
msgstr "rivinumero arvoalueen ulkopuolelta"

msgid "not allowed in the Vim sandbox"
msgstr "ei sallittu Vimin hiekkalaatikossa"

msgid "E836: This Vim cannot execute :python after using :py3"
msgstr "E836: Python: Ei voi käyttää komentoja :py ja :py3 samassa istunnossa"

msgid ""
"E263: Sorry, this command is disabled, the Python library could not be "
"loaded."
msgstr ""
"E263: komento ei toimi, Python-kirjaston lataaminen ei onnistunut."

msgid ""
"E887: Sorry, this command is disabled, the Python's site module could not be "
"loaded."
msgstr ""
"E887: Komento ei toimi, Pythonin site-moduulien lataaminen ei onnistunut."

msgid "E659: Cannot invoke Python recursively"
msgstr "E659: Pythonia ei voi kutsua rekursiivisesti"

msgid "E837: This Vim cannot execute :py3 after using :python"
msgstr "E837: Python: Ei voi käyttää komentoja :py ja :py3 samassa istunnossa"

msgid "E265: $_ must be an instance of String"
msgstr "E265: muuttujan $_ pitää olla Stringin instanssi"

msgid ""
"E266: Sorry, this command is disabled, the Ruby library could not be loaded."
msgstr "E266: komento ei toimi, Ruby-kirjastoa ei voitu ladata."

msgid "E267: unexpected return"
msgstr "E267: odotuksenvastainen return"

msgid "E268: unexpected next"
msgstr "E268: Odotuksenvastainen next"

msgid "E269: unexpected break"
msgstr "E269: Odotuksenvastainen break"

msgid "E270: unexpected redo"
msgstr "E270: odotuksenvastainen redo"

msgid "E271: retry outside of rescue clause"
msgstr "E271: retry rescuen ulkopuolella"

msgid "E272: unhandled exception"
msgstr "E272: käsittelemätön poikkeus"

#, c-format
msgid "E273: unknown longjmp status %d"
msgstr "E273: tuntematon longjmp-tila %d"

msgid "invalid buffer number"
msgstr "virheellinen puskurinumero"

msgid "not implemented yet"
msgstr "ei toteutettu"

#. ???
msgid "cannot set line(s)"
msgstr "ei voi asettaa rivejä"

msgid "invalid mark name"
msgstr "virheellinen merkin nimi"

msgid "mark not set"
msgstr "merkko ei ole asetettu"

#, c-format
msgid "row %d column %d"
msgstr "rivi %d sarake %d"

msgid "cannot insert/append line"
msgstr "rivin lisäys ei onnistu"

msgid "line number out of range"
msgstr "rivinumero arvoalueen ulkopuolella"

msgid "unknown flag: "
msgstr "tuntematon asetus: "

msgid "unknown vimOption"
msgstr "tuntematon vimOption"

msgid "keyboard interrupt"
msgstr "näppäimistökeskeytys"

msgid "vim error"
msgstr "vim-virhe"

msgid "cannot create buffer/window command: object is being deleted"
msgstr "ei voi luoda puskuri- tai ikkunakomentoa, olio on poistumassa"

msgid ""
"cannot register callback command: buffer/window is already being deleted"
msgstr "callbackia ei voi rekisteröidä: puskuri tai ikkuna on poistettu"

#. This should never happen.  Famous last word?
msgid ""
"E280: TCL FATAL ERROR: reflist corrupt!? Please report this to vim-dev@vim."
"org"
msgstr ""
"E280: kriittinen TCL-virhe: reflist hajalla? Ilmoita asiasta "
"postituslistalle vim-dev@vim.org"

msgid "cannot register callback command: buffer/window reference not found"
msgstr "callbackia ei voi rekisteröidä: puskurin tai ikkunan viitettä ei löydy"

msgid ""
"E571: Sorry, this command is disabled: the Tcl library could not be loaded."
msgstr "E571: komento ei toimi, Tcl-kirjastoa ei voitu ladata."

#, c-format
msgid "E572: exit code %d"
msgstr "E572: palautusarvo %d"

msgid "cannot get line"
msgstr "ei voida hakea riviä"

msgid "Unable to register a command server name"
msgstr "Komentopalvelimen nimen rekisteröinti ei onnistu"

msgid "E248: Failed to send command to the destination program"
msgstr "E248: Komennon lähetys kohdeohjelmalle ei onnistu"

#, c-format
msgid "E573: Invalid server id used: %s"
msgstr "E573: Virheellinen palvelimen tunniste: %s"

msgid "E251: VIM instance registry property is badly formed.  Deleted!"
msgstr "E251: VIMin instanssin rekisteriarvo on virheellinen, poistettiin."

#, c-format
msgid "E696: Missing comma in List: %s"
msgstr "E696: Listasta puuttuu pilkku: %s"

#, c-format
msgid "E697: Missing end of List ']': %s"
msgstr "E697: Listan lopusta puuttuu ]: %s"

msgid "Unknown option argument"
msgstr "Tuntematon asetusargumentti"

msgid "Too many edit arguments"
msgstr "Liikaa muokkausargumentteja"

msgid "Argument missing after"
msgstr "Argumentti puuttuu kohdasta"

msgid "Garbage after option argument"
msgstr "Roskaa argumentin perässä"

msgid "Too many \"+command\", \"-c command\" or \"--cmd command\" arguments"
msgstr "Liikaa +komentoja, -c-komentoja tai --cmd-komentoja"

msgid "Invalid argument for"
msgstr "Väärä argumentti valitsimelle"

#, c-format
msgid "%d files to edit\n"
msgstr "%d tiedostoa muokattavana\n"

msgid "netbeans is not supported with this GUI\n"
msgstr "netbeans ei toimi tässä käyttöliittymässä\n"

msgid "'-nb' cannot be used: not enabled at compile time\n"
msgstr "-nb:tä ei voi käyttää, koska sitä ei käännetty mukaan\n"

msgid "This Vim was not compiled with the diff feature."
msgstr "Tähän Vimiin ei ole käännetty diff-toimintoja mukaan."

msgid "Attempt to open script file again: \""
msgstr "Yritettiin avata skriptitiedostoa uudestaan:"

msgid "Cannot open for reading: \""
msgstr "Ei voi avata luettavaksi: "

msgid "Cannot open for script output: \""
msgstr "Ei voi avata skriptin tulostetta varten: "

msgid "Vim: Error: Failure to start gvim from NetBeans\n"
msgstr "Vim: Virhe: Gvimin käynnistys NetBeansistä ei onnistu\n"

msgid "Vim: Error: This version of Vim does not run in a Cygwin terminal\n"
msgstr "Vim: Virhe: Tämä versio Vimistä ei toimi Cygwinin terminaalissa\n"

msgid "Vim: Warning: Output is not to a terminal\n"
msgstr "Vim: Varoitus: Tuloste ei mene terminaalille\n"

msgid "Vim: Warning: Input is not from a terminal\n"
msgstr "Vim: Varoitus: Syöte ei tule terminaalilta\n"

#. just in case..
msgid "pre-vimrc command line"
msgstr "esi-vimrc-komentorivi"

#, c-format
msgid "E282: Cannot read from \"%s\""
msgstr "E282: Ei voida lukea kohteesta %s"

msgid ""
"\n"
"More info with: \"vim -h\"\n"
msgstr ""
"\n"
"Lisätietoja: \"vim -h\"\n"

msgid "[file ..]       edit specified file(s)"
msgstr "[tiedosto ..]       muokkaa tiedostoja"

msgid "-               read text from stdin"
msgstr "-                   lue vakiosyötteestä"

msgid "-t tag          edit file where tag is defined"
msgstr "-t tägi             muokkaa tiedostoa tägistä"

msgid "-q [errorfile]  edit file with first error"
msgstr "-q [virhetiedosto]  muokkaa tiedostoa ensimmäisestä virheestä"

msgid ""
"\n"
"\n"
"usage:"
msgstr ""
"\n"
"\n"
"käyttö:"

msgid " vim [arguments] "
msgstr " vim [argumentit] "

msgid ""
"\n"
"   or:"
msgstr ""
"\n"
"   tai:"

msgid ""
"\n"
"Where case is ignored prepend / to make flag upper case"
msgstr ""
"\n"
"Jos aakkoslaji on ohitettu, lisää alkuun / tehdäksesi asetuksesta "
"suuraakkosia"

msgid ""
"\n"
"\n"
"Arguments:\n"
msgstr ""
"\n"
"\n"
"Argumentit:\n"

msgid "--\t\t\tOnly file names after this"
msgstr "--\t\t\tvain tiedostonimiä tämän jälkeen"

msgid "--literal\t\tDon't expand wildcards"
msgstr "--literal\t\tÄlä käsittele jokerimerkkejä "

msgid "-register\t\tRegister this gvim for OLE"
msgstr "-register\t\trekisteröi gvim OLEa varten"

msgid "-unregister\t\tUnregister gvim for OLE"
msgstr "-unregister\t\tPoista gvim OLE-rekisteristä"

msgid "-g\t\t\tRun using GUI (like \"gvim\")"
msgstr "-g\t\t\tAvaa GUI (kuten gvimillä)"

msgid "-f  or  --nofork\tForeground: Don't fork when starting GUI"
msgstr "-f tai --nofork\tEdustalle: Älä haarauta GUIn käynnistyksessä"

msgid "-v\t\t\tVi mode (like \"vi\")"
msgstr "-v\t\t\tVi-tila (kuten villä)"

msgid "-e\t\t\tEx mode (like \"ex\")"
msgstr "-e\t\t\tEx-tila (kute exillä)"

msgid "-E\t\t\tImproved Ex mode"
msgstr "-E\t\t\tParanneltu Ex-tila"

msgid "-s\t\t\tSilent (batch) mode (only for \"ex\")"
msgstr "-s\t\t\tHiljainen (eräajo)tila (vain exillä)"

msgid "-d\t\t\tDiff mode (like \"vimdiff\")"
msgstr "-d\t\t\tDiff-tila (kuten vimdiffillä)"

msgid "-y\t\t\tEasy mode (like \"evim\", modeless)"
msgstr "-y\t\t\tHelppokäyttötila (kuten evimissä, ilman tiloja)"

msgid "-R\t\t\tReadonly mode (like \"view\")"
msgstr "-R\t\t\tKirjoitussuojattu tila (kuten view'lla)"

msgid "-Z\t\t\tRestricted mode (like \"rvim\")"
msgstr "-Z\t\t\tRajoitettu tila (kuten rvimillä)"

msgid "-m\t\t\tModifications (writing files) not allowed"
msgstr "-m\t\t\tMuokkaukset (kirjoittaminen tiedostoon) pois käytöstä"

msgid "-M\t\t\tModifications in text not allowed"
msgstr "-M\t\t\tTekstin muokkaus pois käytöstä"

msgid "-b\t\t\tBinary mode"
msgstr "-b\t\t\tBinääritila"

msgid "-l\t\t\tLisp mode"
msgstr "-l\t\t\tLisp-tila"

msgid "-C\t\t\tCompatible with Vi: 'compatible'"
msgstr "-C\t\t\tVi-yhteensopivuustila: compatible"

msgid "-N\t\t\tNot fully Vi compatible: 'nocompatible'"
msgstr "-N\t\t\tEi Vi-yhteensopivuutta: nocompatible"

msgid "-V[N][fname]\t\tBe verbose [level N] [log messages to fname]"
msgstr ""
"-V[N][tnimi]\t\tMonisanainen tuloste [Taso N] [kirjoita tuloste tnimeen] "

msgid "-D\t\t\tDebugging mode"
msgstr "-D\t\t\tVianetsintätila"

msgid "-n\t\t\tNo swap file, use memory only"
msgstr "-n\t\t\tEi swap-tiedostoja, käytä muistia"

msgid "-r\t\t\tList swap files and exit"
msgstr "-r\t\t\tLuetteloi swap-tiedostot ja poistu"

msgid "-r (with file name)\tRecover crashed session"
msgstr "-r (tiedostonimi)\tPalauta kaatunut sessio"

msgid "-L\t\t\tSame as -r"
msgstr "-L\t\t\tkuten -r"

msgid "-f\t\t\tDon't use newcli to open window"
msgstr "-f\t\t\tÄlä käytä newcli:tä ikkunan avaamiseen"

msgid "-dev <device>\t\tUse <device> for I/O"
msgstr "-dev <laite>\t\tKäytä <laitetta> IO:hon"

msgid "-A\t\t\tstart in Arabic mode"
msgstr "-A\t\t\tkäynnistä arabia-tilassa"

msgid "-H\t\t\tStart in Hebrew mode"
msgstr "-H\t\t\tkäynnistä heprea-tilassa"

msgid "-F\t\t\tStart in Farsi mode"
msgstr "-F\t\t\tkäynnistä farsi-tilassa"

msgid "-T <terminal>\tSet terminal type to <terminal>"
msgstr "-T <terminaali>\tAseta terminaalin tyypiksi <terminaali>"

msgid "--not-a-term\t\tSkip warning for input/output not being a terminal"
msgstr "--not-a-term\t\tOhita varoitus siitä että i/o ei ole terminaali"

msgid "-u <vimrc>\t\tUse <vimrc> instead of any .vimrc"
msgstr "-u <vimrc>\t\tKäytä <vimrc>-tiedostoa .vimrc:iden sijasta"

msgid "-U <gvimrc>\t\tUse <gvimrc> instead of any .gvimrc"
msgstr "-U <gvimrc>\t\tKäytä <gvimrc>-tiedostoa .gvimrc:iden sijasta"

msgid "--noplugin\t\tDon't load plugin scripts"
msgstr "--noplugin\t\tÄlä lataa liitännäisiä"

msgid "-p[N]\t\tOpen N tab pages (default: one for each file)"
msgstr "-p[N]\t\tAvaa N välilehteä (oletus: yksi per tiedosto)"

msgid "-o[N]\t\tOpen N windows (default: one for each file)"
msgstr "-o[N]\t\tAvaa N ikkunaa (oletus: yksi per tiedosto)"

msgid "-O[N]\t\tLike -o but split vertically"
msgstr "-O[N]\t\tKuten -o, mutta jaa pystysuunnassa"

msgid "+\t\t\tStart at end of file"
msgstr "+\t\t\tAloita tiedoston lopusta"

msgid "+<lnum>\t\tStart at line <lnum>"
msgstr "+<rivi>\t\t\tAloita riviltä <rivi>"

msgid "--cmd <command>\tExecute <command> before loading any vimrc file"
msgstr "--cmd <komento>\tSuorita <komento> ennen vimrc:iden latausta"

msgid "-c <command>\t\tExecute <command> after loading the first file"
msgstr "-c <komento>\t\tSuorita <komento> ensimmäisen tiedoston latauduttua"

msgid "-S <session>\t\tSource file <session> after loading the first file"
msgstr "-S <sessio>\t\tLataa <sessio> ensimmäisen tiedoston latauduttua"

msgid "-s <scriptin>\tRead Normal mode commands from file <scriptin>"
msgstr "-s <skripti>\tLue normaalitilan komentoja <skripti>-tiedostosta"

msgid "-w <scriptout>\tAppend all typed commands to file <scriptout>"
msgstr "-w <skripti>\tLisää kirjoitetut komennot <skripti>-tiedostoon"

msgid "-W <scriptout>\tWrite all typed commands to file <scriptout>"
msgstr "-W <skripti>\tKirjoita komennot <skripti>-tiedostoon"

msgid "-x\t\t\tEdit encrypted files"
msgstr "-x\t\t\tMuokkaa salattua tiedostoa"

msgid "-display <display>\tConnect vim to this particular X-server"
msgstr "-display <näyttö>\tYhdistä vim tiettyyn X-palvelimeen"

msgid "-X\t\t\tDo not connect to X server"
msgstr "-X\t\t\tÄlä yhdistä X-palvelimeen"

msgid "--remote <files>\tEdit <files> in a Vim server if possible"
msgstr ""
"--remote <tiedostoja>\tMuokkaa <tiedostoja> Vim-palvelimessa, jos mahdollista"

msgid "--remote-silent <files>  Same, don't complain if there is no server"
msgstr ""
"--remote-silent <tiedostoja>\tSama, mutta älä ilmoita puuttuvasta "
"palvelimesta"

msgid ""
"--remote-wait <files>  As --remote but wait for files to have been edited"
msgstr ""
"--remote-wait <tiedostoja>  kuten --remote, mutta odota tiedostojen "
"muokkaamista"

msgid ""
"--remote-wait-silent <files>  Same, don't complain if there is no server"
msgstr ""
"--remote-wait-silent <tiedostoja>  sama, mutta älä ilmoita puuttuvasta "
"palvelimesta"

msgid ""
"--remote-tab[-wait][-silent] <files>  As --remote but use tab page per file"
msgstr ""
"--remote-tab[-wait][-silent] <tiedostoja>  kuten --remote, mutta avaa "
"välilehti joka tiedostolle"

msgid "--remote-send <keys>\tSend <keys> to a Vim server and exit"
msgstr ""
"--remote-send <näppäimiä>\tLähetä <näppäimiä> painalluksina Vimille ja lopeta"

msgid "--remote-expr <expr>\tEvaluate <expr> in a Vim server and print result"
msgstr ""
"--remote-expr <ilmaus>\tKäsittele <ilmaus> Vim-palvelimella ja tulosta tulos"

msgid "--serverlist\t\tList available Vim server names and exit"
msgstr "--serverlist\t\tLuettele Vim-palvelinten nimet ja lopeta"

msgid "--servername <name>\tSend to/become the Vim server <name>"
msgstr "--servername <nimi>\tLähetä Vim-palvelimelle <nimi> tai luo se"

msgid "--startuptime <file>\tWrite startup timing messages to <file>"
msgstr "--startuptime <file>\tKirjoita käynnistysaikaviestit tiedostoon <file>"

msgid "-i <viminfo>\t\tUse <viminfo> instead of .viminfo"
msgstr "-i <viminfo>\t\tKäytä <viminfo>-tiedostoa .viminfon sijaan"

msgid "-h  or  --help\tPrint Help (this message) and exit"
msgstr "-h tai --help\tTulosta ohje (tämä viesti) ja lopeta"

msgid "--version\t\tPrint version information and exit"
msgstr "--version\t\t\tTulosta versiotiedot ja lopeta"

msgid ""
"\n"
"Arguments recognised by gvim (Motif version):\n"
msgstr ""
"\n"
"Gvimin (Motif-version) tuntemat argumentit:\n"

msgid ""
"\n"
"Arguments recognised by gvim (neXtaw version):\n"
msgstr ""
"\n"
"Gvimin (neXtaw-version) tuntemat argumentit:\n"

msgid ""
"\n"
"Arguments recognised by gvim (Athena version):\n"
msgstr ""
"\n"
"Gvimin (Athena-version) tuntemat argumentit:\n"

msgid "-display <display>\tRun vim on <display>"
msgstr "-display <näyttö>\tSuorita vim <näytössä>"

msgid "-iconic\t\tStart vim iconified"
msgstr "-iconic\t\tKäynnistä pienennettynä"

msgid "-background <color>\tUse <color> for the background (also: -bg)"
msgstr "-background <väri>\tKäytä <väriä> taustavärinä (myös: -bg)"

msgid "-foreground <color>\tUse <color> for normal text (also: -fg)"
msgstr "-foreground <väri>\tKäytä <väriä> tekstin värinä (myös: -fg)"

msgid "-font <font>\t\tUse <font> for normal text (also: -fn)"
msgstr "-font <fontti>\t\tKäytä <fonttia> tekstissä (myös: -fn)"

msgid "-boldfont <font>\tUse <font> for bold text"
msgstr "-boldfont <fontti>\tKäytä <fonttia> lihavoidussa tekstissä"

msgid "-italicfont <font>\tUse <font> for italic text"
msgstr "-italicfont <fontti>\tKäytä <fonttia> kursivoidussa tekstissä"

msgid "-geometry <geom>\tUse <geom> for initial geometry (also: -geom)"
msgstr ""
"-geometry <geom>\tKäytä mittoja <geom> ikkunan asetteluun (myös: -geom)"

msgid "-borderwidth <width>\tUse a border width of <width> (also: -bw)"
msgstr "-borderwidt <leveys>\tKäytä <leveyttä> reunuksissa (myös: -bw) "

msgid "-scrollbarwidth <width>  Use a scrollbar width of <width> (also: -sw)"
msgstr ""
"-scrollbarwidth <leveys>  Käytä <leveyttä> vierityspalkissa (myös: -sw)"

msgid "-menuheight <height>\tUse a menu bar height of <height> (also: -mh)"
msgstr "-menuheight <korkeus>\tKäytä <korkeutta> valikossa (myös: -mh)"

msgid "-reverse\t\tUse reverse video (also: -rv)"
msgstr "-reverse\t\tKäytä käänteisvärejä (myös: -rv) "

msgid "+reverse\t\tDon't use reverse video (also: +rv)"
msgstr "+reverse\t\tÄlä käytä käänteisvärejä (myös: +rv)"

msgid "-xrm <resource>\tSet the specified resource"
msgstr "-xrm <resurssi>\tAseta resurssi"

msgid ""
"\n"
"Arguments recognised by gvim (GTK+ version):\n"
msgstr ""
"\n"
"Gvimin (GTK+-version) tuntemat argumentit:\n"

msgid "-display <display>\tRun vim on <display> (also: --display)"
msgstr "-display <näyttö>\tSuorita vim näytöllä <näyttö> (myös: --display)"

# X-ikkunointijärjestelmässä saman sovelluksen saman luokan ikkunat
# tunnistetaan rooliresursseista
msgid "--role <role>\tSet a unique role to identify the main window"
msgstr "--role <rooli>\tAseta pääikkunalle ainutlaatuinen rooli tunnisteeksi"

msgid "--socketid <xid>\tOpen Vim inside another GTK widget"
msgstr "--socketid <xid>\tAvaa Vim annettuun GTK-olioon "

msgid "--echo-wid\t\tMake gvim echo the Window ID on stdout"
msgstr "--echo-wid\t\tTulosta gvimin Window ID vakiotulosteeseen"

msgid "-P <parent title>\tOpen Vim inside parent application"
msgstr "-P <otsikko>\tAvaa Vim isäntäohjelman sisään"

msgid "--windowid <HWND>\tOpen Vim inside another win32 widget"
msgstr "--windowid <HWND>\tAvaa Vim annettuun win32-olioon "

msgid "No display"
msgstr "Ei näyttöä"

#. Failed to send, abort.
msgid ": Send failed.\n"
msgstr ": Lähetys epäonnistui.\n"

#. Let vim start normally.
msgid ": Send failed. Trying to execute locally\n"
msgstr ": Lähetys epäonnistui. Yritetään suorittaa paikallisena\n"

#, c-format
msgid "%d of %d edited"
msgstr "%d/%d muokattu"

msgid "No display: Send expression failed.\n"
msgstr "Ei näyttöä: Ilmauksen lähetys epäonnistui.\n"

msgid ": Send expression failed.\n"
msgstr ": Ilmauksen lähetys epäonnistui.\n"

msgid "No marks set"
msgstr "Ei asetettuja merkkejä"

#, c-format
msgid "E283: No marks matching \"%s\""
msgstr "E283: Mikään merkki ei täsmää ilmaukseen \"%s\""

#. Highlight title
msgid ""
"\n"
"mark line  col file/text"
msgstr ""
"\n"
"merkki rivi sarake tiedosto/teksti"

#. Highlight title
msgid ""
"\n"
" jump line  col file/text"
msgstr ""
"\n"
"hyppy rivi sarake tiedosto/teksti"

#. Highlight title
msgid ""
"\n"
"change line  col text"
msgstr ""
"\n"
"muutos rivi sarake teksti"

msgid ""
"\n"
"# File marks:\n"
msgstr ""
"\n"
"# Tiedoston merkit:\n"

#. Write the jumplist with -'
msgid ""
"\n"
"# Jumplist (newest first):\n"
msgstr ""
"\n"
"# Hyppylista (uusin ensiksi):\n"

msgid ""
"\n"
"# History of marks within files (newest to oldest):\n"
msgstr ""
"\n"
"# Tiedostojen merkkien historia (uusimmasta vanhimpaan):\n"

msgid "Missing '>'"
msgstr "> puuttuu"

msgid "E543: Not a valid codepage"
msgstr "E543: Koodisivu ei ole käypä"

msgid "E284: Cannot set IC values"
msgstr "E284: Ei voi asettaa IC-arvoja"

msgid "E285: Failed to create input context"
msgstr "E285: Syötekontekstin luonti ei onnistu"

msgid "E286: Failed to open input method"
msgstr "E286: Syötemetodin avaus ei onnistu"

msgid "E287: Warning: Could not set destroy callback to IM"
msgstr ""
"E287: Varoitus: Ei voitu asettaa destroy-kutsua syötemetodipalvelimelle"

msgid "E288: input method doesn't support any style"
msgstr "E288: syötemetodi ei tue tyylejä"

msgid "E289: input method doesn't support my preedit type"
msgstr "E289: syötemetodi ei tue tätä preedit-tyyppiä"

msgid "E293: block was not locked"
msgstr "E293: lohkoa ei ole lukittu"

msgid "E294: Seek error in swap file read"
msgstr "E294: Hakuvirhe swap-tiedostoa luettaessa"

msgid "E295: Read error in swap file"
msgstr "E295: Lukuvirhe swap-tiedostossa"

msgid "E296: Seek error in swap file write"
msgstr "E296: Hakuvirhe swap-tiedostoa kirjoitettaessa"

msgid "E297: Write error in swap file"
msgstr "E297: Kirjoitusvirhe swap-tiedostossa"

msgid "E300: Swap file already exists (symlink attack?)"
msgstr "E300: Swaptiedosto on jo olemassa (symlink-hyökkäys?)"

msgid "E298: Didn't get block nr 0?"
msgstr "E298: Lohko 0:aa ei saatu?"

msgid "E298: Didn't get block nr 1?"
msgstr "E298: Lohko 1:tä ei saatu?"

msgid "E298: Didn't get block nr 2?"
msgstr "E298: Lohko 2:ta ei saatu?"

msgid "E843: Error while updating swap file crypt"
msgstr "E843: Virhe päivitettäessä swapin kryptausta"

#. could not (re)open the swap file, what can we do????
msgid "E301: Oops, lost the swap file!!!"
msgstr "E301: Hups, swap-tiedosto hävisi!"

msgid "E302: Could not rename swap file"
msgstr "E302: Swap-tiedoston uudellennimeys ei onnistu"

#, c-format
msgid "E303: Unable to open swap file for \"%s\", recovery impossible"
msgstr "E303: Swap-tiedostoa %s ei voi avata, palautus ei onnistu"

msgid "E304: ml_upd_block0(): Didn't get block 0??"
msgstr "E304: ml_upd_block0(): Lohko 0:aa ei saatu?"

#, c-format
msgid "E305: No swap file found for %s"
msgstr "E305: Ei swap-tiedostoa tiedostolle %s"

msgid "Enter number of swap file to use (0 to quit): "
msgstr "Anna swap-tiedoston numero tai 0 lopettaaksesi: "

#, c-format
msgid "E306: Cannot open %s"
msgstr "E306: Ei voi avata tiedostoa %s"

msgid "Unable to read block 0 from "
msgstr "Ei voi lukea lohkoa 0 kohteesta "

msgid ""
"\n"
"Maybe no changes were made or Vim did not update the swap file."
msgstr ""
"\n"
"Muutoksia ei tehty, tai Vim ei päivittänyt swap-tiedostoa."

msgid " cannot be used with this version of Vim.\n"
msgstr " ei toimi tämän version Vimin kanssa.\n"

msgid "Use Vim version 3.0.\n"
msgstr "Käytä Vimin versiota 3.0\n"

#, c-format
msgid "E307: %s does not look like a Vim swap file"
msgstr "E307: %s ei ole Vimin swap-tiedosto"

msgid " cannot be used on this computer.\n"
msgstr " ei toimi tällä koneella.\n"

msgid "The file was created on "
msgstr "Tiedosto luotiin "

msgid ""
",\n"
"or the file has been damaged."
msgstr ""
",\n"
"tai tiedosto on vahingoittunut."

#, c-format
msgid ""
"E833: %s is encrypted and this version of Vim does not support encryption"
msgstr "E833: %s on salattu eikä tämä Vim tue salausta"

msgid " has been damaged (page size is smaller than minimum value).\n"
msgstr " on vioittunut (sivun koko on vähimmäisarvoa pienempi).\n"

#, c-format
msgid "Using swap file \"%s\""
msgstr "Käytetään swap-tiedostoa %s"

#, c-format
msgid "Original file \"%s\""
msgstr "Alkuperäinen tiedosto %s"

msgid "E308: Warning: Original file may have been changed"
msgstr "E308: Varoitus: Alkuperäistä tiedostoa saattaa olla muutettu"

#, c-format
msgid "Swap file is encrypted: \"%s\""
msgstr "Swap-tiedosto on salattu: %s"

msgid ""
"\n"
"If you entered a new crypt key but did not write the text file,"
msgstr ""
"\n"
"Jos käytit uutta salausavainta muttet kirjoittanut tekstitiedostoa,"

msgid ""
"\n"
"enter the new crypt key."
msgstr ""
"\n"
"anna uusi salausavain."

msgid ""
"\n"
"If you wrote the text file after changing the crypt key press enter"
msgstr ""
"\n"
"Jos kirjoitit tekstitiedoston salausavaimen vaihdon jälkeen paina enteriä"

msgid ""
"\n"
"to use the same key for text file and swap file"
msgstr ""
"\n"
"käyttääksesi samaa avainta teksti- ja swäppitiedostoille"

#, c-format
msgid "E309: Unable to read block 1 from %s"
msgstr "E309: Ei voitu lukea lohkoa 1 tiedostosta %s"

msgid "???MANY LINES MISSING"
msgstr "???PALJON RIVEJÄ PUUTTUU"

msgid "???LINE COUNT WRONG"
msgstr "???RIVIMÄÄRÄ PIELESSÄ"

msgid "???EMPTY BLOCK"
msgstr "???TYHJÄ LOHKO"

msgid "???LINES MISSING"
msgstr "???RIVEJÄ PUUTTUU"

#, c-format
msgid "E310: Block 1 ID wrong (%s not a .swp file?)"
msgstr "E310: Lohon 1 tunniste väärä (%s ei ole .swp-tiedosto?)"

msgid "???BLOCK MISSING"
msgstr "???LOHKO PUUTTUU"

msgid "??? from here until ???END lines may be messed up"
msgstr "??? tästä kohtaan ???LOPPU rivejä sekaisin"

msgid "??? from here until ???END lines may have been inserted/deleted"
msgstr "??? tästä kohtaan ???LOPPU rivejä saattaa olla lisätty tai poistettu"

msgid "???END"
msgstr "???LOPPU"

msgid "E311: Recovery Interrupted"
msgstr "E311: Palautus keskeytetty"

msgid ""
"E312: Errors detected while recovering; look for lines starting with ???"
msgstr "E312: Palautuksessa oli virheitä, etsi rivejä, jotka alkavat ???"

msgid "See \":help E312\" for more information."
msgstr ":help E312 kertoo lisätietoja"

msgid "Recovery completed. You should check if everything is OK."
msgstr "Palautus onnistui. Tarkista, että kaikki on kunnossa."

msgid ""
"\n"
"(You might want to write out this file under another name\n"
msgstr ""
"\n"
"(Saattaa kannattaa kirjoittaa tämä tiedosto toisella nimellä\n"

msgid "and run diff with the original file to check for changes)"
msgstr "ja katso diffillä muutokset alkuperäiseen tiedostoon)"

msgid "Recovery completed. Buffer contents equals file contents."
msgstr "Palautus onnistui. Puskurin ja tiedoston sisällöt täsmäävät."

msgid ""
"\n"
"You may want to delete the .swp file now.\n"
"\n"
msgstr ""
"\n"
"Voit poistaa .swp-tiedosto nyt.\n"
"\n"

msgid "Using crypt key from swap file for the text file.\n"
msgstr "Käytetään swäpin salausavainta tekstitiedostolle\n"

#. use msg() to start the scrolling properly
msgid "Swap files found:"
msgstr "Swap-tiedostoja löytyi:"

msgid "   In current directory:\n"
msgstr "   Tässä hakemistossa:\n"

msgid "   Using specified name:\n"
msgstr "   Määritellyllä nimellä:\n"

msgid "   In directory "
msgstr "   Hakemistossa "

msgid "      -- none --\n"
msgstr " -- ei mitään --\n"

msgid "          owned by: "
msgstr "          omistaja: "

msgid "   dated: "
msgstr "  ajalta: "

msgid "             dated: "
msgstr "            ajalta:"

msgid "         [from Vim version 3.0]"
msgstr "         [Vimin 3.0-versiosta]"

msgid "         [does not look like a Vim swap file]"
msgstr "         [ei näytä Vimin swap-tiedostolta]"

msgid "         file name: "
msgstr "      tiedostonimi: "

msgid ""
"\n"
"          modified: "
msgstr ""
"\n"
"          muokattu: "

msgid "YES"
msgstr "KYLLÄ"

msgid "no"
msgstr "ei"

msgid ""
"\n"
"         user name: "
msgstr ""
"\n"
"         käyttäjänimi: "

msgid "   host name: "
msgstr "   laitenimi: "

msgid ""
"\n"
"         host name: "
msgstr ""
"\n"
"         laitenimi: "

msgid ""
"\n"
"        process ID: "
msgstr ""
"\n"
"        prosessin tunniste: "

msgid " (still running)"
msgstr " (käynnissä)"

msgid ""
"\n"
"         [not usable with this version of Vim]"
msgstr ""
"\n"
"         [ei toimi tämän Vim-version kanssa]"

msgid ""
"\n"
"         [not usable on this computer]"
msgstr ""
"\n"
"         [ei toimi tällä koneella]"

msgid "         [cannot be read]"
msgstr "         [ei voi lukea]"

msgid "         [cannot be opened]"
msgstr "         [ei voi avata]"

msgid "E313: Cannot preserve, there is no swap file"
msgstr "E313: Ei voi säilyttää, swap-tiedostoa ei ole"

msgid "File preserved"
msgstr "Tiedosto säilytetty"

msgid "E314: Preserve failed"
msgstr "E314: Säilyttäminen epäonnistui"

#, c-format
msgid "E315: ml_get: invalid lnum: %ld"
msgstr "E315: ml_get: virheellinen lnum: %ld"

#, c-format
msgid "E316: ml_get: cannot find line %ld"
msgstr "E316: ml_get: riviä %ld ei löydy"

msgid "E317: pointer block id wrong 3"
msgstr "E317: osoitinlohkon tunnus väärä 3"

msgid "stack_idx should be 0"
msgstr "stack_idx pitää olla 0"

msgid "E318: Updated too many blocks?"
msgstr "E318: Päivitetty liikaa lohkoja"

msgid "E317: pointer block id wrong 4"
msgstr "E317: osoitinlohkon tunnus väärä 4"

msgid "deleted block 1?"
msgstr "poistettu lohko 1?"

#, c-format
msgid "E320: Cannot find line %ld"
msgstr "E320: Riviä %ld ei löydy"

msgid "E317: pointer block id wrong"
msgstr "E317: osoitinlohkon tunnus väärä"

msgid "pe_line_count is zero"
msgstr "pe_line_count on nolla"

#, c-format
msgid "E322: line number out of range: %ld past the end"
msgstr "E322: rivinumero arvoalueen ulkopuoleta: %ld on loppua suurempi"

#, c-format
msgid "E323: line count wrong in block %ld"
msgstr "E323: rivimäärä väärin lohkossa %ld"

msgid "Stack size increases"
msgstr "Pinon koko kasvaa"

msgid "E317: pointer block id wrong 2"
msgstr "E317: osoitinlohon tunnus väärä 2"

#, c-format
msgid "E773: Symlink loop for \"%s\""
msgstr "E773: Symlinkkisilmukka kohteelle %s"

msgid "E325: ATTENTION"
msgstr "E325: HUOMAA"

msgid ""
"\n"
"Found a swap file by the name \""
msgstr ""
"\n"
"Swap-tiedosto löytyi: \""

msgid "While opening file \""
msgstr "Avattaessa tiedostoa "

msgid "      NEWER than swap file!\n"
msgstr "   joka on UUDEMPI kuin swap-tiedosto!\n"

#. Some of these messages are long to allow translation to
#. * other languages.
msgid ""
"\n"
"(1) Another program may be editing the same file.  If this is the case,\n"
"    be careful not to end up with two different instances of the same\n"
"    file when making changes.  Quit, or continue with caution.\n"
msgstr ""
"\n"
"(1) Toinen ohjelma saattaa käyttää samaa tiedostoa.\n"
"    Jos näin on, varo, ettet muokkaa saman tiedoston\n"
"    kahta instanssia yhtä aikaa. Lopeta tai jatka varoen.\n"

msgid "(2) An edit session for this file crashed.\n"
msgstr "(2) Tiedostonmuokkausistunto on kaatunut.\n"

msgid "    If this is the case, use \":recover\" or \"vim -r "
msgstr "    Jos näin on, käytä komentoa :recover tai vim -r "

msgid ""
"\"\n"
"    to recover the changes (see \":help recovery\").\n"
msgstr ""
"\"\n"
"    palauttaaksesi muutokset (lisätietoja: \":help recovery\").\n"

msgid "    If you did this already, delete the swap file \""
msgstr "    Jos teit jo näin, poista swap-tiedosto "

msgid ""
"\"\n"
"    to avoid this message.\n"
msgstr ""
"\"\n"
"    välttääksesi tämän viestin.\n"

msgid "Swap file \""
msgstr "Swap-tiedosto "

msgid "\" already exists!"
msgstr " on jo olemassa"

msgid "VIM - ATTENTION"
msgstr "VIM - HUOMAUTUS"

msgid "Swap file already exists!"
msgstr "Swap-tiedosto on jo olemassa"

msgid ""
"&Open Read-Only\n"
"&Edit anyway\n"
"&Recover\n"
"&Quit\n"
"&Abort"
msgstr ""
"&Avaa kirjoitussuojattuna\n"
"&Muokkaa\n"
"&Palauta\n"
"&Lopeta\n"
"P&eru"

msgid ""
"&Open Read-Only\n"
"&Edit anyway\n"
"&Recover\n"
"&Delete it\n"
"&Quit\n"
"&Abort"
msgstr ""
"&Avaa kirjoitussuojattuna\n"
"&Muokkaa\n"
"&Palauta\n"
"P&oista\n"
"&Lopeta\n"
"P&eru"

msgid "E326: Too many swap files found"
msgstr "E326: Liian monta swap-tiedostoa"

msgid "E327: Part of menu-item path is not sub-menu"
msgstr "E327: Valikkokohtapolun osa ei ole alivalikko"

msgid "E328: Menu only exists in another mode"
msgstr "E328: Valikko on olemassa vain toisessa tilassa"

#, c-format
msgid "E329: No menu \"%s\""
msgstr "E329: Ei valikkoa %s"

#. Only a mnemonic or accelerator is not valid.
msgid "E792: Empty menu name"
msgstr "E792: tyhjä valikkonimi"

msgid "E330: Menu path must not lead to a sub-menu"
msgstr "E330: Valikkopolku ei saa johtaa alivalikkoon"

msgid "E331: Must not add menu items directly to menu bar"
msgstr "E331: Valikkokohtia ei saa lisätä suoraan valikkopalkkiin"

msgid "E332: Separator cannot be part of a menu path"
msgstr "E332: Erotin ei voi olla valikkopolun osa"

#. Now we have found the matching menu, and we list the mappings
#. Highlight title
msgid ""
"\n"
"--- Menus ---"
msgstr ""
"\n"
"--- Valikot ---"

msgid "Tear off this menu"
msgstr "Repäise valikko irti"

msgid "E333: Menu path must lead to a menu item"
msgstr "E333: Valikkopolun on johdettava valikkokohtaan"

#, c-format
msgid "E334: Menu not found: %s"
msgstr "E334: Valikkoa ei löydy: %s"

#, c-format
msgid "E335: Menu not defined for %s mode"
msgstr "E335: Valikkoa ei ole määritelty %s-tilassa"

msgid "E336: Menu path must lead to a sub-menu"
msgstr "E336: Valikkopolun pitää johtaa alivalikkoon"

msgid "E337: Menu not found - check menu names"
msgstr "E337: Valikkoa ei löytynyt - tarkista valikkojen nimet"

#, c-format
msgid "Error detected while processing %s:"
msgstr "Virhe suoritettaessa komentoja %s:"

#, c-format
msgid "line %4ld:"
msgstr "rivi %4ld:"

#, c-format
msgid "E354: Invalid register name: '%s'"
msgstr "E354: Virheellinen rekisterin nimi: %s"

msgid "Messages maintainer: Bram Moolenaar <Bram@vim.org>"
msgstr "Käännöksen ylläpitäjä: Flammie Pirinen <flammie@iki.fi>"

msgid "Interrupt: "
msgstr "Keskeytys: "

msgid "Press ENTER or type command to continue"
msgstr "Paina enteriä tai kirjoita komento aloittaaksesi "

#, c-format
msgid "%s line %ld"
msgstr "%s rivi %ld"

msgid "-- More --"
msgstr "-- Lisää --"

msgid " SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "
msgstr " SPACE/d/j: ruutu/sivu/rivi alas, b/u/k: ylös, q: lopeta "

msgid "Question"
msgstr "Kysymys"

msgid ""
"&Yes\n"
"&No"
msgstr ""
"&Kyllä\n"
"&Ei"

msgid ""
"&Yes\n"
"&No\n"
"Save &All\n"
"&Discard All\n"
"&Cancel"
msgstr ""
"&Kyllä\n"
"&Ei\n"
"&Tallenna kaikki\n"
"T&uhoa kaikki\n"
"&Peru"

msgid "Select Directory dialog"
msgstr "Hakemiston valintaikkuna"

msgid "Save File dialog"
msgstr "Tallennusikkuna"

msgid "Open File dialog"
msgstr "Avausikkuna"

#. TODO: non-GUI file selector here
msgid "E338: Sorry, no file browser in console mode"
msgstr "E338: tiedostonselain puuttuu konsolitilasta"

msgid "E766: Insufficient arguments for printf()"
msgstr "E766: printf():lle ei annettu tarpeeksi argumentteja"

msgid "E807: Expected Float argument for printf()"
msgstr "E807: Odotettiin Float-argumenttia printf():lle"

msgid "E767: Too many arguments to printf()"
msgstr "E767: printf():lle annettiin liikaa argumentteja"

msgid "W10: Warning: Changing a readonly file"
msgstr "W10: Varoitus: Muutetaan kirjoitussuojattua tiedostoa"

msgid "Type number and <Enter> or click with mouse (empty cancels): "
msgstr "Kirjoita numero ja <Enter> tai valitse hiirellä (tyhjä peruu): "

msgid "Type number and <Enter> (empty cancels): "
msgstr "Valitse numero ja <Enter> (tyhjä peruu): "

msgid "1 more line"
msgstr "1 rivi lisää"

msgid "1 line less"
msgstr "1 rivi vähemmän"

#, c-format
msgid "%ld more lines"
msgstr "%ld riviä lisää"

#, c-format
msgid "%ld fewer lines"
msgstr "%ld riviä vähemmän"

msgid " (Interrupted)"
msgstr " (Keskeytetty)"

msgid "Beep!"
msgstr "Piip!"

msgid "ERROR: "
msgstr "VIRHE: "

#, c-format
msgid ""
"\n"
"[bytes] total alloc-freed %lu-%lu, in use %lu, peak use %lu\n"
msgstr ""
"\n"
"[tavua] yht. alloc-free %lu-%lu, käytössä %lu, käyttöhuippu %lu\n"

#, c-format
msgid ""
"[calls] total re/malloc()'s %lu, total free()'s %lu\n"
"\n"
msgstr ""
"[kutsut] yht. re/malloc() %lu, yht. free() %lu\n"
"\n"

msgid "E340: Line is becoming too long"
msgstr "E340: Rivistä tulee liian pitkä"

#, c-format
msgid "E341: Internal error: lalloc(%ld, )"
msgstr "E341: Sisäinen virhe: lalloc(%ld, )"

#, c-format
msgid "E342: Out of memory!  (allocating %lu bytes)"
msgstr "E342: Muisti loppui! (varattaessa %lu tavua)"

#, c-format
msgid "Calling shell to execute: \"%s\""
msgstr "Kutsutaan kuorta suorittamaan: %s"

msgid "E545: Missing colon"
msgstr "E545: Kaksoispiste puuttuu"

msgid "E546: Illegal mode"
msgstr "E546: Virheellinen tila"

msgid "E547: Illegal mouseshape"
msgstr "E547: Virheellinen hiiren muoto"

msgid "E548: digit expected"
msgstr "E548: pitää olla numero"

msgid "E549: Illegal percentage"
msgstr "E549: Virheellinen prosenttiluku"

msgid "E854: path too long for completion"
msgstr "E854: polku on liian pitkä täydennykseen"

#, c-format
msgid ""
"E343: Invalid path: '**[number]' must be at the end of the path or be "
"followed by '%s'."
msgstr ""
"E343: Virheellinen polku: '**[numero]' kuuluu polun loppuun tai ennen kohtaa "
"%s."

#, c-format
msgid "E344: Can't find directory \"%s\" in cdpath"
msgstr "E344: Hakemistoa %s ei löydy cdpathista"

#, c-format
msgid "E345: Can't find file \"%s\" in path"
msgstr "E345: Tiedostoa %s ei löydy polulta"

#, c-format
msgid "E346: No more directory \"%s\" found in cdpath"
msgstr "E346: Hakemisto %s ei ole enää cdpathissa"

#, c-format
msgid "E347: No more file \"%s\" found in path"
msgstr "E347: Tiedosto %s ei ole enää polulla"

#, c-format
msgid "E668: Wrong access mode for NetBeans connection info file: \"%s\""
msgstr "E668: Väärä avaustila NetBeans-yhteyden infotiedostolle: %s"

#, c-format
msgid "E658: NetBeans connection lost for buffer %ld"
msgstr "E658: NetBeans-yhteys katkesi puskurille %ld"

msgid "E838: netbeans is not supported with this GUI"
msgstr "E838: netbeans ei toimi tässä käyttöliittymässä"

msgid "E511: netbeans already connected"
msgstr "E511: netbeans on yhdistetty jo"

#, c-format
msgid "E505: %s is read-only (add ! to override)"
msgstr "E505: %s on kirjoitussuojattu (lisää komentoon ! ohittaaksesi)"

msgid "E349: No identifier under cursor"
msgstr "E349: Ei tunnistetta osoittimen alla"

msgid "E774: 'operatorfunc' is empty"
msgstr "E774: operatorfunc on tyhjä"

msgid "E775: Eval feature not available"
msgstr "E775: Eval ei ole käytettävissä"

msgid "Warning: terminal cannot highlight"
msgstr "Varoitus: terminaalista puuttuu korostus"

msgid "E348: No string under cursor"
msgstr "E348: Ei merkkijonoa kursorin alla"

msgid "E352: Cannot erase folds with current 'foldmethod'"
msgstr "E352: taitoksia ei voi poistaa tällä foldmethodilla"

msgid "E664: changelist is empty"
msgstr "E664: muutoslista on tyhjä"

msgid "E662: At start of changelist"
msgstr "E662: Muutoslistan alussa"

msgid "E663: At end of changelist"
msgstr "E663: Muutoslistan lopussa"

msgid "Type  :quit<Enter>  to exit Vim"
msgstr "Komento :quit<Enter> lopettaa Vimin"

#, c-format
msgid "1 line %sed 1 time"
msgstr "1 riviä %s kerran"

#, c-format
msgid "1 line %sed %d times"
msgstr "1 riviä %s %d kertaa"

#, c-format
msgid "%ld lines %sed 1 time"
msgstr "%ld riviä %s kerran"

#, c-format
msgid "%ld lines %sed %d times"
msgstr "%ld riviä %s %d kertaa"

#, c-format
msgid "%ld lines to indent... "
msgstr "%ld riviä sisennettävänä..."

msgid "1 line indented "
msgstr "1 rivi sisennetty "

#, c-format
msgid "%ld lines indented "
msgstr "%ld riviä sisennetty "

msgid "E748: No previously used register"
msgstr "E748: Ei aiemmin käytettyjä rekisterejä"

#. must display the prompt
msgid "cannot yank; delete anyway"
msgstr "Ei voi kopioida; poista joka tapauksessa"

msgid "1 line changed"
msgstr "1 rivi muuttui"

#, c-format
msgid "%ld lines changed"
msgstr "%ld riviä muuttui"

#, c-format
msgid "freeing %ld lines"
msgstr "vapautetaan %ld riviä"

msgid "block of 1 line yanked"
msgstr "1 rivin lohko kopioitu"

msgid "1 line yanked"
msgstr "1 rivi kopioitu"

#, c-format
msgid "block of %ld lines yanked"
msgstr "lohko %ld riviltä kopioitu"

#, c-format
msgid "%ld lines yanked"
msgstr "%ld riviä kopioitu"

#, c-format
msgid "E353: Nothing in register %s"
msgstr "E353: Rekisterissä %s ei ole mitään"

#. Highlight title
msgid ""
"\n"
"--- Registers ---"
msgstr ""
"\n"
"--- Rekisterit ---"

msgid "Illegal register name"
msgstr "Virheellinen rekisterin nimi"

msgid ""
"\n"
"# Registers:\n"
msgstr ""
"\n"
"# Rekisterit:\n"

#, c-format
msgid "E574: Unknown register type %d"
msgstr "E574: Tuntematon rekisterityyppi %d"

msgid ""
"E883: search pattern and expression register may not contain two or more "
"lines"
msgstr ""
"E883: hakulauseke- ja -ilmausrekisteri ei voi sisältää kahta tai useampaa "
"riviä"

#, c-format
msgid "%ld Cols; "
msgstr "%ld saraketta, "

#, c-format
msgid "Selected %s%ld of %ld Lines; %lld of %lld Words; %lld of %lld Bytes"
msgstr "Valittu %s%ld/%ld riviä, %lld/%lld sanaa, %lld/%lld tavua"

#, c-format
msgid ""
"Selected %s%ld of %ld Lines; %lld of %lld Words; %lld of %lld Chars; %lld of "
"%lld Bytes"
msgstr "Valittu %s%ld/%ld riviä, %lld/%lld sanaa, %lld/%lld merkkiä, "
"%lld/%lld tavua"

#, c-format
msgid "Col %s of %s; Line %ld of %ld; Word %lld of %lld; Byte %lld of %lld"
msgstr "Sarake %s/%s, Rivi %ld/%ld, sana %lld/%lld, tavu %lld/%lld"

#, c-format
msgid ""
"Col %s of %s; Line %ld of %ld; Word %lld of %lld; Char %lld of %lld; Byte "
"%lld of %lld"
msgstr "Sarake %s/%s, rivi %ld/%ld, sana %lld/%lld, merkki %lld/%lld, tavu "
"%lld/%lld"

# Unicode Byte Order Mark
#, c-format
msgid "(+%ld for BOM)"
msgstr "(+%ld BOMista)"

msgid "%<%f%h%m%=Page %N"
msgstr "%<%f%h%m%=Sivu %N"

msgid "Thanks for flying Vim"
msgstr "Kiitos että ajoit Vimiä"

msgid "E518: Unknown option"
msgstr "E518: Tuntematon asetus"

msgid "E519: Option not supported"
msgstr "E519: Asetusta ei tueta"

msgid "E520: Not allowed in a modeline"
msgstr "E520: Ei sallitu modeline-rivillä"

msgid "E846: Key code not set"
msgstr "E846: Avainkoodi puuttuu"

msgid "E521: Number required after ="
msgstr "E521: =:n jälkeen tarvitaan luku"

msgid "E522: Not found in termcap"
msgstr "E522: Puuttuu termcapista"

#, c-format
msgid "E539: Illegal character <%s>"
msgstr "E539: Virheellinen merkki <%s>"

#, c-format
msgid "For option %s"
msgstr "Asetukselle %s"

msgid "E529: Cannot set 'term' to empty string"
msgstr "E529: Termiä ei voi asettaa tyhjäksi merkkijonoksi"

msgid "E530: Cannot change term in GUI"
msgstr "E530: Ei voi vaihtaa termiä GUIssa"

msgid "E531: Use \":gui\" to start the GUI"
msgstr "E531: Käytä komentoa :gui GUIn käynnistämiseen"

msgid "E589: 'backupext' and 'patchmode' are equal"
msgstr "E589: backupext ja patchmod ovat samat"

msgid "E834: Conflicts with value of 'listchars'"
msgstr "E834: listcharsin arvoissa on ristiriitoja"

msgid "E835: Conflicts with value of 'fillchars'"
msgstr "E835: fillcharsin arvossa on ristiriitoja"

msgid "E617: Cannot be changed in the GTK+ 2 GUI"
msgstr "E617: Ei voi muuttaa GTK+2-GUIssa"

msgid "E524: Missing colon"
msgstr "E524: Kaksoispiste puuttuu"

msgid "E525: Zero length string"
msgstr "E525: Nollan pituinen merkkijono"

#, c-format
msgid "E526: Missing number after <%s>"
msgstr "E526: Lukuarvo puuttuu merkkijonon <%s> jälkeen"

msgid "E527: Missing comma"
msgstr "E527: Pilkku puuttuu"

msgid "E528: Must specify a ' value"
msgstr "E528: '-arvo pitää antaa"

msgid "E595: contains unprintable or wide character"
msgstr "E595: Sisältää tulostumattomia tai leveitä merkkejä"

msgid "E596: Invalid font(s)"
msgstr "E596: Viallisia fontteja"

msgid "E597: can't select fontset"
msgstr "E597: Fontsetin valinta ei onnistu"

msgid "E598: Invalid fontset"
msgstr "E598: Viallinen fontset"

msgid "E533: can't select wide font"
msgstr "E533: Leveän fontin valinta ei onnistu"

msgid "E534: Invalid wide font"
msgstr "E534: Viallinen leveä fontti"

#, c-format
msgid "E535: Illegal character after <%c>"
msgstr "E535: Virheellinen merkki merkin <%c> jälkeen"

msgid "E536: comma required"
msgstr "E536: pilkku puuttuu"

#, c-format
msgid "E537: 'commentstring' must be empty or contain %s"
msgstr "E537: commentstringin pitää olla tyhjä tai sisältää %s"

msgid "E538: No mouse support"
msgstr "E538: Hiirtä ei tueta"

msgid "E540: Unclosed expression sequence"
msgstr "E540: Sulkematon lausekesarja"

msgid "E541: too many items"
msgstr "E541: liikaa kohteita"

msgid "E542: unbalanced groups"
msgstr "E542: epätasapainoisia ryhmiä"

msgid "E590: A preview window already exists"
msgstr "E590: Esikatseluikkuna on jo olemassa"

msgid "W17: Arabic requires UTF-8, do ':set encoding=utf-8'"
msgstr "W17: Arabialle pitää olla UTF-8:aa, aseta :set encoding=utf-8"

#, c-format
msgid "E593: Need at least %d lines"
msgstr "E593: Tarvitaan ainakin %d riviä"

#, c-format
msgid "E594: Need at least %d columns"
msgstr "E594: Tarvitaan ainakin %d saraketta"

#, c-format
msgid "E355: Unknown option: %s"
msgstr "E355: Tuntematon asetus: %s"

#. There's another character after zeros or the string
#. * is empty.  In both cases, we are trying to set a
#. * num option using a string.
#, c-format
msgid "E521: Number required: &%s = '%s'"
msgstr "E521: tarvitaan luku: &%s = '%s'"

msgid ""
"\n"
"--- Terminal codes ---"
msgstr ""
"\n"
"--- Terminaalikoodit ---"

msgid ""
"\n"
"--- Global option values ---"
msgstr ""
"\n"
"--- Globaalit asetukset ---"

msgid ""
"\n"
"--- Local option values ---"
msgstr ""
"\n"
"--- Paikalliset asetukset ---"

msgid ""
"\n"
"--- Options ---"
msgstr ""
"\n"
"--- Asetukset ---"

msgid "E356: get_varp ERROR"
msgstr "E356: get_varp-virhe"

#, c-format
msgid "E357: 'langmap': Matching character missing for %s"
msgstr "E357: langmap: Merkkiin %s täsmäävä merkki puuttuu"

#, c-format
msgid "E358: 'langmap': Extra characters after semicolon: %s"
msgstr "E358: langmap: ylimääräisiä merkkejä puolipisteen jälkeen: %s"

msgid "cannot open "
msgstr "ei voi avata "

msgid "VIM: Can't open window!\n"
msgstr "VIM: Ei voi avata ikkunaa\n"

msgid "Need Amigados version 2.04 or later\n"
msgstr "Amigados 2.04 tai uudempi tarvitaan\n"

#, c-format
msgid "Need %s version %ld\n"
msgstr "Tarvitaan %s versio %ld\n"

msgid "Cannot open NIL:\n"
msgstr "Ei voi avata NILiä:\n"

msgid "Cannot create "
msgstr "Ei voi luoda "

#, c-format
msgid "Vim exiting with %d\n"
msgstr "Vim sulkeutuu koodilla %d\n"

msgid "cannot change console mode ?!\n"
msgstr "ei voi vaihtaa konsolitilaa?\n"

msgid "mch_get_shellsize: not a console??\n"
msgstr "mch_get_shellsize: ei ole konsoli?\n"

#. if Vim opened a window: Executing a shell may cause crashes
msgid "E360: Cannot execute shell with -f option"
msgstr "E360: Kuorta ei voi avata asetuksella -f"

msgid "Cannot execute "
msgstr "Ei voi suorittaa "

msgid "shell "
msgstr "kuori "

msgid " returned\n"
msgstr " palautti\n"

msgid "ANCHOR_BUF_SIZE too small."
msgstr "ANCHOR_BUF_SIZE liian pieni."

msgid "I/O ERROR"
msgstr "IO-virhe"

msgid "Message"
msgstr "Viesti"

msgid "'columns' is not 80, cannot execute external commands"
msgstr "columns ei ole 80, ei voi suorittaa ulkoista komentoa"

msgid "E237: Printer selection failed"
msgstr "E237: Tulostimen valinta epäonnistui"

#, c-format
msgid "to %s on %s"
msgstr "tulostimelle %s kohteessa %s"

#, c-format
msgid "E613: Unknown printer font: %s"
msgstr "E613: Tuntematon tulostimen fontti: %s"

#, c-format
msgid "E238: Print error: %s"
msgstr "E238: Tulostinvirhe: %s"

#, c-format
msgid "Printing '%s'"
msgstr "Tulostetaan %s"

#, c-format
msgid "E244: Illegal charset name \"%s\" in font name \"%s\""
msgstr "E244: Virheellinen merkistön nimi %s fontin nimessä %s"

#, c-format
msgid "E244: Illegal quality name \"%s\" in font name \"%s\""
msgstr "E244: Virheellinen laatunimi %s fontin nimessä %s"

#, c-format
msgid "E245: Illegal char '%c' in font name \"%s\""
msgstr "E245: Virheellinen merkki %c fontin nimessä %s"

#, c-format
msgid "Opening the X display took %ld msec"
msgstr "X-näytön avaus vei %ld millisekuntia"

msgid ""
"\n"
"Vim: Got X error\n"
msgstr ""
"\n"
"Vim: X-virhe\n"

msgid "Testing the X display failed"
msgstr "X-näytön testaus epäonnistui"

msgid "Opening the X display timed out"
msgstr "X-näytön avaus aikakatkaistiin"

# mikä security context?
msgid ""
"\n"
"Could not get security context for "
msgstr ""
"\n"
"Ei saatu turvallisuuskontekstia kohteelle "

msgid ""
"\n"
"Could not set security context for "
msgstr ""
"\n"
"Ei voitu asettaa turvallisuuskontekstia kohteelle "

#, c-format
msgid "Could not set security context %s for %s"
msgstr ""
"Ei voitu asettaa turvallisuuskontekstia %s kohteelle %s"

# mikä security context?
#, c-format
msgid "Could not get security context %s for %s. Removing it!"
msgstr ""
"Ei saatu turvallisuuskontekstia %s kohteelle %s ja se poistetaan"

msgid ""
"\n"
"Cannot execute shell sh\n"
msgstr ""
"\n"
"Kuoren sh suoritus ei onnistu\n"

msgid ""
"\n"
"shell returned "
msgstr ""
"\n"
"kuoren palautusarvo "

msgid ""
"\n"
"Cannot create pipes\n"
msgstr ""
"\n"
"Putkia ei voi tehdä\n"

msgid ""
"\n"
"Cannot fork\n"
msgstr ""
"\n"
"Ei voi haarauttaa\n"

msgid ""
"\n"
"Cannot execute shell "
msgstr ""
"\n"
"Kuoren suoritus ei onnistu "

msgid ""
"\n"
"Command terminated\n"
msgstr ""
"\n"
"Komento loppui\n"

msgid "XSMP lost ICE connection"
msgstr "XSMP kadotti ICE-yhteyden"

#, c-format
msgid "dlerror = \"%s\""
msgstr "dlerror = %s"

msgid "Opening the X display failed"
msgstr "X-näytön avaus epäonnistui"

msgid "XSMP handling save-yourself request"
msgstr "XSMP käsittelee save-yourself-pyyntöä"

msgid "XSMP opening connection"
msgstr "XSMP avaa yhteyttä"

msgid "XSMP ICE connection watch failed"
msgstr "XSMP:n ICE-yhteyden tarkkailu epäonnistui"

#, c-format
msgid "XSMP SmcOpenConnection failed: %s"
msgstr "XSMP SmcOpenConnection epäonnistui: %s"

msgid "At line"
msgstr "Rivillä"

msgid "Could not load vim32.dll!"
msgstr "Vim32.dll:ää ei voitu ladata"

msgid "VIM Error"
msgstr "VIM-virhe"

msgid "Could not fix up function pointers to the DLL!"
msgstr "Ei voitu korjata funktio-osoittimia DLL:ssä"

#, c-format
msgid "Vim: Caught %s event\n"
msgstr "Vim: Napattiin %s\n"

msgid "close"
msgstr "sulkeminen"

msgid "logoff"
msgstr "uloskirjautuminen"

msgid "shutdown"
msgstr "sammutus"

msgid "E371: Command not found"
msgstr "E371: Komentoa ei löydy"

msgid ""
"VIMRUN.EXE not found in your $PATH.\n"
"External commands will not pause after completion.\n"
"See  :help win32-vimrun  for more information."
msgstr ""
"VIMRUN.EXEä ei löydy muuttujasta $PATH.\n"
"Ulkoiset komennot eivät pysähdy suorituksen lopussa.\n"
"Lisätietoja komennolla  :help win32-vimrun"

msgid "Vim Warning"
msgstr "Vim-varoitus"

#, c-format
msgid "shell returned %d"
msgstr "kuori palautti arvon %d"

#, c-format
msgid "E372: Too many %%%c in format string"
msgstr "E372: Liikaa %%%c-juttuja muotoilumerkkijonossa"

#, c-format
msgid "E373: Unexpected %%%c in format string"
msgstr "E373: Odottamaton %%%c muotoilumerkkijonossa"

msgid "E374: Missing ] in format string"
msgstr "E374: ] puuttuu muotoilemerkkijonosta"

#, c-format
msgid "E375: Unsupported %%%c in format string"
msgstr "E375: Tukematon %%%c muotoilumerkkijonossa"

#, c-format
msgid "E376: Invalid %%%c in format string prefix"
msgstr "E376: Virheellinen %%%c muotoilumerkkijonon alussa"

#, c-format
msgid "E377: Invalid %%%c in format string"
msgstr "E377: Virheellinen %%%c muotoilumerkkijonossa"

#. nothing found
msgid "E378: 'errorformat' contains no pattern"
msgstr "E378: errorformatissa ei ole kuvioita"

msgid "E379: Missing or empty directory name"
msgstr "E379: Puuttuva tai tyhjä hakemiston nimi"

msgid "E553: No more items"
msgstr "E553: Ei enää kohteita"

msgid "E924: Current window was closed"
msgstr "E924: Nykyinen ikkuna on suljettu"

msgid "E925: Current quickfix was changed"
msgstr "E925: Nykyinen quickfix on muuttunut"

msgid "E926: Current location list was changed"
msgstr "E926: Nykyinen sijaintiluettelo on muuttunut"

#, c-format
msgid "(%d of %d)%s%s: "
msgstr "(%d/%d)%s%s: "

msgid " (line deleted)"
msgstr " (rivi poistettu)"

#, c-format
msgid "%serror list %d of %d; %d errors "
msgstr "%svirhelista %d/%d, %d virhettä"

msgid "E380: At bottom of quickfix stack"
msgstr "E380: quickfix-pinon pohjalla"

msgid "E381: At top of quickfix stack"
msgstr "E381: quickfix-pinon huipulla"

msgid "No entries"
msgstr "Ei kenttiä"

msgid "E382: Cannot write, 'buftype' option is set"
msgstr "E382: Ei voi kirjoittaa, buftype asetettu"

msgid "Error file"
msgstr "Virhetiedosto"

msgid "E683: File name missing or invalid pattern"
msgstr "E683: Tiedostonimi puuttuu tai kuvio on viallinen"

#, c-format
msgid "Cannot open file \"%s\""
msgstr "Tiedostoa %s ei voi avata"

msgid "E681: Buffer is not loaded"
msgstr "E681: Puskuria ei ole ladattu"

msgid "E777: String or List expected"
msgstr "E777: Pitää olla merkkijono tai lista"

#, c-format
msgid "E369: invalid item in %s%%[]"
msgstr "E369: virheellinen olio kohdassa %s%%[]"

#, c-format
msgid "E769: Missing ] after %s["
msgstr "E769: ] puuttuu merkinnän %s[ jäljestä"

#, c-format
msgid "E53: Unmatched %s%%("
msgstr "E53: Pariton %s%%("

#, c-format
msgid "E54: Unmatched %s("
msgstr "E54: Pariton %s("

#, c-format
msgid "E55: Unmatched %s)"
msgstr "E55: Pariton %s)"

msgid "E66: \\z( not allowed here"
msgstr "E66: \\z( ei ole sallittu tässä"

msgid "E67: \\z1 et al. not allowed here"
msgstr "E67: \\z1 jne. ei ole sallittu tässä"

#, c-format
msgid "E69: Missing ] after %s%%["
msgstr "E69: ] puuttuu merkinnän %s%%[ jäljestä"

#, c-format
msgid "E70: Empty %s%%[]"
msgstr "E70: Tyhjä %s%%[]"

msgid "E339: Pattern too long"
msgstr "E339: Liian pitkä kuvio"

msgid "E50: Too many \\z("
msgstr "E50: Liikaa merkkejä \\z("

#, c-format
msgid "E51: Too many %s("
msgstr "E51: Liikaa merkkejä %s("

msgid "E52: Unmatched \\z("
msgstr "E52: Pariton \\z("

#, c-format
msgid "E59: invalid character after %s@"
msgstr "E59: virheellinen merkki kohdan %s@ jälkeen"

#, c-format
msgid "E60: Too many complex %s{...}s"
msgstr "E60: Liikaa monimutkaisia ilmauksia %s{...}s"

#, c-format
msgid "E61: Nested %s*"
msgstr "E61: Sisäkkäistetty %s*"

#, c-format
msgid "E62: Nested %s%c"
msgstr "E62: Sisäkkäistetty %s%c"

msgid "E63: invalid use of \\_"
msgstr "E63: väärinkäytetty \\_"

#, c-format
msgid "E64: %s%c follows nothing"
msgstr "E64: %s%c jälkeen ei minkään"

msgid "E65: Illegal back reference"
msgstr "E65: Virheellinen täsmäysviittaus"

msgid "E68: Invalid character after \\z"
msgstr "E68: Virheellinen merkki ilmauksen \\z jälkeen"

#, c-format
msgid "E678: Invalid character after %s%%[dxouU]"
msgstr "E678: Virheellinen merkki merkinnän %s%%[dxouU] jäljessä"

#, c-format
msgid "E71: Invalid character after %s%%"
msgstr "E71: Virheellinen merkki merkinnän %s%% jäljessä"

#, c-format
msgid "E554: Syntax error in %s{...}"
msgstr "E554: Syntaksivirhe ilmauksessa %s{...}"

msgid "External submatches:\n"
msgstr "Ulkoisia alitäsmäyksiä:\n"

#, c-format
msgid "E888: (NFA regexp) cannot repeat %s"
msgstr "E888: (NFA-säänn. ilmaus) ei voi toistaa kohdetta %s"

msgid ""
"E864: \\%#= can only be followed by 0, 1, or 2. The automatic engine will be "
"used "
msgstr ""
"E864: \\%#=-merkkien perään voi tulla vain 0, 1 tai 2. Käytetään "
"automaattista engineä "

msgid "Switching to backtracking RE engine for pattern: "
msgstr "Vaihdetaan käyttämään backtrackkaavaa RE-engineä ilmaukselle: "

msgid "E865: (NFA) Regexp end encountered prematurely"
msgstr "E865: (NFA) Säännöllisen ilmauksen ennenaikainen loppu"

#, c-format
msgid "E866: (NFA regexp) Misplaced %c"
msgstr "E866: (NFA-regexp) %c väärässä paikassa"

#, c-format
msgid "E877: (NFA regexp) Invalid character class: %ld"
msgstr "E877: (NFA regexp) Virheellinen merkkiluokka: %ld"

#, c-format
msgid "E867: (NFA) Unknown operator '\\z%c'"
msgstr "E867: (NFA) Tuntematon operaattori '\\z%c'"

#, c-format
msgid "E867: (NFA) Unknown operator '\\%%%c'"
msgstr "E867: (NFA) Tuntematon operaattori '\\%%%c'"

#. should never happen
msgid "E868: Error building NFA with equivalence class!"
msgstr "E868: Virhe NFA:n ekvivalenssiluokkia tekemisessä"

#, c-format
msgid "E869: (NFA) Unknown operator '\\@%c'"
msgstr "E869: (NFA) Tuntematon operaattori '\\@%c'"

msgid "E870: (NFA regexp) Error reading repetition limits"
msgstr "E870: (NFA regexp) Virhe luettaessa toiston määriä"

#. Can't have a multi follow a multi.
msgid "E871: (NFA regexp) Can't have a multi follow a multi !"
msgstr "E871: (NFA regexp) Multi ei voi seurata multia"

#. Too many `('
msgid "E872: (NFA regexp) Too many '('"
msgstr "E872: (NFA regexp) Liian monta suljetta '('"

msgid "E879: (NFA regexp) Too many \\z("
msgstr "E879: (NFA regexp) Liikaa merkkejä \\z("

msgid "E873: (NFA regexp) proper termination error"
msgstr "E873: (NFA regexp) oikea lopetusvirhe"

msgid "E874: (NFA) Could not pop the stack !"
msgstr "E874: (NFA) Ei voida poistaa pinosta"

msgid ""
"E875: (NFA regexp) (While converting from postfix to NFA), too many states "
"left on stack"
msgstr ""
"E875: (NFA regexp) (Muunnettaessa postfixistä NFA:ksi), liikaa "
"tiloja jäljellä pinossa"

msgid "E876: (NFA regexp) Not enough space to store the whole NFA "
msgstr "E876: (NFA regexp) Tila ei riitä NFA:n tallentamiseen"

msgid "E878: (NFA) Could not allocate memory for branch traversal!"
msgstr "E878: (NFA) Ei voitu allokoida muistia polkujen läpikäyntiin"

msgid ""
"Could not open temporary log file for writing, displaying on stderr ... "
msgstr ""
"Ei voitu avata väliaikaislokitiedosta kirjoittamista varten, joten virheet "
"näytetään vakiovirhevirrassa. "

#, c-format
msgid "(NFA) COULD NOT OPEN %s !"
msgstr "(NFA) EI VOI AVATA KOHDETTA %s"

msgid "Could not open temporary log file for writing "
msgstr "Väliaikaislokitiedoston avaus kirjoittamista varten ei onnistu"

# tiloja
msgid " VREPLACE"
msgstr " VKORVAUS"

msgid " REPLACE"
msgstr " KORVAUS"

msgid " REVERSE"
msgstr " KÄÄNTEIS"

msgid " INSERT"
msgstr " SYÖTTÖ"

msgid " (insert)"
msgstr " (syöttö)"

msgid " (replace)"
msgstr " (korvaus)"

msgid " (vreplace)"
msgstr " (vkorvaus)"

msgid " Hebrew"
msgstr " Heprea"

msgid " Arabic"
msgstr " Arabia"

msgid " (paste)"
msgstr " (liitos)"

msgid " VISUAL"
msgstr " VALINTA"

msgid " VISUAL LINE"
msgstr " VALINTARIVI"

msgid " VISUAL BLOCK"
msgstr " VALINTALOHKO"

msgid " SELECT"
msgstr " WALINTA"

msgid " SELECT LINE"
msgstr " WALINTARIVI"

msgid " SELECT BLOCK"
msgstr " WALINTALOHKO"

msgid "recording"
msgstr "tallennetaan"

#, c-format
msgid "E383: Invalid search string: %s"
msgstr "E383: Viallinen hakujono: %s"

#, c-format
msgid "E384: search hit TOP without match for: %s"
msgstr "E384: Haku pääsi alkuun löytämättä jonoa: %s"

#, c-format
msgid "E385: search hit BOTTOM without match for: %s"
msgstr "E385: Haku pääsi loppuun löytämättä jonoa: %s"

msgid "E386: Expected '?' or '/'  after ';'"
msgstr "E386: ;:n jälkeen pitää olla ? tai /"

msgid " (includes previously listed match)"
msgstr " (sisältää viimeksi luetellun täsmäyksen)"

#. cursor at status line
msgid "--- Included files "
msgstr "--- Sisällytetyt tiedostot "

msgid "not found "
msgstr "ei löytynyt "

msgid "in path ---\n"
msgstr "polusta ---\n"

msgid "  (Already listed)"
msgstr "  (Jo lueteltu)"

msgid "  NOT FOUND"
msgstr "  EI LÖYTYNYT"

#, c-format
msgid "Scanning included file: %s"
msgstr "Haku sisälsi tiedoston: %s"

#, c-format
msgid "Searching included file %s"
msgstr "Haku sisälsi tiedoston %s"

msgid "E387: Match is on current line"
msgstr "E387: Täsmäys tällä rivillä"

msgid "All included files were found"
msgstr "Kaikki sisällytetyt rivit löytyivät"

msgid "No included files"
msgstr "Ei sisällytettyjä tiedostoja"

msgid "E388: Couldn't find definition"
msgstr "E388: Määritelmä ei löydy"

msgid "E389: Couldn't find pattern"
msgstr "E389: kuvio ei löydy"

msgid "Substitute "
msgstr "Korvaa "

#, c-format
msgid ""
"\n"
"# Last %sSearch Pattern:\n"
"~"
msgstr ""
"\n"
"# Edellinen %sHakulauseke:\n"
"~"

msgid "E756: Spell checking is not enabled"
msgstr "E756: Oikaisuluku ei ole päällä"

#, c-format
msgid "Warning: Cannot find word list \"%s_%s.spl\" or \"%s_ascii.spl\""
msgstr "Varoitus: Ei löydetty sanalistaa %s_%s.spl tai %s_ascii.spl"

#, c-format
msgid "Warning: Cannot find word list \"%s.%s.spl\" or \"%s.ascii.spl\""
msgstr "Varoitus: Ei löydetty sanalistaa %s.%s.spl tai %s.ascii.spl"

#, c-format
msgid "Warning: region %s not supported"
msgstr "Varoitus: osaa %s ei tueta"

msgid "Sorry, no suggestions"
msgstr "ei ehdotuksia"

#, c-format
msgid "Sorry, only %ld suggestions"
msgstr "vain %ld ehdotusta"

#. for when 'cmdheight' > 1
#. avoid more prompt
#, c-format
msgid "Change \"%.*s\" to:"
msgstr "Muuta %.*s:"

#, c-format
msgid " < \"%.*s\""
msgstr " < %.*s"

msgid "E752: No previous spell replacement"
msgstr "E752: Ei edellistä oikaisulukukorjausta"

#, c-format
msgid "E753: Not found: %s"
msgstr "E753: Ei löytynyt: %s"

msgid "E758: Truncated spell file"
msgstr "E758: Oikolukutiedosto katkaistu"

#, c-format
msgid "Trailing text in %s line %d: %s"
msgstr "Tekstiä rivin perässä tiedostossa %s rivillä %d: %s"

#, c-format
msgid "Affix name too long in %s line %d: %s"
msgstr "Affiksin nimi on liian pitkä tiedostossa %s rivillä %d: %s"

msgid "E761: Format error in affix file FOL, LOW or UPP"
msgstr "E761: Affiksitiedoston FOL-, LOW- tai UPP-muotovirhe "

msgid "E762: Character in FOL, LOW or UPP is out of range"
msgstr "E762: Merkki FOL:ssä, LOW:ssä tai UPP:ssä ei kuulu arvoalueeseen"

msgid "Compressing word tree..."
msgstr "Tiivistetään sanapuuta..."

#, c-format
msgid "Reading spell file \"%s\""
msgstr "Luetaan oikaisulukutiedosta %s"

msgid "E757: This does not look like a spell file"
msgstr "E757: Ei vaikuta oikaisulukutiedostolta"

msgid "E771: Old spell file, needs to be updated"
msgstr "E771: Vanha oikaisulukutiedosto vaatii päivittämistä"

msgid "E772: Spell file is for newer version of Vim"
msgstr "E772: Oikaisulukutiedosto on uudemmalle Vimille"

msgid "E770: Unsupported section in spell file"
msgstr "E770: Tukematon osio oikaisulukutiedostossa"

#, c-format
msgid "E778: This does not look like a .sug file: %s"
msgstr "E778: Ei vaikuta .sug-tiedostolta: %s"

#, c-format
msgid "E779: Old .sug file, needs to be updated: %s"
msgstr "E779: Vanha .sug-tiedosto pitää päivittää: %s"

#, c-format
msgid "E780: .sug file is for newer version of Vim: %s"
msgstr "E780: .sug-tiedosto on uudemmalle Vimille: %s"

#, c-format
msgid "E781: .sug file doesn't match .spl file: %s"
msgstr "E781: .sug-tiedosto ei täsmää .spl-tiedostoon: %s"

#, c-format
msgid "E782: error while reading .sug file: %s"
msgstr "E782: virhe luettaessa .sug-tiedostoa: %s"

#, c-format
msgid "Reading affix file %s ..."
msgstr "Luetaan affiksitiedostoa %s..."

#, c-format
msgid "Conversion failure for word in %s line %d: %s"
msgstr "Muunnosvirhe sanalle %s rivillä %d: %s"

#, c-format
msgid "Conversion in %s not supported: from %s to %s"
msgstr "Muunnosta kohteessa %s ei tueta: kohteesta %s kohteeseen %s"

#, c-format
msgid "Conversion in %s not supported"
msgstr "Muutosta kohteessa %s ei tueta"

#, c-format
msgid "Invalid value for FLAG in %s line %d: %s"
msgstr "Tuntematon FLAG kohteessa %s rivillä %d: %s"

#, c-format
msgid "FLAG after using flags in %s line %d: %s"
msgstr "FLAG kohteessa %s lippujen jälkeen rivillä %d: %s"

#, c-format
msgid ""
"Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line "
"%d"
msgstr ""
"COMPOUNDFORBIDFLAG PFX:n jälkeen voi antaa vääriä tuloksia kohteessa %s "
"rivillä %d"

#, c-format
msgid ""
"Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line "
"%d"
msgstr ""
"COMPOUNDPERMITFLAG PFX:n jälkeen voi antaa vääriä tuloksia kohteessa %s "
"rivillä %d"

#, c-format
msgid "Wrong COMPOUNDRULES value in %s line %d: %s"
msgstr "Väärä COMPOUNDRULES-arvo kohteessa %s rivillä %d: %s"

#, c-format
msgid "Wrong COMPOUNDWORDMAX value in %s line %d: %s"
msgstr "Väärä COMPOUNDWORDMAX-arvo kohteessa %s rivillä %d: %s"

#, c-format
msgid "Wrong COMPOUNDMIN value in %s line %d: %s"
msgstr "Väärä COMPOUNDMIN-arvo kohteessa %s rivillä %d: %s"

#, c-format
msgid "Wrong COMPOUNDSYLMAX value in %s line %d: %s"
msgstr "Väärä COMPOUNDSYLMAX-arvo kohteessa %s rivillä %d: %s"

#, c-format
msgid "Wrong CHECKCOMPOUNDPATTERN value in %s line %d: %s"
msgstr "Väärä CHECKCOMPOUNDPATTERN-arvo kohteessa %s rivillä %d: %s"

#, c-format
msgid "Different combining flag in continued affix block in %s line %d: %s"
msgstr ""
"Eri yhdistelmälippu jatketussa affiksilohkossa kohteessa %s rivillä %d: %s"

#, c-format
msgid "Duplicate affix in %s line %d: %s"
msgstr "Kaksoiskappale affiksista kohteessa %s rivillä %d: %s"

#, c-format
msgid ""
"Affix also used for BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST in %s "
"line %d: %s"
msgstr ""
"Affiksia käytetty myös BAD-, RARE-, KEEPCASE-, NEEDAFFIX-, NEEDCOMPOUND- tai "
"NOSUGGEST-arvossa kohteessa %s rivillä %d: %s"

#, c-format
msgid "Expected Y or N in %s line %d: %s"
msgstr "Odotettiin Y:tä tai N:ää kohteessa %s rivillä %d: %s"

#, c-format
msgid "Broken condition in %s line %d: %s"
msgstr "Viallinen ehto kohteessa %s rivillä %d: %s"

#, c-format
msgid "Expected REP(SAL) count in %s line %d"
msgstr "Odotettiin REP(SAL)-arvoa kohteessa %s rivillä %d"

#, c-format
msgid "Expected MAP count in %s line %d"
msgstr "Odotettiin MAP-arvoa kohteessa %s rivillä %d"

#, c-format
msgid "Duplicate character in MAP in %s line %d"
msgstr "Kaksoiskappale merkistä MAP:ssä kohteessa %s rivillä %d"

#, c-format
msgid "Unrecognized or duplicate item in %s line %d: %s"
msgstr "Tunnistamaton tai kaksoiskappale arvosta kohteessa %s rivillä %d: %s"

#, c-format
msgid "Missing FOL/LOW/UPP line in %s"
msgstr "Puuttuva FOL, LOW tai UPP rivi kohteessa %s"

msgid "COMPOUNDSYLMAX used without SYLLABLE"
msgstr "COMPOUNDSYLMAX ilman SYLLABLEa"

msgid "Too many postponed prefixes"
msgstr "Liikaa jälkikäteistettyjä prefiksejä"

msgid "Too many compound flags"
msgstr "Liikaa yhdyssanalippuja"

msgid "Too many postponed prefixes and/or compound flags"
msgstr "Liikaa jälkikäteistettyjä prefiksejä tai yhdyssanalippuja"

#, c-format
msgid "Missing SOFO%s line in %s"
msgstr "Puuttuva SOFO%s-rivi kohteessa %s"

#, c-format
msgid "Both SAL and SOFO lines in %s"
msgstr "SAL- ja SOFO-rivit kohteessa %s"

#, c-format
msgid "Flag is not a number in %s line %d: %s"
msgstr "Lippu ei ole lukuarvo kohteessa %s rivillä %d: %s"

#, c-format
msgid "Illegal flag in %s line %d: %s"
msgstr "Tuntematon lippu kohteessa %s rivillä %d: %s"

#, c-format
msgid "%s value differs from what is used in another .aff file"
msgstr "%s-arvo eroaa toisessa .aff-tiedostossa olevasta"

#, c-format
msgid "Reading dictionary file %s ..."
msgstr "Luetaan sanakirjatiedostoa %s"

#, c-format
msgid "E760: No word count in %s"
msgstr "E760: Ei sanalaskuria kohteessa %s"

#, c-format
msgid "line %6d, word %6d - %s"
msgstr "rivi %6d, sana %6d - %s"

#, c-format
msgid "Duplicate word in %s line %d: %s"
msgstr "Toistettu sana kohteessa %s rivillä %d: %s"

#, c-format
msgid "First duplicate word in %s line %d: %s"
msgstr "Ensimmäinen kappale kohteessa %s rivillä %d: %s"

#, c-format
msgid "%d duplicate word(s) in %s"
msgstr "toistettuja sanoja %d kohteessa %s"

#, c-format
msgid "Ignored %d word(s) with non-ASCII characters in %s"
msgstr "Ei-ASCII-merkkien takia ohitettuja sanoja %d kohteessa %s"

#, c-format
msgid "Reading word file %s ..."
msgstr "Luetaan sanatiedostoa %s..."

#, c-format
msgid "Duplicate /encoding= line ignored in %s line %d: %s"
msgstr "Toistettu /encoding= ohitettu kohteessa %s rivillä %d: %s"

#, c-format
msgid "/encoding= line after word ignored in %s line %d: %s"
msgstr "/encoding= sanojen jälkeen ohitettu kohteessa %s rivillä %d: %s"

#, c-format
msgid "Duplicate /regions= line ignored in %s line %d: %s"
msgstr "Toistettu /regions= ohitettu kohteessa %s rivillä %d: %s"

#, c-format
msgid "Too many regions in %s line %d: %s"
msgstr "Liikaa regionseja kohteessa %s rivillä %d: %s"

#, c-format
msgid "/ line ignored in %s line %d: %s"
msgstr "/ ohitettu kohteessa %s rivillä %d: %s"

#, c-format
msgid "Invalid region nr in %s line %d: %s"
msgstr "Virheellinen region-luku kohteessa %s rivillä %d: %s"

#, c-format
msgid "Unrecognized flags in %s line %d: %s"
msgstr "Tunnistamaton lippu kohteessa %s rivillä %d: %s"

#, c-format
msgid "Ignored %d words with non-ASCII characters"
msgstr "Ei-ASCIIn takia ohitettuja sanoja %d"

msgid "E845: Insufficient memory, word list will be incomplete"
msgstr "E845: Muisti ei riitä, sanalista jää keskeneräiseksi"

#, c-format
msgid "Compressed %d of %d nodes; %d (%d%%) remaining"
msgstr "Tiivistetty %d/%d noodia. %d (%d %%) jäljellä"

msgid "Reading back spell file..."
msgstr "Luetaan taas oikaisulukutiedostoa..."

#.
#. * Go through the trie of good words, soundfold each word and add it to
#. * the soundfold trie.
#.
msgid "Performing soundfolding..."
msgstr "Ääntämyksen mukaan yhdistellään..."

#, c-format
msgid "Number of words after soundfolding: %ld"
msgstr "Sanoja ääntämysyhdistelyn jälkeen: %ld"

#, c-format
msgid "Total number of words: %d"
msgstr "Sanoja yhteensä: %d"

#, c-format
msgid "Writing suggestion file %s ..."
msgstr "Kirjoitetaan ehdotustiedostoa %s..."

#, c-format
msgid "Estimated runtime memory use: %d bytes"
msgstr "Arvioitu käyttömuisti: %d tavua"

msgid "E751: Output file name must not have region name"
msgstr "E751: Tulostetiedostonimessä ei saa olla alueen nimeä"

msgid "E754: Only up to 8 regions supported"
msgstr "E754: Enintään 8 aluetta tuetaan"

#, c-format
msgid "E755: Invalid region in %s"
msgstr "E755: Virheellinen alue kohteelle %s"

msgid "Warning: both compounding and NOBREAK specified"
msgstr "Varoitus: sekä yhdyssanamuodostus että NOBREAK käytössä"

#, c-format
msgid "Writing spell file %s ..."
msgstr "Kirjoitetaan oikaisulukutiedostoa %s..."

msgid "Done!"
msgstr "Valmista."

#, c-format
msgid "E765: 'spellfile' does not have %ld entries"
msgstr "E765: spellfile ei sisällä %ld kohtaa"

#, c-format
msgid "Word '%.*s' removed from %s"
msgstr "Sana %.*s poistettu kohteesta %s"

#, c-format
msgid "Word '%.*s' added to %s"
msgstr "Sana %.*s lisätty kohteeseen %s"

msgid "E763: Word characters differ between spell files"
msgstr "E763: Sanan merkit muuttuvat oikaisulukutiedostojen välillä"

#. This should have been checked when generating the .spl
#. * file.
msgid "E783: duplicate char in MAP entry"
msgstr "E783: kaksoiskappale merkistä MAP-kohdassa"

msgid "No Syntax items defined for this buffer"
msgstr "Ei syntaksikohteita tälle puskurille"

#, c-format
msgid "E390: Illegal argument: %s"
msgstr "E390: Virheellinen argumentti: %s"

msgid "syntax iskeyword "
msgstr "syntax iskeyword "

#, c-format
msgid "E391: No such syntax cluster: %s"
msgstr "E391: Syntaksiklusteri puuttuu: %s"

msgid "syncing on C-style comments"
msgstr "synkkaa C-tyylin kommentteihin"

msgid "no syncing"
msgstr "ei synkkausta"

msgid "syncing starts "
msgstr "synkkaus aloitettu "

msgid " lines before top line"
msgstr " riviä ennen alkua"

msgid ""
"\n"
"--- Syntax sync items ---"
msgstr ""
"\n"
"--- Syntax sync -kohteet ---"

msgid ""
"\n"
"syncing on items"
msgstr ""
"\n"
"synkataan kohteisiin"

msgid ""
"\n"
"--- Syntax items ---"
msgstr ""
"\n"
"--- Syntax-kohteet ---"

#, c-format
msgid "E392: No such syntax cluster: %s"
msgstr "E392: syntaksiklusteria ei ole: %s"

msgid "minimal "
msgstr "vähintään "

msgid "maximal "
msgstr "enitntään "

msgid "; match "
msgstr "; täsmää "

msgid " line breaks"
msgstr " rivinvaihdot"

msgid "E395: contains argument not accepted here"
msgstr "E395: contains ei sovi tähän"

msgid "E844: invalid cchar value"
msgstr "E844: Virheellinen cchar-arvo"

msgid "E393: group[t]here not accepted here"
msgstr "E393: group[t]here ei sovi tähän"

#, c-format
msgid "E394: Didn't find region item for %s"
msgstr "E394: Aluetta nimelle %s ei löydy"

msgid "E397: Filename required"
msgstr "E397: Tiedostonimi puuttuu"

msgid "E847: Too many syntax includes"
msgstr "E847: Liikaa syntax includeja"

#, c-format
msgid "E789: Missing ']': %s"
msgstr "E789: ] puuttuu: %s"

#, c-format
msgid "E890: trailing char after ']': %s]%s"
msgstr "E890: Ylimääräisiä merkkejä merkin ] perässä: %s]%s"

#, c-format
msgid "E398: Missing '=': %s"
msgstr "E398: = puuttuu: %s"

#, c-format
msgid "E399: Not enough arguments: syntax region %s"
msgstr "E399: Argumentteja puuttuu: syntaksialue %s"

msgid "E848: Too many syntax clusters"
msgstr "E848: Liikaa syntaksiklustereita"

msgid "E400: No cluster specified"
msgstr "E400: klusteri määrittelemättä"

#, c-format
msgid "E401: Pattern delimiter not found: %s"
msgstr "E401: Kuvoin erotin puuttuu: %s"

#, c-format
msgid "E402: Garbage after pattern: %s"
msgstr "E402: Roskia kuvion jäljessä: %s"

msgid "E403: syntax sync: line continuations pattern specified twice"
msgstr "E403: syntax sync: rivinjatkamiskuvio määritelty kahdesti"

#, c-format
msgid "E404: Illegal arguments: %s"
msgstr "E404: Virheelliset argumentit: %s"

#, c-format
msgid "E405: Missing equal sign: %s"
msgstr "E405: = puuttuu: %s"

#, c-format
msgid "E406: Empty argument: %s"
msgstr "E406: Tyhjä argumentti: %s"

#, c-format
msgid "E407: %s not allowed here"
msgstr "E407: %s ei sovi tähän"

#, c-format
msgid "E408: %s must be first in contains list"
msgstr "E408: %s kuuluu contains-listan alkuun"

#, c-format
msgid "E409: Unknown group name: %s"
msgstr "E409: Tuntematon ryhmän nimi: %s"

#, c-format
msgid "E410: Invalid :syntax subcommand: %s"
msgstr "E410: Virheelluinen :syntax-osakomento: %s"

msgid ""
"  TOTAL      COUNT  MATCH   SLOWEST     AVERAGE   NAME               PATTERN"
msgstr ""
"  KAIKKI     MÄÄRÄ  TÄSMÄYS HITAIN      KEKSIARVO NIMI               ILMAUS"

msgid "E679: recursive loop loading syncolor.vim"
msgstr "E679: rekursiivinen silmukka syncolor.vimissä"

#, c-format
msgid "E411: highlight group not found: %s"
msgstr "E411: korostusryhmää ei löytynyt: %s"

#, c-format
msgid "E412: Not enough arguments: \":highlight link %s\""
msgstr "E412: Argumentteja puuttuu: :highlight link %s"

#, c-format
msgid "E413: Too many arguments: \":highlight link %s\""
msgstr "E413: Liikaa argumentteja: :highlight link %s"

msgid "E414: group has settings, highlight link ignored"
msgstr "E414: ryhmällä on asetuksia, highlight link -komento ohitetaan"

#, c-format
msgid "E415: unexpected equal sign: %s"
msgstr "E415: odotuksenvastainen =-merkki: %s"

#, c-format
msgid "E416: missing equal sign: %s"
msgstr "E416: puuttuva =-merkki: %s"

#, c-format
msgid "E417: missing argument: %s"
msgstr "E417: puuttuva argumentti: %s"

#, c-format
msgid "E418: Illegal value: %s"
msgstr "E418: Viallinen arvo: %s"

msgid "E419: FG color unknown"
msgstr "E419: edustaväri tuntematon"

msgid "E420: BG color unknown"
msgstr "E420: taustaväri tuntematon"

#, c-format
msgid "E421: Color name or number not recognized: %s"
msgstr "E421: Värin nimi tai numero tuntematon: %s"

#, c-format
msgid "E422: terminal code too long: %s"
msgstr "E422: terminaalikoodi liian pitkä: %s"

#, c-format
msgid "E423: Illegal argument: %s"
msgstr "E423: Virheellinen argumentti: %s"

msgid "E424: Too many different highlighting attributes in use"
msgstr "E424: Liikaa eri korostusattribuutteja"

msgid "E669: Unprintable character in group name"
msgstr "E669: Tulostuskelvoton merkki ryhmän nimessä"

msgid "W18: Invalid character in group name"
msgstr "W18: Virheellinen merkki ryhmän nimessä"

msgid "E849: Too many highlight and syntax groups"
msgstr "E849: Liikaa korostuksia ja syntaksiryhmiä"

msgid "E555: at bottom of tag stack"
msgstr "E555: tägipinon pohja"

msgid "E556: at top of tag stack"
msgstr "E556: tägipinon huippu"

msgid "E425: Cannot go before first matching tag"
msgstr "E425: Ei voida mennä ensimmäistä täsmäävää tägiä alummaksi"

#, c-format
msgid "E426: tag not found: %s"
msgstr "E426: tägi puuttuu: %s"

msgid "  # pri kind tag"
msgstr "  # arvo tyyppi tägi"

msgid "file\n"
msgstr "tiedosto\n"

msgid "E427: There is only one matching tag"
msgstr "E427: Vain yksi tägi täsmää"

msgid "E428: Cannot go beyond last matching tag"
msgstr "E428: Ei voida edetä viimeisen täsmäävän tägin ohi"

#, c-format
msgid "File \"%s\" does not exist"
msgstr "Tiedostoa %s ei ole"

#. Give an indication of the number of matching tags
#, c-format
msgid "tag %d of %d%s"
msgstr "tägi %d/%d%s"

msgid " or more"
msgstr " tai useammasta"

msgid "  Using tag with different case!"
msgstr "  Tägissä eri kirjaintaso"

#, c-format
msgid "E429: File \"%s\" does not exist"
msgstr "E429: Tiedostoa %s ei ole"

#. Highlight title
msgid ""
"\n"
"  # TO tag         FROM line  in file/text"
msgstr ""
"\n"
"  # TILL tagg          FRÅN LINJE  i fil/text"

#, c-format
msgid "Searching tags file %s"
msgstr "Etsitään tägitiedostoa %s"

#, c-format
msgid "E430: Tag file path truncated for %s\n"
msgstr "E430: Tägitiedoston polku katkaistu kohdassa %s\n"

msgid "Ignoring long line in tags file"
msgstr "Ohitetaan pitkä rivi tägitiedostossa"

#, c-format
msgid "E431: Format error in tags file \"%s\""
msgstr "E431: Muotovirh tägitiedostossa %s"

#, c-format
msgid "Before byte %ld"
msgstr "Ennen tavua %ld"

#, c-format
msgid "E432: Tags file not sorted: %s"
msgstr "E432: Tägitiedosto ei ole järjestetty: %s"

#. never opened any tags file
msgid "E433: No tags file"
msgstr "E433: Ei tägitiedostoja"

msgid "E434: Can't find tag pattern"
msgstr "E434: Tägikuviota ei löydy"

msgid "E435: Couldn't find tag, just guessing!"
msgstr "E435: Tägiä ei löydy, arvataan."

#, c-format
msgid "Duplicate field name: %s"
msgstr "Kaksoiskappale kentän nimestä: %s"

msgid "' not known. Available builtin terminals are:"
msgstr " ei tunnettu. Tuetut terminaalit:"

msgid "defaulting to '"
msgstr "oletusarvona "

msgid "E557: Cannot open termcap file"
msgstr "E557: Ei voi avata termcap-tiedostoa"

msgid "E558: Terminal entry not found in terminfo"
msgstr "E558: Terminaalia ei löytynyt terminfosta"

msgid "E559: Terminal entry not found in termcap"
msgstr "E559: Terminaalia ei löytynyt termcapista"

#, c-format
msgid "E436: No \"%s\" entry in termcap"
msgstr "E436: %s ei löytynyt termcapista"

msgid "E437: terminal capability \"cm\" required"
msgstr "E437: terminaalilla pitää olla cm kyvyissään"

#. Highlight title
msgid ""
"\n"
"--- Terminal keys ---"
msgstr ""
"\n"
"--- Terminaalinäppäimet ---"

msgid "Cannot open $VIMRUNTIME/rgb.txt"
msgstr "Ei voida avata tiedostoa $VIMRUNTIME/rgb.txt"

msgid "new shell started\n"
msgstr "uusi kuori avattu\n"

msgid "Vim: Error reading input, exiting...\n"
msgstr "Vim: Virhe luettaessa syötettä, poistutaan...\n"

msgid "Used CUT_BUFFER0 instead of empty selection"
msgstr "Käytettiin CUT_BUFFER0:aa tyhjän valinnan sijaan"

#. This happens when the FileChangedRO autocommand changes the
#. * file in a way it becomes shorter.
msgid "E881: Line count changed unexpectedly"
msgstr "E881: Rivimäärä vaihtui odottamatta"

#. must display the prompt
msgid "No undo possible; continue anyway"
msgstr "Ei voi kumota, jatketaan silti"

#, c-format
msgid "E828: Cannot open undo file for writing: %s"
msgstr "E828: Kumoustiedoston avaus kirjoittamista varten ei onnistu: %s"

#, c-format
msgid "E825: Corrupted undo file (%s): %s"
msgstr "E825: Pilaanntunut kumoustiedosto (%s): %s"

msgid "Cannot write undo file in any directory in 'undodir'"
msgstr "Ei voitu lukea kumoustiedostoa mistään undodir-muuttujan hakemistosta"

#, c-format
msgid "Will not overwrite with undo file, cannot read: %s"
msgstr "Ei ylikirjoitetat kumoustiedostolla, koska ei voida lukea: %s"

#, c-format
msgid "Will not overwrite, this is not an undo file: %s"
msgstr "Ei ylikirjoiteta, koska tämä ei ole kumoustiedosto: %s"

msgid "Skipping undo file write, nothing to undo"
msgstr "Ohitetaan kumoustiedoston kirjoitus, koska ei ole peruutettavia"

#, c-format
msgid "Writing undo file: %s"
msgstr "Kirjoitetaan kumoustiedostoa: %s"

#, c-format
msgid "E829: write error in undo file: %s"
msgstr "E829: Kirjoitusvirhe kumoustiedostossa: %s"

#, c-format
msgid "Not reading undo file, owner differs: %s"
msgstr "Ei lueta kumoustiedosto jonka omistaja on eri: %s"

#, c-format
msgid "Reading undo file: %s"
msgstr "Luetaan kumoustiedostoa: %s"

#, c-format
msgid "E822: Cannot open undo file for reading: %s"
msgstr "E822: Kumoustiedostoa ei voi avata lukemista varten: %s"

#, c-format
msgid "E823: Not an undo file: %s"
msgstr "E823: Ei ole kumoustiedosto: %s"

#, c-format
msgid "E832: Non-encrypted file has encrypted undo file: %s"
msgstr "E832: Salaamattomalla tiedostolla on salattu kumoustiedosto: %s"

#, c-format
msgid "E826: Undo file decryption failed: %s"
msgstr "E826: Kumoustiedoston purku epäonnistui: %s"

#, c-format
msgid "E827: Undo file is encrypted: %s"
msgstr "E827: Kumoustiedosto on salattu: %s"

#, c-format
msgid "E824: Incompatible undo file: %s"
msgstr "E824: Epäyhteensopiva kumoustiedosto: %s"

msgid "File contents changed, cannot use undo info"
msgstr ""
"Tiedoston sisältö on muuttunut, joen kumoustiedot ovat käyttökelvottomia"

#, c-format
msgid "Finished reading undo file %s"
msgstr "Ladattu kumoustiedoto %s"

msgid "Already at oldest change"
msgstr "Vanhimmassa muutoksessa"

msgid "Already at newest change"
msgstr "Nuorimmassa muutoksessa"

#, c-format
msgid "E830: Undo number %ld not found"
msgstr "E830: Kumouslukua %ld ei löydy"

msgid "E438: u_undo: line numbers wrong"
msgstr "E438: u_undo: väärät rivinumerot"

msgid "more line"
msgstr "rivi lisää"

msgid "more lines"
msgstr "riviä lisää"

msgid "line less"
msgstr "rivi vähemmän"

msgid "fewer lines"
msgstr "riviä vähemmän"

msgid "change"
msgstr "muutos"

msgid "changes"
msgstr "muutosta"

# eka %s yläpuolelta, toka %s alapuolelta, kolmas %s aika
#, c-format
msgid "%ld %s; %s #%ld  %s"
msgstr "%ld %s, %s #%ld %s"

msgid "before"
msgstr "ennen muutosta"

msgid "after"
msgstr "jälkeen muutoksen"

msgid "Nothing to undo"
msgstr "Ei kumottavaa"

msgid "number changes  when               saved"
msgstr "numero muutoksia aika              tallennettu"

#, c-format
msgid "%ld seconds ago"
msgstr "%ld sekuntia sitten"

msgid "E790: undojoin is not allowed after undo"
msgstr "E790: undojoin ei toimi undon jälkeen"

msgid "E439: undo list corrupt"
msgstr "E439: kumouslista rikki"

msgid "E440: undo line missing"
msgstr "E440: kumousrivi puuttuu"

#, c-format
msgid "E122: Function %s already exists, add ! to replace it"
msgstr "E122: Funktio %s on jo olemassa, lisää ! korvataksesi"

msgid "E717: Dictionary entry already exists"
msgstr "E717: Sanakirja-alkio on jo olemassa"

msgid "E718: Funcref required"
msgstr "E718: Funcref tarvitaan"

#, c-format
msgid "E130: Unknown function: %s"
msgstr "E130: Tuntematon funktio: %s"

#, c-format
msgid "E125: Illegal argument: %s"
msgstr "E125: Virheellinen argumentti: %s"

#, c-format
msgid "E853: Duplicate argument name: %s"
msgstr "E853: Kaksoiskappale argumentin nimestä: %s"

#, c-format
msgid "E740: Too many arguments for function %s"
msgstr "E740: Liikaa argumentteja funktiolle %s"

#, c-format
msgid "E116: Invalid arguments for function %s"
msgstr "E116: Vääriä argumentteja funktiolle %s"

msgid "E132: Function call depth is higher than 'maxfuncdepth'"
msgstr "E132: Funktiokutsujen syvyys on enemmän kuin maxfuncdepth"

#, c-format
msgid "calling %s"
msgstr "kutsutaan funktiota %s"

#, c-format
msgid "%s aborted"
msgstr "%s keskeytettiin"

#, c-format
msgid "%s returning #%ld"
msgstr "%s palaa kohdassa #%ld"

#, c-format
msgid "%s returning %s"
msgstr "%s palaa kohdassa %s"

msgid "E699: Too many arguments"
msgstr "E699: Liikaa argumentteja"

#, c-format
msgid "E117: Unknown function: %s"
msgstr "E117: Tuntematon funktio: %s"

#, c-format
msgid "E933: Function was deleted: %s"
msgstr "E933: Funktion nimi poistettu: %s"

#, c-format
msgid "E119: Not enough arguments for function: %s"
msgstr "E119: Liikaa argumentteja funktiolle %s"

#, c-format
msgid "E120: Using <SID> not in a script context: %s"
msgstr "E120: <SID> skriptin ulkopuolella: %s"

#, c-format
msgid "E725: Calling dict function without Dictionary: %s"
msgstr "E725: dict-funktio ilman sanakirjaa: %s"

msgid "E129: Function name required"
msgstr "E129: Funktion nimi puuttuu"

#, c-format
msgid "E128: Function name must start with a capital or \"s:\": %s"
msgstr ""
"E128: Funktion nimen pitää alkaa suuraakkosella tai merkeillä ’s:’: "
"%s"

#, c-format
msgid "E884: Function name cannot contain a colon: %s"
msgstr ""
"E884: Funktion nimessä ei saa olla kaksoispistettä: "
"%s"

#, c-format
msgid "E123: Undefined function: %s"
msgstr "E123: Tuntematon funktio: %s"

#, c-format
msgid "E124: Missing '(': %s"
msgstr "E124: ( puuttuu: %s"

msgid "E862: Cannot use g: here"
msgstr "E862: g: ei toimi täällä"

#, c-format
msgid "E932 Closure function should not be at top level: %s"
msgstr "E932 Sulkeumafunktio ei voi olla uloimmalla tasolla: %s"

msgid "E126: Missing :endfunction"
msgstr "E126: :endfunction puuttuu"

#, c-format
msgid "E707: Function name conflicts with variable: %s"
msgstr "E707: Funktion nimi on ristiriidassa muuttujan kanssa: %s"

#, c-format
msgid "E127: Cannot redefine function %s: It is in use"
msgstr "E127: Funktiota %s ei voi määritellä uudestaan, koska se on käytössä"

#, c-format
msgid "E746: Function name does not match script file name: %s"
msgstr "E746: Funktion nimi ei ole sama kuin skriptin tiedostonnimi: %s"

#, c-format
msgid "E131: Cannot delete function %s: It is in use"
msgstr "E131: Funktiota %s ei voi poistaa"

msgid "E133: :return not inside a function"
msgstr "E133: :return ei ole funktion sisällä"

#, c-format
msgid "E107: Missing parentheses: %s"
msgstr "E107: Sulkeita puuttuu: %s"

#. Only MS VC 4.1 and earlier can do Win32s
msgid ""
"\n"
"MS-Windows 16/32-bit GUI version"
msgstr ""
"\n"
"MS-Windows 16- t. 32-bittinen GUI-versio"

msgid ""
"\n"
"MS-Windows 64-bit GUI version"
msgstr ""
"\n"
"MS-Windows 64-bittinen GUI-versio"

msgid ""
"\n"
"MS-Windows 32-bit GUI version"
msgstr ""
"\n"
"MS-Windows 32-bittinen GUI-version"

msgid " in Win32s mode"
msgstr " Win32s-tilassa"

msgid " with OLE support"
msgstr " OLE-tuella"

msgid ""
"\n"
"MS-Windows 64-bit console version"
msgstr ""
"\n"
"MS-Windows 32-bittinen konsoliversio"

msgid ""
"\n"
"MS-Windows 32-bit console version"
msgstr ""
"\n"
"MS-Windows 32-bittinen konsoliversio"

msgid ""
"\n"
"MacOS X (unix) version"
msgstr ""
"\n"
"MacOS X-version (unix)"

msgid ""
"\n"
"MacOS X version"
msgstr ""
"\n"
"MacOS X-version"

msgid ""
"\n"
"MacOS version"
msgstr ""
"\n"
"MacOS-version"

msgid ""
"\n"
"OpenVMS version"
msgstr ""
"\n"
"OpenVMS-version"

msgid ""
"\n"
"Included patches: "
msgstr ""
"\n"
"Pätsit: "

msgid ""
"\n"
"Extra patches: "
msgstr ""
"\n"
"Muita pätsejä: "

msgid "Modified by "
msgstr "Muokannut "

msgid ""
"\n"
"Compiled "
msgstr ""
"\n"
"Kääntänyt "

msgid "by "
msgstr ": "

msgid ""
"\n"
"Huge version "
msgstr ""
"\n"
"Huge-versio "

msgid ""
"\n"
"Big version "
msgstr ""
"\n"
"Big-version "

msgid ""
"\n"
"Normal version "
msgstr ""
"\n"
"Normal-versio "

msgid ""
"\n"
"Small version "
msgstr ""
"\n"
"Small-versio "

msgid ""
"\n"
"Tiny version "
msgstr ""
"\n"
"Tiny-versio "

msgid "without GUI."
msgstr "ilman GUIta."

msgid "with GTK3 GUI."
msgstr "GTK3-GUIlla."

msgid "with GTK2-GNOME GUI."
msgstr "GTK2-Gnome-GUIlla."

msgid "with GTK2 GUI."
msgstr "GTK2-GUIlla."

msgid "with X11-Motif GUI."
msgstr "X11-Motif-GUIlla."

msgid "with X11-neXtaw GUI."
msgstr "X11-neXtaw-GUIlla."

msgid "with X11-Athena GUI."
msgstr "X11-Athena-GUIlla."

msgid "with Photon GUI."
msgstr "Photon-GUIlla."

msgid "with GUI."
msgstr "GUIlla."

msgid "with Carbon GUI."
msgstr "Carbon-GUIlla."

msgid "with Cocoa GUI."
msgstr "Cocoa-GUIlla."

msgid "with (classic) GUI."
msgstr "perinteisellä GUIlla."

msgid "  Features included (+) or not (-):\n"
msgstr " Ominaisuudet mukana (+) ja poissa (-):\n"

msgid "   system vimrc file: \""
msgstr "   järjestelmän vimrc: \""

msgid "     user vimrc file: \""
msgstr "     käyttäjän vimrc: \""

msgid " 2nd user vimrc file: \""
msgstr " 2. käyttäjän vimrc: \""

msgid " 3rd user vimrc file: \""
msgstr " 3. käyttäjän vimrc: \""

msgid "      user exrc file: \""
msgstr "      käyttäjän exrc: \""

msgid "  2nd user exrc file: \""
msgstr "  2. käyttäjän exrc: \""

msgid "  system gvimrc file: \""
msgstr "  järjestelmän gvimrc: \""

msgid "    user gvimrc file: \""
msgstr "    käyttäjän gvimrc: \""

msgid "2nd user gvimrc file: \""
msgstr "2. käyttäjän gvimrc: \""

msgid "3rd user gvimrc file: \""
msgstr "3. käyttäjän gvimrc: \""

msgid "       defaults file: \""
msgstr "       defaults-tiedosto: \""

msgid "    system menu file: \""
msgstr "    järjestelmävalikko: \""

msgid "  fall-back for $VIM: \""
msgstr "  $VIMin fallback: \""

msgid " f-b for $VIMRUNTIME: \""
msgstr " $VIMRUNTIMEn f-b: \""

msgid "Compilation: "
msgstr "Käännös: "

msgid "Compiler: "
msgstr "Käännin: "

msgid "Linking: "
msgstr "Linkitys: "

msgid "  DEBUG BUILD"
msgstr "  DEBUG-versio"

msgid "VIM - Vi IMproved"
msgstr "VIM - Vi IMproved"

msgid "version "
msgstr "versio "

msgid "by Bram Moolenaar et al."
msgstr "tekijät Bram Moolenaar et al."

msgid "Vim is open source and freely distributable"
msgstr "Vim on avointa lähdekoodia ja vapaasti jaossa"

msgid "Help poor children in Uganda!"
msgstr "Auta Ugandan köyhiä lapsia"

msgid "type  :help iccf<Enter>       for information "
msgstr "kirjoita :help iccf<Enter>    lisätietoa varten            "

msgid "type  :q<Enter>               to exit         "
msgstr "kirjoita :q<Enter>            lopettaaksesi                "

msgid "type  :help<Enter>  or  <F1>  for on-line help"
msgstr "kirjoita :help<Enter> tai <F1> ohjetta varten              "

msgid "type  :help version8<Enter>   for version info"
msgstr "kirjoita :help version8<Enter> versiotietoja varten        "

msgid "Running in Vi compatible mode"
msgstr "Suoritetaan Vi-yhteensopivuustilaa"

msgid "type  :set nocp<Enter>        for Vim defaults"
msgstr "kirjoita :set nocp<Enter>      Vimin oletuksiin            "

msgid "type  :help cp-default<Enter> for info on this"
msgstr "kirjoita :help cp-default<Enter> ohjetta oletuksista varten"

msgid "menu  Help->Orphans           for information    "
msgstr "valikko Ohje->Orvot            lisätietoja varten          "

msgid "Running modeless, typed text is inserted"
msgstr "Suoritetaan tilattomana, kirjoitettu teksti syötetään"

msgid "menu  Edit->Global Settings->Toggle Insert Mode  "
msgstr "valikko Muokkaa->Yleiset asetukset->Vaihda syötetilaa"

msgid "                              for two modes      "
msgstr "                              kahta tilaa varten "

msgid "menu  Edit->Global Settings->Toggle Vi Compatible"
msgstr "valikko Muokkaa->Yleiset asetukset->Vaihda Vi-yhteensopivuutta"

msgid "                              for Vim defaults   "
msgstr "                              Vim-oletuksia varten"

msgid "Sponsor Vim development!"
msgstr "Tue Vimin kehitystä"

msgid "Become a registered Vim user!"
msgstr "Rekisteröidy Vim-käyttäjäksi."

msgid "type  :help sponsor<Enter>    for information "
msgstr "kirjoita :help sponsor<Enter>  lisätietoja varten"

msgid "type  :help register<Enter>   for information "
msgstr "kirjoita :help register<Enter> lisätietoja varten"

msgid "menu  Help->Sponsor/Register  for information    "
msgstr "valikko Ohje->Sponsoroi/Rekisteröi lisätietoja varten"

msgid "WARNING: Windows 95/98/ME detected"
msgstr "VAROITUS: Window 95/98/ME havaittu"

msgid "type  :help windows95<Enter>  for info on this"
msgstr "kirjoita :help windows95<Enter> lisätietoja varten"

msgid "Already only one window"
msgstr "Enää yksi ikkuna jäljellä"

msgid "E441: There is no preview window"
msgstr "E441: Ei esikatseluikkunaa"

msgid "E442: Can't split topleft and botright at the same time"
msgstr "E442: Ei voi jakaa vasenta ylänurkkaa ja oikeaa alanurkkaa yhtäaikaa"

msgid "E443: Cannot rotate when another window is split"
msgstr "E443: Ei voi kiertää kun toinen ikkuna on jaettu"

msgid "E444: Cannot close last window"
msgstr "E444: Ei voi sulkea viimeistä ikkunaa"

msgid "E813: Cannot close autocmd window"
msgstr "E813: Ei voi sulkea autocmd-ikkunaa"

msgid "E814: Cannot close window, only autocmd window would remain"
msgstr "E814: Ei voi sulkea viimeistä ikkunaa, joka ei ole autocmd-ikkuna"

msgid "E445: Other window contains changes"
msgstr "E445: Toinen ikkuna sisältää muutoksia"

msgid "E446: No file name under cursor"
msgstr "E446: Ei tiedostonimeä kursorin alla"

#, c-format
msgid "E447: Can't find file \"%s\" in path"
msgstr "E447: Tiedosto %s ei löydy polulta"

msgid "List or number required"
msgstr "Lista tai luku tarvitaan"

#, c-format
msgid "E370: Could not load library %s"
msgstr "E370: Kirjaston %s lataaminen ei onnistu"

msgid "Sorry, this command is disabled: the Perl library could not be loaded."
msgstr "komento ei toimi, Perl kirjastoa ei voinut ladata."

msgid "E299: Perl evaluation forbidden in sandbox without the Safe module"
msgstr "E299: Perl-suoritus kielletty hiekkalaatikossa ilman Safe-moduulia"

msgid "Edit with &multiple Vims"
msgstr "&Muokkaa usealla Vimillä"

msgid "Edit with single &Vim"
msgstr "Muokkaa yhdellä &Vimillä"

msgid "Diff with Vim"
msgstr "Diffi Vimillä"

msgid "Edit with &Vim"
msgstr "Muokkaa &Vimillä"

#. Now concatenate
msgid "Edit with existing Vim - "
msgstr "Muokkaa olemassaolevalla Vimillä - "

msgid "Edits the selected file(s) with Vim"
msgstr "Muokkaa valittuja tiedostoja Vimillä"

msgid "Error creating process: Check if gvim is in your path!"
msgstr "Virhe prosessin käynnistämisessä, varmista että gvim on polulla"

msgid "gvimext.dll error"
msgstr "gvimext.dll-virhe"

msgid "Path length too long!"
msgstr "Liian pitkä polku"

msgid "--No lines in buffer--"
msgstr "--Ei rivejä puskurissa--"

#.
#. * The error messages that can be shared are included here.
#. * Excluded are errors that are only used once and debugging messages.
#.
msgid "E470: Command aborted"
msgstr "E470: Komento peruttu"

msgid "E471: Argument required"
msgstr "E471: Argumentti puuttuu"

msgid "E10: \\ should be followed by /, ? or &"
msgstr "E10: \\:n jälkeen pitää tulla /, ? tai &"

msgid "E11: Invalid in command-line window; <CR> executes, CTRL-C quits"
msgstr "E11: Virheellinen komentorivi-ikkuna, <CR> suorittaa, Ctrl C lopettaa"

msgid "E12: Command not allowed from exrc/vimrc in current dir or tag search"
msgstr ""
"E12: Komentoa ei tueta exrc:ssä tai vimrc:ssä tässä hakemistossa tai "
"tägihaussa"

msgid "E171: Missing :endif"
msgstr "E171: :endif puuttuu"

msgid "E600: Missing :endtry"
msgstr "E600: :endtry puuttuu"

msgid "E170: Missing :endwhile"
msgstr "E170: :endwhile puuttuu"

msgid "E170: Missing :endfor"
msgstr "E170: :endfor puuttuu"

msgid "E588: :endwhile without :while"
msgstr "E588: :endwhile ilman komentoa :while"

msgid "E588: :endfor without :for"
msgstr "E588: :endfor ilman komentoa :for"

msgid "E13: File exists (add ! to override)"
msgstr "E13: Tiedosto on jo olemassa (lisää ! ohittaaksesi)"

msgid "E472: Command failed"
msgstr "E472: Komento epäonnistui"

#, c-format
msgid "E234: Unknown fontset: %s"
msgstr "E234: Tuntematon fontset: %s"

#, c-format
msgid "E235: Unknown font: %s"
msgstr "E235: Tuntematon fontti: %s"

#, c-format
msgid "E236: Font \"%s\" is not fixed-width"
msgstr "E236: Fontti %s ei ole tasavälinen"

msgid "E473: Internal error"
msgstr "E473: Sisäinen virhe"

msgid "Interrupted"
msgstr "Keskeytetty"

msgid "E14: Invalid address"
msgstr "E14: Virheellinen osoite"

msgid "E474: Invalid argument"
msgstr "E474: Virheellinen argumentti"

#, c-format
msgid "E475: Invalid argument: %s"
msgstr "E475: Virheellinen argumentti: %s"

#, c-format
msgid "E15: Invalid expression: %s"
msgstr "E15: Virheellinen ilmaus: %s"

msgid "E16: Invalid range"
msgstr "E16: Virheellinen arvoalue"

msgid "E476: Invalid command"
msgstr "E476: Virheellinen komento"

#, c-format
msgid "E17: \"%s\" is a directory"
msgstr "E17: %s on hakemisto"

#, c-format
msgid "E364: Library call failed for \"%s()\""
msgstr "E364: Kirjastukutsu %s() epäonnistui"

#, c-format
msgid "E448: Could not load library function %s"
msgstr "E448: Ei voitu ladta kirjastofunktiota %s"

msgid "E19: Mark has invalid line number"
msgstr "E19: Merkillä on virheellinen rivinumero"

msgid "E20: Mark not set"
msgstr "E20: Merkkiä ei asetettu"

msgid "E21: Cannot make changes, 'modifiable' is off"
msgstr "E21: Ei voi tehdä muutoksia, modifiable on pois päältä"

msgid "E22: Scripts nested too deep"
msgstr "E22: Liian monta tasoa skripteissä"

msgid "E23: No alternate file"
msgstr "E23: Eo vaihtoehtoista tiedostoa"

msgid "E24: No such abbreviation"
msgstr "E24: Lyhennettä ei ole"

msgid "E477: No ! allowed"
msgstr "E477: ! ei sallittu"

msgid "E25: GUI cannot be used: Not enabled at compile time"
msgstr "E25: GUIta ei voi käyttää, koska sitä ei käännetty mukaan"

msgid "E26: Hebrew cannot be used: Not enabled at compile time\n"
msgstr "E26: Hepreaa ei voi käyttää, koska sitä ei käännetty mukaan\n"

msgid "E27: Farsi cannot be used: Not enabled at compile time\n"
msgstr "E27: Farsia ei voi käyttää, koska sitä ei käännetty mukaan\n"

msgid "E800: Arabic cannot be used: Not enabled at compile time\n"
msgstr "E800: Arabiaa ei voi käyttää, koska sitä ei käännetty mukaan\n"

#, c-format
msgid "E28: No such highlight group name: %s"
msgstr "E28: Korostusryhmää ei ole nimellä: %s"

msgid "E29: No inserted text yet"
msgstr "E29: Tekstiä ei ole syötetty vielä"

msgid "E30: No previous command line"
msgstr "E30: Ei edellistä komentoriviä"

msgid "E31: No such mapping"
msgstr "E31: Kuvausta ei ole"

msgid "E479: No match"
msgstr "E479: Ei täsmää"

#, c-format
msgid "E480: No match: %s"
msgstr "E480: Ei tsämää: %s"

msgid "E32: No file name"
msgstr "E32: Ei tiedostonimeä"

msgid "E33: No previous substitute regular expression"
msgstr "E33: Ei edellistä korvausta säännölliselle ilmaukselle"

msgid "E34: No previous command"
msgstr "E34: Ei edellistä komentoa"

msgid "E35: No previous regular expression"
msgstr "E35: Ei edellistä säännöllistä ilmausta"

msgid "E481: No range allowed"
msgstr "E481: Arvoalue ei sallittu"

msgid "E36: Not enough room"
msgstr "E36: Tila ei riitä"

#, c-format
msgid "E247: no registered server named \"%s\""
msgstr "E247: palvelinta %s ei ole rekisteröitynä"

#, c-format
msgid "E482: Can't create file %s"
msgstr "E482: Tiedostoa %s ei voi luoda"

msgid "E483: Can't get temp file name"
msgstr "E483: väliaikaistiedoston nimeä ei saada selville"

#, c-format
msgid "E484: Can't open file %s"
msgstr "E484: Ei voi avata tiedostoa %s"

#, c-format
msgid "E485: Can't read file %s"
msgstr "E485: Ei voi lukea tiedostoa %s"

msgid "E37: No write since last change (add ! to override)"
msgstr ""
"E37: Viimeisen muutoksen jälkeen ei ole kirjoitettu (lisää ! ohittaaksesi)"

msgid "E37: No write since last change"
msgstr "E37: Viimeisimmän muutoksen jälkeen ei ole kirjoitettu mitään"

msgid "E38: Null argument"
msgstr "E38: Null-argumentti"

msgid "E39: Number expected"
msgstr "E39: Pitää olla numero"

#, c-format
msgid "E40: Can't open errorfile %s"
msgstr "E40: virhetiedostoa %s ei voi avata"

msgid "E233: cannot open display"
msgstr "E233: näyttöä ei voi avata"

msgid "E41: Out of memory!"
msgstr "E41: Muisti loppui"

msgid "Pattern not found"
msgstr "Kuviota ei löydy"

#, c-format
msgid "E486: Pattern not found: %s"
msgstr "E486: Kuviota ei löydy: %s"

msgid "E487: Argument must be positive"
msgstr "E487: Argumentin pitää olla positiivinen"

msgid "E459: Cannot go back to previous directory"
msgstr "E459: Ei voi siirtyä edelliseen hakemistoon"

# ;-)
msgid "E42: No Errors"
msgstr "E42: Ei virheitä"

msgid "E776: No location list"
msgstr "E776: Ei sijaintilistaa"

msgid "E43: Damaged match string"
msgstr "E43: Viallinen täsmäysmerkkijono"

msgid "E44: Corrupted regexp program"
msgstr "E44: Viallinen regexp-ohjelma"

msgid "E45: 'readonly' option is set (add ! to override)"
msgstr "E45: readonly asetettu (lisää ! ohittaaksesi)"

#, c-format
msgid "E46: Cannot change read-only variable \"%s\""
msgstr "E46: Kirjoitussuojattua muuttujaa %s ei voi muuttaa"

#, c-format
msgid "E794: Cannot set variable in the sandbox: \"%s\""
msgstr "E794: Muuttujaa ei voi asettaa hiekkalaatikossa: %s"

msgid "E713: Cannot use empty key for Dictionary"
msgstr "E713: Sanakirjassa ei voi olla tyhjiä avaimia"

msgid "E715: Dictionary required"
msgstr "E715: Sanakirja tarvitaan"

#, c-format
msgid "E684: list index out of range: %ld"
msgstr "E684: Indeksi %ld luettelon rajojen ulkopuolella"

#, c-format
msgid "E118: Too many arguments for function: %s"
msgstr "E118: Liikaa argumentteja funktiolle: %s"

#, c-format
msgid "E716: Key not present in Dictionary: %s"
msgstr "E716: Avainta %s ei ole sanakirjassa"

msgid "E714: List required"
msgstr "E714: Lista tarvitaan"

# datarakenteita
#, c-format
msgid "E712: Argument of %s must be a List or Dictionary"
msgstr "E712: Argumentin %s pitää olla lista tai sanakirja"

msgid "E47: Error while reading errorfile"
msgstr "E47: Virhe virhetiedostoa luettaessa"

msgid "E48: Not allowed in sandbox"
msgstr "E48: Ei sallittu hiekkalaatikossa"

msgid "E523: Not allowed here"
msgstr "E523: Ei sallittu täällä"

msgid "E359: Screen mode setting not supported"
msgstr "E359: Näyttötila-asetus ei tuettu"

msgid "E49: Invalid scroll size"
msgstr "E49: Virheellinen vierityskoko"

msgid "E91: 'shell' option is empty"
msgstr "E91: shell-asetus on tyhjä"

msgid "E255: Couldn't read in sign data!"
msgstr "E255: Merkkidatan luku ei onnistu"

msgid "E72: Close error on swap file"
msgstr "E72: Swap-tiedoston sulkemisvirhe"

msgid "E73: tag stack empty"
msgstr "E73: tägipino tyhjä"

msgid "E74: Command too complex"
msgstr "E74: Liian monimutkainen komento"

msgid "E75: Name too long"
msgstr "E75: Liian pitkä nimi"

msgid "E76: Too many ["
msgstr "E76: Liian monta [:a"

msgid "E77: Too many file names"
msgstr "E77: Liikaa tiedostonimiä"

msgid "E488: Trailing characters"
msgstr "E488: Ylimääräisiä merkkejä perässä"

msgid "E78: Unknown mark"
msgstr "E78: Tuntematon merkki"

msgid "E79: Cannot expand wildcards"
msgstr "E79: Jokerimerkkien avaus ei onnistu"

msgid "E591: 'winheight' cannot be smaller than 'winminheight'"
msgstr "E591: winheight ei voi olla pienempi kuin winminheight"

msgid "E592: 'winwidth' cannot be smaller than 'winminwidth'"
msgstr "E592: winwidth ei voi olla pienempi kuin winminwidth"

msgid "E80: Error while writing"
msgstr "E80: Kirjoitusvirhe"

msgid "Zero count"
msgstr "Nollalaskuri"

msgid "E81: Using <SID> not in a script context"
msgstr "E81: <SID> skriptin ulkopuolella"

msgid "E449: Invalid expression received"
msgstr "E449: Virheellinen ilmaus saatu"

msgid "E463: Region is guarded, cannot modify"
msgstr "E463: Alue on suojattu, muuttaminen ei onnistu"

msgid "E744: NetBeans does not allow changes in read-only files"
msgstr "E744: NetBeans ei tue muutoksia kirjoitussuojattuihin tiedostoihin"

#, c-format
msgid "E685: Internal error: %s"
msgstr "E685: Sisäinen virhe: %s"

msgid "E363: pattern uses more memory than 'maxmempattern'"
msgstr "E363: kuvio käyttää enemmän muistia kuin maxmempattern on"

msgid "E749: empty buffer"
msgstr "E749: tyhjä puskuri"

#, c-format
msgid "E86: Buffer %ld does not exist"
msgstr "E86: Puskuria %ld ei ole"

msgid "E682: Invalid search pattern or delimiter"
msgstr "E682: Virheellinen hakulauseke tai erotin"

msgid "E139: File is loaded in another buffer"
msgstr "E139: Tiedosto on ladattu toiseen puskuriin"

#, c-format
msgid "E764: Option '%s' is not set"
msgstr "E764: Asetus %s on asettamatta"

msgid "E850: Invalid register name"
msgstr "E850: Virheellinen rekisterin nimi"

#, c-format
msgid "E919: Directory not found in '%s': \"%s\""
msgstr "E919: Hakemisto puuttuu kohteesta %s: %s"

msgid "search hit TOP, continuing at BOTTOM"
msgstr "haku pääsi ALKUUN, jatketaan LOPUSTA"

msgid "search hit BOTTOM, continuing at TOP"
msgstr "haku pääsi LOPPUUN, jatketaan ALUSTA"

#, c-format
msgid "Need encryption key for \"%s\""
msgstr "Tarvitaan salausavain kohteelle %s "

msgid "empty keys are not allowed"
msgstr "tyhjiä avaimia ei voi käyttää"

msgid "dictionary is locked"
msgstr "dictionary on lukittu"

msgid "list is locked"
msgstr "luettelo on lukittu"

#, c-format
msgid "failed to add key '%s' to dictionary"
msgstr "avaimen %s lisääminen sanakirjaan ei onnistu"

#, c-format
msgid "index must be int or slice, not %s"
msgstr "indeksin pitää olla int tai slice, ei %s"

#, c-format
msgid "expected str() or unicode() instance, but got %s"
msgstr "odottettiin insanssia tyypeistä str() tai unicode(), ei %s"

#, c-format
msgid "expected bytes() or str() instance, but got %s"
msgstr "odotettiin instanssia tyypeistä bytes() tai str(), ei %s"

#, c-format
msgid ""
"expected int(), long() or something supporting coercing to long(), but got %s"
msgstr ""
"odotettiin instanssia tyypeistä int(), long() tai mitä tahansa joka muuntuisi "
"tyyppiin long(), ei %s"

#, c-format
msgid "expected int() or something supporting coercing to int(), but got %s"
msgstr "odotettiin tyyppiä int() tai jotain joka muuntuu tyyppiin int(), ei %s"

msgid "value is too large to fit into C int type"
msgstr "arvo on liian suuri mahtumaan C:n int-tyyppiin"

msgid "value is too small to fit into C int type"
msgstr "arvo on liian pieni mahtumaan C:n int-tyyppiin"

msgid "number must be greater than zero"
msgstr "luvun on oltava nollaa suurempi"

msgid "number must be greater or equal to zero"
msgstr "luvun on oltava yhtä suuri tai suurempi kuin nolla"

msgid "can't delete OutputObject attributes"
msgstr "ei voi poistaa OutputObject-attribuutteja"

#, c-format
msgid "invalid attribute: %s"
msgstr "virheellinen attribuutti: %s"

msgid "E264: Python: Error initialising I/O objects"
msgstr "E264: Python: Virhe IO-olioiden alustuksessa"

msgid "failed to change directory"
msgstr "hakemistoa ei voitu muuttaa"

#, c-format
msgid "expected 3-tuple as imp.find_module() result, but got %s"
msgstr "odotettiin 3-tuplea tuloksena imp.find_module()-kutsulle, ei %s"

#, c-format
msgid "expected 3-tuple as imp.find_module() result, but got tuple of size %d"
msgstr "odotettiin 3-tuple tuloksnea imp.find_module()-kutsulle, mutta tuplen "
"koko onkin %d"

msgid "internal error: imp.find_module returned tuple with NULL"
msgstr "sisäinen virhe: imp.find_module palautti tuplen joka sisältää nullin"

msgid "cannot delete vim.Dictionary attributes"
msgstr "ei voi poistaa vim.Dictionary-attribuutteja"

msgid "cannot modify fixed dictionary"
msgstr "ei voida muuttaa kiinnitettyä sanakirjaa"

#, c-format
msgid "cannot set attribute %s"
msgstr "ei voi asettaa attribuuttia %s"

msgid "hashtab changed during iteration"
msgstr "hashtab muuttui kesken iteraation"

#, c-format
msgid "expected sequence element of size 2, but got sequence of size %d"
msgstr "sekvenssin elementin koon pitäisi olla 2, ei %d"

msgid "list constructor does not accept keyword arguments"
msgstr "listakonstruktori ei tue avainsanaparametrejä"

msgid "list index out of range"
msgstr "listaindeksi arvoalueen ulkopuolelta"

#. No more suitable format specifications in python-2.3
#, c-format
msgid "internal error: failed to get vim list item %d"
msgstr "sisäinen virhe: ei pystytty hakea vimin listan indeksiä %d"

msgid "slice step cannot be zero"
msgstr "slicen askel ei voi olla nolla"

#, c-format
msgid "attempt to assign sequence of size greater than %d to extended slice"
msgstr "yritettiin sijoittaa sekvenssiä jonka koko on enemmän kuin %d sliceen"

#, c-format
msgid "internal error: no vim list item %d"
msgstr "sisäinen virhe: ei vim-listan indeksiä %d"

msgid "internal error: not enough list items"
msgstr "sisäinen virhe: ei tarpeeksi listan kohtia"

msgid "internal error: failed to add item to list"
msgstr "sisäinen virhe: ei voitu lisätä kohtaa listaan"

#, c-format
msgid "attempt to assign sequence of size %d to extended slice of size %d"
msgstr "yritettiin asettaa sekvenssiä jonka koko on %d sliceen jonka koko on %d"

msgid "failed to add item to list"
msgstr "ei voitu lisätä kohtaa listaan"

msgid "cannot delete vim.List attributes"
msgstr "ei voi poistaa vim.List-attribuutteja"

msgid "cannot modify fixed list"
msgstr "ei voida muokata kiinitettyä listaa"

#, c-format
msgid "unnamed function %s does not exist"
msgstr "nimetöntä funktiota %s ei ole"

#, c-format
msgid "function %s does not exist"
msgstr "funktiota %s ei ole"

#, c-format
msgid "failed to run function %s"
msgstr "ei voitu suorittaa funktiota %s"

msgid "unable to get option value"
msgstr "ei voitu hakea asetuksen arvoa"

msgid "internal error: unknown option type"
msgstr "sisäinen virhe: tuntematon asetustyyppi"

msgid "problem while switching windows"
msgstr "virhe ikkunaa vaihtaessa"

#, c-format
msgid "unable to unset global option %s"
msgstr "ei voi tyhjentää yleistä asetusta %s"

#, c-format
msgid "unable to unset option %s which does not have global value"
msgstr "ei voi tyhjentää asetusta %s jolla ei ole yleistä arvoa"

msgid "attempt to refer to deleted tab page"
msgstr "yritettiin viitata poistettuun välilehteen"

msgid "no such tab page"
msgstr "välilehteä ei ole"

msgid "attempt to refer to deleted window"
msgstr "yritettiin viitata poistettuun ikkunaan"

msgid "readonly attribute: buffer"
msgstr "kirjoitussuojausattribuutti: puskuri"

msgid "cursor position outside buffer"
msgstr "kursorin sijainti puskurin ulkopuolella"

msgid "no such window"
msgstr "ikkunaa ei ole"

msgid "attempt to refer to deleted buffer"
msgstr "yritettiin viitata poistettuun puskuriin"

msgid "failed to rename buffer"
msgstr "ei voity uudelleennimetä puskuria"

msgid "mark name must be a single character"
msgstr "merkin nimen pitää olla yksi merkki"

#, c-format
msgid "expected vim.Buffer object, but got %s"
msgstr "odotettiin vim.Buffer-oliota, ei %s"

#, c-format
msgid "failed to switch to buffer %d"
msgstr "ei voitu vaihtaa puskuriin %d"

#, c-format
msgid "expected vim.Window object, but got %s"
msgstr "odotettiin vim.Window-oliota, saatiin %s"

msgid "failed to find window in the current tab page"
msgstr "ei voitu löytää ikkunaa nykyiselle välilehtisivulle"

msgid "did not switch to the specified window"
msgstr "ei vaihdettu annettuun ikkunaan"

#, c-format
msgid "expected vim.TabPage object, but got %s"
msgstr "odotettiin vim.TabPage-oliota, saatiin %s"

msgid "did not switch to the specified tab page"
msgstr "ei voitu vaihtaa annetulle välilehtisivulle"

msgid "failed to run the code"
msgstr "ei voitu suorittaa koodia"

msgid "E858: Eval did not return a valid python object"
msgstr "E858: Eval ei palauttanut python-oliota"

msgid "E859: Failed to convert returned python object to vim value"
msgstr "E859: Ei voitu konvertoida python-oliota vim-arvoksi"

#, c-format
msgid "unable to convert %s to vim dictionary"
msgstr "ei voitu konvertoida oliota %s vim-sanakirjaksi"

#, c-format
msgid "unable to convert %s to vim list"
msgstr "ei voitu konvertoida tyypistä %s vim-listaksi"

#, c-format
msgid "unable to convert %s to vim structure"
msgstr "ei voi konvertoida oliota %s vim-tietorakenteeksi"

msgid "internal error: NULL reference passed"
msgstr "sisäinen virhe: NULL-viite annettu"

msgid "internal error: invalid value type"
msgstr "sisäinen virhe: huono arvotyyppi"

msgid ""
"Failed to set path hook: sys.path_hooks is not a list\n"
"You should now do the following:\n"
"- append vim.path_hook to sys.path_hooks\n"
"- append vim.VIM_SPECIAL_PATH to sys.path\n"
msgstr ""
"Ei voitu asettaa polkukoukkua: sys.path_hooks ei ole lista\n"
"Koeta seuraavaa:\n"
"- lisää vim.path_hook muuttujaan sys.path_hooks\n"
"- lisää vim.VIM_SPECIAL_PATH muuttujaan sys.path\n"


msgid ""
"Failed to set path: sys.path is not a list\n"
"You should now append vim.VIM_SPECIAL_PATH to sys.path"
msgstr ""
"Ei onnistuttu asettaman polkua: sys.path ei ole list\n"
"Lisää vim.VIM_SPECIAL_PATH muuttujaan sys.path"

