<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
  
          http://www.apache.org/licenses/LICENSE-2.0
  
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="application_name" msgid="1935869255545976415">"Brauser"</string>
    <string name="choose_upload" msgid="3649366287575002063">"Valige fail üleslaadimiseks"</string>
    <string name="uploads_disabled" msgid="463761197575372994">"Failide üleslaadimised on keelatud."</string>
    <string name="new_tab" msgid="7971857320679510529">"Uus vaheleht"</string>
    <string name="new_incognito_tab" msgid="3606197964239039478">"Uus inkognitovaheleht"</string>
    <string name="tab_bookmarks" msgid="2305793036003473653">"Järjehoidjad"</string>
    <string name="tab_most_visited" msgid="1077402532455000703">"Enim külastatud"</string>
    <string name="tab_history" msgid="1979267558744613746">"Ajalugu"</string>
    <string name="tab_snapshots" msgid="1449241204980265186">"Salvestatud lehed"</string>
    <string name="added_to_bookmarks" msgid="4028710765672851635">"Lisatud järjehoidjatesse"</string>
    <string name="removed_from_bookmarks" msgid="546648923924996722">"Järjehoidjatest eemaldatud"</string>
    <string name="sign_in_to" msgid="5939425800148759165">"Logige sisse saidile <xliff:g id="HOSTNAME">%s1</xliff:g> „<xliff:g id="REALM">%s2</xliff:g>”"</string>
    <string name="username" msgid="5057566336518215922">"Nimi"</string>
    <string name="password" msgid="1177138552305184404">"Parool"</string>
    <string name="action" msgid="183105774472071343">"Logi sisse"</string>
    <string name="bookmarks_add_page" msgid="3093456701072617702">"Järjehoidja salvestamine"</string>
    <string name="bookmarks_search" msgid="5229596268214362873">"Brauser"</string>
    <string name="cancel" msgid="3017274947407233702">"Tühista"</string>
    <string name="ok" msgid="1509280796718850364">"OK"</string>
    <string name="title_bar_loading" msgid="7438217780834640678">"Laadimine ..."</string>
    <string name="page_info" msgid="4048529256302257195">"Lehe teave"</string>
    <string name="page_info_view" msgid="5303490449842635158">"Kuva lehe teave"</string>
    <string name="page_info_address" msgid="2222306609532903254">"Aadress:"</string>
    <string name="ssl_warnings_header" msgid="79744901983636370">"Selle saidi turvasertifikaadiga on probleeme."</string>
    <string name="ssl_continue" msgid="8031515015829358457">"Jätka"</string>
    <string name="security_warning" msgid="6607795404322797541">"Turvahoiatus"</string>
    <string name="view_certificate" msgid="1472768887529093862">"Kuva sertifikaat"</string>
    <string name="ssl_go_back" msgid="4598951822061593819">"Mine tagasi"</string>
    <string name="ssl_untrusted" msgid="7754507359360636447">"See sertifikaat ei pärine usaldusväärselt asutuselt."</string>
    <string name="ssl_mismatch" msgid="3809794439740523641">"Saidi nimi ei vasta sertifikaadil olevale nimele."</string>
    <string name="ssl_expired" msgid="5739349389499575559">"See sertifikaat on aegunud."</string>
    <string name="ssl_not_yet_valid" msgid="8193083327719048247">"See sertifikaat pole veel kehtiv."</string>
    <string name="ssl_date_invalid" msgid="3705563379257285534">"Sellel sertifikaadil on kehtetu kuupäev."</string>
    <string name="ssl_invalid" msgid="9041704741505449967">"See sertifikaat on kehtetu."</string>
    <string name="ssl_unknown" msgid="5679243486524754571">"Tundmatu sertifikaadiviga."</string>
    <string name="stopping" msgid="4839698519340302982">"Peatumine ..."</string>
    <string name="stop" msgid="5687251076030630074">"Peata"</string>
    <string name="reload" msgid="8585220783228408062">"Värskenda"</string>
    <string name="back" msgid="8414603107175713668">"Tagasi"</string>
    <string name="forward" msgid="4288210890526641577">"Edasta"</string>
    <string name="save" msgid="5922311934992468496">"OK"</string>
    <string name="do_not_save" msgid="6777633870113477714">"Tühista"</string>
    <string name="location" msgid="3411848697912600125">"Aadress"</string>
    <string name="account" msgid="5179824606448077042">"Konto"</string>
    <string name="containing_folder" msgid="6771180232953030479">"Lisa asukohta"</string>
    <string name="new_folder" msgid="7743540149088867917">"Uus kaust"</string>
    <string name="edit_folder" msgid="621817453133656156">"Kausta muutmine"</string>
    <string name="delete_folder" msgid="2046483129024501116">"Kausta kustutamine"</string>
    <string name="no_subfolders" msgid="3303645239686962674">"Alamkaustu pole."</string>
    <string name="add_to_bookmarks_menu_option" msgid="4449323955122214389">"Järjehoidjad"</string>
    <string name="add_to_homescreen_menu_option" msgid="1461447829242963790">"Avaekraan"</string>
    <string name="add_to_other_folder_menu_option" msgid="5947586525822134105">"Muu kaust"</string>
    <string name="name" msgid="5462672162695365387">"Silt"</string>
    <string name="http" msgid="2163722670597250102">"http://"</string>
    <string name="save_to_bookmarks" msgid="1679286010089780932">"Salvesta järjehoidjatesse."</string>
    <string name="bookmark_this_page" msgid="7530739804320811054">"Lehe järjehoidjatesse lisamine"</string>
    <string name="remove" msgid="7820112494467011374">"Eemalda"</string>
    <string name="edit_bookmark" msgid="5024089053490231905">"Muuda järjehoidjat"</string>
    <string name="create_shortcut_bookmark" msgid="1995095662095484289">"Lisa otsetee avalehele"</string>
    <string name="open_bookmark" msgid="8473581305759935790">"Ava"</string>
    <string name="remove_bookmark" msgid="8407495852801410891">"Kustuta järjehoidja"</string>
    <string name="remove_from_bookmarks" msgid="4374080666576982775">"Eemalda järjehoidjatest"</string>
    <string name="remove_history_item" msgid="5021424935726728618">"Eemalda ajaloost"</string>
    <string name="set_as_homepage" msgid="4752937379414905560">"Määra avaleheks"</string>
    <string name="bookmark_saved" msgid="2766434679871317557">"Salvestatud järjehoidjatesse."</string>
    <string name="bookmark_not_saved" msgid="1077732557310662080">"Järjehoidjat ei saanud salvestada."</string>
    <string name="homepage_set" msgid="8768087280310966395">"Avaleht määratud."</string>
    <string name="bookmark_needs_title" msgid="6245900436119218187">"Järjehoidjal peab olema nimi."</string>
    <string name="bookmark_needs_url" msgid="7809876865972755158">"Järjehoidjal peab olema asukoht."</string>
    <string name="bookmark_url_not_valid" msgid="4917440933384496211">"URL on kehtetu."</string>
    <string name="bookmark_cannot_save_url" msgid="7836064647943671126">"Seda URL-i ei saa järjehoidjatesse lisada."</string>
    <string name="bookmark_page" msgid="6845189305130307274">"Lisa viimati vaadatud leht järjehoidjatesse"</string>
    <string name="bookmark_thumbnail_view" msgid="3164068314718522138">"Pisipildid"</string>
    <string name="bookmark_list_view" msgid="7848510619500937839">"Loend"</string>
    <string name="current_page" msgid="7510129573681663135">"allikast "</string>
    <string name="delete_bookmark_warning" msgid="7825328496411904321">"Kustutada järjehoidja „<xliff:g id="BOOKMARK">%s</xliff:g>”?"</string>
    <string name="open_all_in_new_window" msgid="455786763426575293">"Ava kõik uutel vahelehtedel"</string>
    <string name="goto_dot" msgid="3895839050522602723">"Mine"</string>
    <string name="select_dot" msgid="6299170761900561967">"Valige tekst"</string>
    <string name="close_other_tabs" msgid="7693157495148282778">"Sule teised vahekaardid"</string>
    <string name="bookmarks" msgid="1961279134885867815">"Järjehoidjad"</string>
    <string name="shortcut_bookmark" msgid="3974876480401135895">"Järjehoidja"</string>
    <string name="shortcut_bookmark_title" msgid="7570786275916681296">"Järjehoidja valimine"</string>
    <string name="history" msgid="2451240511251410032">"Ajalugu"</string>
    <string name="menu_view_download" msgid="2124570321712995120">"Allalaadimised"</string>
    <string name="copy_page_url" msgid="1188679152608889555">"Kopeeri lehe URL"</string>
    <string name="share_page" msgid="593756995297268343">"Jaga lehte"</string>
    <string name="menu_save_snapshot" msgid="6935080344031126139">"Salvesta offlainis lugemiseks"</string>
    <string name="saving_snapshot" msgid="1693789062351182809">"Salvestamine ..."</string>
    <string name="snapshot_failed" msgid="4584580873565876033">"Võrguühenduseta lugemiseks salvestam. ebaõnnestus."</string>
    <string name="contextheader_folder_bookmarkcount" msgid="353987136645619089">"<xliff:g id="BOOKMARK_COUNT">%d</xliff:g> järjehoidjat"</string>
    <string name="contextheader_folder_empty" msgid="974171637803391651">"Tühi kaust"</string>
    <string name="contextmenu_openlink" msgid="7237961252214188935">"Ava"</string>
    <string name="contextmenu_openlink_newwindow" msgid="1205313604181761403">"Ava uuel vahelehel"</string>
    <string name="contextmenu_openlink_newwindow_background" msgid="4690381019116746687">"Ava uuel taustavahelehel"</string>
    <string name="contextmenu_savelink" msgid="5508554930832538184">"Salvesta link"</string>
    <string name="contextmenu_sharelink" msgid="5392275392280130331">"Jaga linki"</string>
    <string name="contextmenu_copy" msgid="398860586635404030">"Kopeeri"</string>
    <string name="contextmenu_copylink" msgid="5153657160294534270">"Kopeeri lingi URL"</string>
    <string name="contextmenu_download_image" msgid="4243829645180686912">"Salvesta kujutis"</string>
    <string name="contextmenu_view_image" msgid="3870625602053600905">"Kuva kujutis"</string>
    <string name="contextmenu_set_wallpaper" msgid="3691902960115350686">"Määra taustapildiks"</string>
    <string name="contextmenu_dial_dot" msgid="5856550683415933806">"Valimine ..."</string>
    <string name="contextmenu_add_contact" msgid="3183511922223645716">"Lisa kontakt"</string>
    <string name="contextmenu_send_mail" msgid="1014513374828775660">"Saada meil"</string>
    <string name="contextmenu_map" msgid="7471390435434034912">"Kaart"</string>
    <string name="choosertitle_sharevia" msgid="4600490613341909086">"Jaga rakendusega:"</string>
    <string name="clear" msgid="7070043081700011461">"Kustuta"</string>
    <string name="replace" msgid="4843033491070384047">"Asenda"</string>
    <string name="browser_bookmarks_page_bookmarks_text" msgid="6787605028726162673">"Järjehoidjad"</string>
    <string name="menu_preferences" msgid="6709237687234102240">"Seaded"</string>
    <string name="pref_content_title" msgid="3834107397725342174">"Lehe sisu"</string>
    <string name="pref_allow_apptabs" msgid="1325989799080202871">"Luba mitu vahekaarti rakenduse kohta"</string>
    <string name="pref_content_load_images" msgid="2125616852957377561">"Laadi kujutisi"</string>
    <string name="pref_content_load_images_summary" msgid="5055874125248398584">"Kuva kujutised veebilehtedel"</string>
    <string name="pref_content_block_popups" msgid="4158524847764470895">"Blokeeri hüpikaknad"</string>
    <string name="pref_content_javascript" msgid="4570972030299516843">"Luba JavaScript"</string>
    <string name="pref_content_open_in_background" msgid="824123779725118663">"Ava taustal"</string>
    <string name="pref_content_plugins" msgid="7231944644794301582">"Luba pistikprogrammid"</string>
  <string-array name="pref_content_plugins_choices">
    <item msgid="6745108155096660725">"Alati"</item>
    <item msgid="2484126708670016519">"Nõudluses"</item>
    <item msgid="8547442717307793863">"Väljas"</item>
  </string-array>
    <string name="pref_content_open_in_background_summary" msgid="955411158407739504">"Uute vahelehtede avamine praeguse taga"</string>
    <string name="pref_content_homepage" msgid="3324574611613105696">"Määra avaleheks"</string>
    <string name="pref_content_search_engine" msgid="1620101310821644144">"Määra otsingumootor"</string>
    <string name="pref_content_search_engine_summary" msgid="304003941861818133">"Valige otsingumootor"</string>
    <string name="pref_set_homepage_to" msgid="7838684355145561242">"Sea avaleheks"</string>
  <string-array name="pref_homepage_choices">
    <item msgid="844041670142910837">"Praegune leht"</item>
    <item msgid="4430498748295169195">"Tühi leht"</item>
    <item msgid="5747608191946904074">"Vaikeleht"</item>
    <item msgid="6092441301001006473">"Enim külastatavad saidid"</item>
    <item msgid="6569304572171444894">"Muu"</item>
  </string-array>
    <string name="pref_content_autofit" msgid="8260474534053660809">"Sobita lehed automaatselt"</string>
    <string name="pref_content_autofit_summary" msgid="324810555822572112">"Veebilehtede vormindamine ekraanile sobitumiseks"</string>
    <string name="pref_general_title" msgid="1946872771219249323">"Üldine"</string>
    <string name="pref_general_sync_title" msgid="3138637035975860324">"Sünkroonimine"</string>
    <string name="pref_general_autofill_title" msgid="547881256865816858">"Andmetega automaatselt täitmine"</string>
    <string name="pref_autofill_enabled" msgid="1015751713312396713">"Täida vorm automaatselt"</string>
    <string name="pref_autofill_enabled_summary" msgid="7659954073892471496">"Täitke veebivorme ühe puudutusega"</string>
    <string name="pref_autofill_profile_editor" msgid="8934844472922113166">"Automaatse täitmise tekst"</string>
    <string name="pref_autofill_profile_editor_summary" msgid="4864447251676856190">"Seadistage tekst, mida soovite automaatselt lisada veebivormidesse."</string>
    <string name="pref_autologin_title" msgid="4421187193809267096">"Auto. sisselogimine Google\'isse"</string>
    <string name="pref_autologin_progress" msgid="8333244467048833461">"Google\'i saitidele sisselogimine, kasutades kontot <xliff:g id="ID_1">%s</xliff:g>"</string>
    <string name="autologin_bar_text" msgid="3684581827167173371">"Logi sisse kasutajanimega"</string>
    <string name="autologin_bar_login_text" msgid="3336615320510851879">"Logi sisse"</string>
    <string name="autologin_bar_hide_text" msgid="3629355974385859580">"Peida"</string>
    <string name="autologin_bar_error" msgid="7470001207395920811">"Sisselogimine ebaõnnestus"</string>
    <string name="autofill_profile_editor_heading" msgid="4798644544927738078">"Tippige tekst, mida soovite automaatselt lisada veebivormidesse."</string>
    <string name="autofill_profile_editor_name" msgid="8566130291459685955">"Täisnimi:"</string>
    <string name="autofill_profile_editor_email_address" msgid="7967585896612797173">"E-post:"</string>
    <string name="autofill_profile_editor_company_name" msgid="2813443159949210417">"Ettevõtte nimi:"</string>
    <string name="autofill_profile_editor_address_line_1" msgid="836433242509243081">"Aadressirida 1:"</string>
    <string name="autofill_profile_editor_address_line_1_hint" msgid="5965659598509327172">"Tänav, postkast, vahendaja"</string>
    <string name="autofill_profile_editor_address_line_2" msgid="8194745202893822479">"Aadressirida 2:"</string>
    <string name="autofill_profile_editor_address_line_2_hint" msgid="8529642768127569254">"Korter, sviit, üksus, maja, korrus jne"</string>
    <string name="autofill_profile_editor_city" msgid="7306716145784997135">"Linn/alev:"</string>
    <string name="autofill_profile_editor_state" msgid="2150403366835080407">"Osariik/maakond/piirkond:"</string>
    <string name="autofill_profile_editor_zip_code" msgid="283668573295656671">"Sihtnumber:"</string>
    <string name="autofill_profile_editor_country" msgid="7234470301239156656">"Riik:"</string>
    <string name="autofill_profile_editor_phone_number" msgid="4938852821413729276">"Telefon:"</string>
    <string name="autofill_profile_editor_phone_number_invalid" msgid="6795411298467068957">"Kehtetu telefoninumber."</string>
    <string name="autofill_profile_editor_save_profile" msgid="3230301454458581157">"Salvesta"</string>
    <string name="autofill_profile_successful_save" msgid="5691459703493331983">"Automaatse täitmise tekst on salvestatud."</string>
    <string name="autofill_profile_successful_delete" msgid="1790262652460723127">"Automaatse täitmise tekst kustutatud."</string>
    <string name="autofill_profile_editor_delete_profile" msgid="3098369314558164153">"Kustuta"</string>
    <string name="autofill_setup_dialog_message" msgid="7123905786076456503">"Brauser suudab selliseid veebivorme automaatselt täita. Kas soovite seadistada teksti automaatse täitmise?"</string>
    <string name="autofill_setup_dialog_negative_toast" msgid="3288881675232206984">"Automaatse täitmise teksti saate alati seadistada, tehes valikud Brauser &gt; Seaded &gt; Üldine kuva."</string>
    <string name="disable_autofill" msgid="8305901059849400354">"Keela automaatne täitmine"</string>
    <string name="pref_privacy_security_title" msgid="3480313968942160914">"Privaatsus ja turvalisus"</string>
    <string name="pref_privacy_clear_cache" msgid="3380316479925886998">"Tühjenda vahemälu"</string>
    <string name="pref_privacy_clear_cache_summary" msgid="2216463577207991454">"Kustuta kohalikult vahemällu talletatud sisu ja andmebaasid"</string>
    <string name="pref_privacy_clear_cache_dlg" msgid="4344512581716422465">"Kas kustutada kohalikku vahemällu talletatud sisu ja andmebaasid?"</string>
    <string name="pref_privacy_cookies_title" msgid="6763274282214830526">"Küpsised"</string>
    <string name="pref_privacy_clear_cookies" msgid="3095583579133780331">"Kustuta kõik küpsiseandmed"</string>
    <string name="pref_privacy_clear_cookies_summary" msgid="6962742063990677520">"Kustuta kõik brauseri küpsised"</string>
    <string name="pref_privacy_clear_cookies_dlg" msgid="1493252163164621278">"Kas kustutada kõik küpsised?"</string>
    <string name="pref_privacy_clear_history" msgid="8723795508825198477">"Kustuta ajalugu"</string>
    <string name="pref_privacy_clear_history_summary" msgid="6868501330708940734">"Kustuta brauseri navigeerimisajalugu"</string>
    <string name="pref_privacy_clear_history_dlg" msgid="6934317391642846227">"Kas kustutada brauseri navigeerimisajalugu?"</string>
    <string name="pref_privacy_formdata_title" msgid="6549813837982050424">"Vormi andmed"</string>
    <string name="pref_privacy_clear_form_data" msgid="4232668196344383987">"Kustuta vormi andmed"</string>
    <string name="pref_privacy_clear_form_data_summary" msgid="7702091143640546200">"Kustuta kõik salvestatud vormiandmed"</string>
    <string name="pref_privacy_clear_form_data_dlg" msgid="8205626042241338983">"Kas kustutada kõik salvestatud vormiandmed?"</string>
    <string name="pref_privacy_clear_passwords" msgid="4750234112289277480">"Kustuta paroolid"</string>
    <string name="pref_privacy_clear_passwords_summary" msgid="8856782718942903335">"Kustuta kõik salvestatud paroolid"</string>
    <string name="pref_privacy_clear_passwords_dlg" msgid="5836576259947160045">"Kas kustutada kõik salvestatud paroolid?"</string>
    <string name="pref_privacy_location_title" msgid="7458378016606081067">"Asukoht"</string>
    <string name="pref_privacy_enable_geolocation" msgid="1395040170290765686">"Luba asukoht"</string>
    <string name="pref_privacy_enable_geolocation_summary" msgid="8437020934664306205">"Luba saitidel taotleda juurdepääsu teie asukohale"</string>
    <string name="pref_privacy_clear_geolocation_access" msgid="6649680770030042980">"Kustuta asukoha juurdepääs"</string>
    <string name="pref_privacy_clear_geolocation_access_summary" msgid="7750143359497314679">"Kustuta kõikide veebisaitide asukoha juurdepääs"</string>
    <string name="pref_privacy_clear_geolocation_access_dlg" msgid="3190928760598034346">"Kas kustutada veebisaidi asukoha juurdepääs?"</string>
    <string name="pref_security_passwords_title" msgid="5734190542383756711">"Paroolid"</string>
    <string name="pref_security_remember_passwords" msgid="6492957683454529549">"Pea paroolid meeles"</string>
    <string name="pref_security_remember_passwords_summary" msgid="256388703356349137">"Salvesta veebisaitidel olevad kasutajanimed ja paroolid"</string>
    <string name="pref_security_save_form_data" msgid="1213669802810198893">"Pidage meeles vormi andmed"</string>
    <string name="pref_security_save_form_data_summary" msgid="4994074685153708026">"Pea minu vormides sisestatavad andmed hilisemaks kasutamiseks meeles"</string>
    <string name="pref_security_show_security_warning" msgid="8901135676266754559">"Näita turvahoiatusi"</string>
    <string name="pref_security_show_security_warning_summary" msgid="5260098316025397525">"Näita hoiatust, kui saidi turvalisusega on probleeme"</string>
    <string name="pref_security_accept_cookies" msgid="3201367661925047989">"Nõustu küpsistega"</string>
    <string name="pref_security_accept_cookies_summary" msgid="1907951236154433751">"Luba saitidel salvestada ja lugeda küpsiseandmeid"</string>
  <string-array name="pref_text_size_choices">
    <item msgid="4952686548944739548">"Pisike"</item>
    <item msgid="1950030433642671460">"Väike"</item>
    <item msgid="4338347520133294584">"Tavaline"</item>
    <item msgid="5043128215356351184">"Suur"</item>
    <item msgid="7201512237890458902">"Väga suur"</item>
  </string-array>
    <string name="pref_min_font_size" msgid="8811125835817449131">"Fondi miinimumsuurus"</string>
    <string name="pref_min_font_size_value" msgid="2924708480509060209">"<xliff:g id="FONT_SIZE">%d</xliff:g> pt"</string>
    <string name="pref_text_zoom" msgid="5171056101805125497">"Teksti skaleerimine"</string>
    <string name="pref_zoom_on_double_tap" msgid="902786475250741795">"Suumi topeltpuudutusel"</string>
    <string name="pref_force_userscalable" msgid="5641500562399892621">"Suumi jõuga lubamine"</string>
    <string name="pref_force_userscalable_summary" msgid="3613242300617172230">"Alistada saidi taotlus suumi juht.?"</string>
    <string name="pref_inverted_category" msgid="1280639705117152207">"Ekraani pööratud esitus"</string>
    <string name="pref_inverted" msgid="7613556986776824112">"Negatiivesitus"</string>
    <string name="pref_inverted_summary" msgid="7357225897413923085">"Must muutub valgeks ja vastupidi"</string>
    <string name="pref_inverted_contrast" msgid="8527441236225288169">"Kontrast"</string>
    <string name="pref_default_zoom" msgid="8076142259097187395">"Vaikesuum"</string>
  <string-array name="pref_default_zoom_choices">
    <item msgid="549583171195154919">"Kaugele"</item>
    <item msgid="5619034257768161024">"Keskmine"</item>
    <item msgid="3840999588443167001">"Sule"</item>
  </string-array>
    <string name="pref_default_zoom_dialogtitle" msgid="6095974367125109021">"Vaikesuum"</string>
    <string name="pref_content_load_page" msgid="2219810141690955452">"Ava lehed ülevaates"</string>
    <string name="pref_content_load_page_summary" msgid="9168803276420332955">"Kuva just avatud lehtede ülevaade"</string>
    <string name="pref_extras_title" msgid="7075456173747370647">"Täpsemad"</string>
    <string name="pref_extras_website_settings" msgid="67866640052455549">"Veebisaidi seaded"</string>
    <string name="pref_extras_website_settings_summary" msgid="1656771443223494406">"Individuaalsete veebisaitide täpsemad seaded"</string>
    <string name="pref_extras_reset_default_title" msgid="3579760449455761762">"Vaikeseadete lähtestamine"</string>
    <string name="pref_extras_reset_default" msgid="8904000515846202110">"Lähtesta vaikeseadetele"</string>
    <string name="pref_extras_reset_default_summary" msgid="4247870778270414501">"Taasta vaikeseaded"</string>
    <string name="pref_extras_reset_default_dlg" msgid="7922814420184322450">"Kas taastada seaded vaikeväärtustele?"</string>
    <string name="pref_development_title" msgid="3263854204533056480">"Silumine"</string>
    <string name="pref_default_text_encoding" msgid="5742965543955558478">"Teksti kodeerimine"</string>
  <string-array name="pref_default_text_encoding_choices">
    <item msgid="7275223955790513818">"Ladina-1 (ISO-8859-1)"</item>
    <item msgid="2456597866837587140">"Unicode (UTF-8)"</item>
    <item msgid="6122474363777211732">"Hiina keel (GBK)"</item>
    <item msgid="373372275931607040">"Hiina keel (Big5)"</item>
    <item msgid="891615911084608570">"Jaapani keel (ISO-2022-JP)"</item>
    <item msgid="5589150448475151241">"Jaapani keel (Shift_JIS)"</item>
    <item msgid="7356792686950371843">"Jaapani keel (EUC-JP)"</item>
    <item msgid="2193955365569270096">"Korea keel (EUC-KR)"</item>
  </string-array>
    <string name="pref_default_text_encoding_dialogtitle" msgid="5508255018084978547">"Teksti kodeerimine"</string>
    <string name="pref_accessibility_title" msgid="5127836981587423215">"Juurdepääsetavus"</string>
    <string name="pref_font_size_category" msgid="6683754355084218254">"Teksti suurus"</string>
    <string name="pref_lab_title" msgid="5571091610359629423">"Laborid"</string>
    <string name="pref_lab_quick_controls" msgid="3267606522082281367">"Kiirnupud"</string>
    <string name="pref_lab_quick_controls_summary" msgid="3149664132600968775">"Kiirn. avamiseks, rak. ja URL-riba peitmiseks libistage pöidlaga v või p serval."</string>
    <string name="pref_use_instant_search" msgid="1119176077760723740">"Google Instant"</string>
    <string name="pref_use_instant_search_summary" msgid="839320474961917522">"Kui kasutate Google Searchi, siis kasutage ka Google Instanti tulemuste nägemiseks tippimise ajal (see võib suurendada andmemahtu)."</string>
    <string name="pref_lab_fullscreen" msgid="8173609016657987973">"Täisekraan"</string>
    <string name="pref_lab_fullscreen_summary" msgid="7694738112219376740">"Kasutage täisekraanrežiimi olekuriba peitmiseks"</string>
    <string name="pref_data_title" msgid="7255058703417796578">"Ribalaiuse haldus"</string>
    <string name="pref_data_preload_title" msgid="4479320472980292873">"Otsingutulemuse eellaadimine"</string>
  <string-array name="pref_data_preload_choices">
    <item msgid="5180466923190095508">"Mitte kunagi"</item>
    <item msgid="1791664748778640002">"Ainult WiFi puhul"</item>
    <item msgid="3944061253437827617">"Alati"</item>
  </string-array>
    <string name="pref_data_preload_summary" msgid="3809168910751382727">"Lubage brauseril väga usaldusväärseid otsingutulemusi taustal eellaadida"</string>
    <string name="pref_data_preload_dialogtitle" msgid="8421297746110796536">"Otsingutulemuse eellaadimine"</string>
    <string name="pref_link_prefetch_title" msgid="4123685219009241072">"Veebilehe eellaadimine"</string>
  <string-array name="pref_link_prefetch_choices">
    <item msgid="4889781230398008031">"Mitte kunagi"</item>
    <item msgid="1908465963242077428">"Ainult WiFi puhul"</item>
    <item msgid="7647277566998527142">"Alati"</item>
  </string-array>
    <string name="pref_link_prefetch_summary" msgid="6558181497993206817">"Lubage brauseril lingitud veebilehti taustal eellaadida"</string>
    <string name="pref_link_prefetch_dialogtitle" msgid="3804646141622839765">"Veebilehe eellaadimine"</string>
    <string name="browserFrameNetworkErrorLabel" msgid="8102515020625680714">"Ühenduse probleem"</string>
    <string name="browserFrameFileErrorLabel" msgid="4703792279852977350">"Faili probleem"</string>
    <string name="browserFrameFormResubmitLabel" msgid="2385512101948178841"></string>
    <string name="browserFrameFormResubmitMessage" msgid="5244059279866705254">"Leht, mida soovite vaadata, sisaldab juba saadetud andmeid („POSTDATA”). Kui saadate andmed uuesti, korratakse kõiki lehe vormil olevaid toiminguid (nt otsing või võrguost)."</string>
    <string name="loadSuspendedTitle" msgid="6453376579109644551">"Ühendus puudub"</string>
    <string name="loadSuspended" msgid="3843343290039218668">"Brauser ei saa seda lehte laadida, kuna puudub Interneti-ühendus."</string>
    <string name="clear_history" msgid="5998307092715979619">"Kustuta ajalugu"</string>
    <string name="browser_history" msgid="2979476257919939232">"Hiljuti külastatud lehed"</string>
    <string name="empty_history" msgid="7013369425484218985">"Brauseri ajalugu puudub."</string>
    <string name="go_home" msgid="109129207276086793">"Avaleht"</string>
    <string name="add_new_bookmark" msgid="3158497555612337238">"Lisa järjehoidja"</string>
    <string name="add_bookmark_short" msgid="3783984330998103735">"Lisa"</string>
    <string name="search_hint" msgid="4647356319916631820">"Otsige või sisestage URL"</string>
    <string name="search_button_text" msgid="5235226933877634410">"Mine"</string>
    <string name="search_settings_description" msgid="1422401062529014107">"Järjehoidjad ja veebiajalugu"</string>
    <string name="popup_window_attempt" msgid="31565781154067629">"Kas lubada saidil avada hüpikaken?"</string>
    <string name="allow" msgid="1157313689171991335">"Luba"</string>
    <string name="block" msgid="9172175889884707800">"Blokeeri"</string>
    <string name="too_many_windows_dialog_title" msgid="5709782301477380438">"Vahelehtede piir on saavutatud"</string>
    <string name="too_many_windows_dialog_message" msgid="3644234634638290304">"Uut vahekaarti ei saa avada seni, kuni te ühe sulgete."</string>
    <string name="too_many_subwindows_dialog_title" msgid="3805453941587725944">"Hüpik on juba avatud"</string>
    <string name="too_many_subwindows_dialog_message" msgid="2164725447981195556">"Korraga saab avada ainult ühe hüpiku."</string>
    <string name="download_no_sdcard_dlg_title" product="nosdcard" msgid="56777245081568508">"USB-seade pole saadaval"</string>
    <string name="download_no_sdcard_dlg_title" product="default" msgid="605904452159416792">"SD-kaart puudub"</string>
    <string name="download_no_sdcard_dlg_msg" product="nosdcard" msgid="3144652102051031721">"Faili <xliff:g id="FILENAME">%s</xliff:g> allalaadimiseks on vajalik USB-mäluseade."</string>
    <string name="download_no_sdcard_dlg_msg" product="default" msgid="2616399456116301518">"Faili <xliff:g id="FILENAME">%s</xliff:g> allalaadimiseks on vajalik SD-kaart."</string>
    <string name="download_sdcard_busy_dlg_title" product="nosdcard" msgid="8081445664689818973">"USB-seade pole saadaval"</string>
    <string name="download_sdcard_busy_dlg_title" product="default" msgid="6877712666046917741">"SD-kaart pole saadaval"</string>
    <string name="download_sdcard_busy_dlg_msg" product="nosdcard" msgid="8412543086906716875">"USB-mäluseade on hõivatud. Allalaadimiste lubamiseks puudutage teatises käsku „Lülita USB-mäluseade välja”."</string>
    <string name="download_sdcard_busy_dlg_msg" product="default" msgid="2629425950473358591">"SD-kaart on hõivatud. Allalaadimiste lubamiseks valige teatises käsk „Lülita USB-mäluseade välja”."</string>
    <string name="cannot_download" msgid="8150552478556798780">"Alla laadida saab ainult protokolli „http” või „https” sisaldavaid URL-e."</string>
    <string name="download_pending" msgid="2599683668575349559">"Allalaadimise alustamine ..."</string>
    <string name="search_the_web" msgid="6046130189241962337">"Otsige veebist"</string>
    <string name="webstorage_outofspace_notification_title" msgid="1160474608059771788">"Brauseri maht täis"</string>
    <string name="webstorage_outofspace_notification_text" msgid="47273584426988640">"Puudutage vaba ruumi loomiseks."</string>
    <string name="webstorage_clear_data_title" msgid="689484577124333977">"Kustuta talletatud andmed"</string>
    <string name="webstorage_clear_data_dialog_message" msgid="6200681632891775881">"Kas kustutada kõik selle veebisaidi salvestatud andmed?"</string>
    <string name="webstorage_clear_data_dialog_ok_button" msgid="6682570951259237542">"OK"</string>
    <string name="webstorage_clear_data_dialog_cancel_button" msgid="2028867751958942762">"Tühista"</string>
    <string name="webstorage_origin_summary_mb_stored" msgid="1985885826292236210">"MB talletatud teie telefoni"</string>
    <string name="loading_video" msgid="7886324933131962321">"Video laadimine ..."</string>
    <string name="geolocation_permissions_prompt_message" msgid="356796102004052471">"<xliff:g id="WEBSITE_ORIGIN">%s</xliff:g> tahab teada teie asukohta"</string>
    <string name="geolocation_permissions_prompt_share" msgid="9084486342048347976">"Asukoha jagamine"</string>
    <string name="geolocation_permissions_prompt_dont_share" msgid="6303025160237860300">"Keeldu"</string>
    <string name="geolocation_permissions_prompt_remember" msgid="3118526300707348308">"Pea eelistus meeles"</string>
    <string name="geolocation_permissions_prompt_toast_allowed" msgid="7201417941112726112">"Sellel saidil puudub juurdepääs teie asukohale. Seda saate muuta järgmiste valikute abil: Seaded &amp;gt Täpsem &amp;gt Veebisaidi kuva."</string>
    <string name="geolocation_permissions_prompt_toast_disallowed" msgid="156443445797377409">"Sellel saidil puudub juurdepääs teie asukohale. Seda saate muuta järgmiste valikute abil: Seaded -&gt; Täpsem -&gt; Veebisaidi kuva."</string>
    <string name="geolocation_settings_page_title" msgid="1745477985097536528">"Kustuta asukoha juurdepääs"</string>
    <string name="geolocation_settings_page_summary_allowed" msgid="9180251524290811398">"Sellel saidil on praegu juurdepääs teie asukohale"</string>
    <string name="geolocation_settings_page_summary_not_allowed" msgid="7941769772784366199">"Sellel saidil puudub praegu juurdepääs teie asukohale"</string>
    <string name="geolocation_settings_page_dialog_message" msgid="8772923416296868537">"Kustuta selle veebisaidi asukoha juurdepääs"</string>
    <string name="geolocation_settings_page_dialog_ok_button" msgid="2113465477131017852">"OK"</string>
    <string name="geolocation_settings_page_dialog_cancel_button" msgid="7941036504673409747">"Tühista"</string>
    <string name="website_settings_clear_all" msgid="8739804325997655980">"Kustuta kõik"</string>
    <string name="website_settings_clear_all_dialog_message" msgid="1551164275687475061">"Kas kustutada kõik veebilehe andmed ja asukoha õigused?"</string>
    <string name="website_settings_clear_all_dialog_ok_button" msgid="7858504776529106243">"OK"</string>
    <string name="website_settings_clear_all_dialog_cancel_button" msgid="1896757051856611674">"Tühista"</string>
    <string name="progress_dialog_setting_wallpaper" msgid="2031391201442335889">"Taustapildi seadmine ..."</string>
    <string name="defaultBookmarksUpButton" msgid="2303951020715704735">"Järjehoidjad"</string>
    <string name="empty_bookmarks_folder" msgid="6239830231917618556">"Järjehoidjaid pole"</string>
    <string name="other_bookmarks" msgid="8021889794475657319">"Muud järjehoidjad"</string>
    <string name="rlz_access_point" msgid="7165847807377650632">"Y1"</string>
    <string name="account_chooser_dialog_title" msgid="3314204833188808194">"Konto valimine"</string>
    <string name="import_bookmarks_dialog_title" msgid="3325557652271172128">"Sünkroonige Google\'i kontoga"</string>
    <string name="import_bookmarks_dialog_description" msgid="2362897194870789609">"Selle seadme järjehoidjad ei ole veel ühegi Google\'i kontoga seotud. Salvestage järjehoidjad, lisades need kontole. Kui te ei soovi järjehoidjaid sünkroonida, kustutage need."</string>
    <string name="import_bookmarks_dialog_select_add_account" msgid="7643058662272484895">"Lisage praegu seadmes olevad järjehoidjad ja alustage sünkroonimist Google\'i kontoga"</string>
    <string name="import_bookmarks_dialog_delete_select_account" msgid="4333848003180415516">"Kas kustutada praegu seadmes olevad järjehoidjad ja alustada järjehoidjate sünkroonimist Google\'i kontoga?"</string>
    <string name="import_bookmarks_dialog_confirm_delete" msgid="2204771572755630570">"Kas kustutada praegu seadmes olevad järjehoidjad ja alustada järjehoidjate sünkroonimist kontoga <xliff:g id="GOOGLE_ACCOUNT">%s</xliff:g>?"</string>
    <string name="import_bookmarks_dialog_confirm_add" msgid="8942794112340838111">"Kas lisada praegu seadmes olevad järjehoidjad ja alustada järjehoidjate sünkroonimist kontoga <xliff:g id="GOOGLE_ACCOUNT">%s</xliff:g>?"</string>
    <string name="import_bookmarks_dialog_remove" msgid="5984607822851800902">"Kustuta järjehoidjad"</string>
    <string name="import_bookmarks_wizard_next" msgid="7578143961884352676">"Järgmine"</string>
    <string name="import_bookmarks_wizard_previous" msgid="8551440353688257031">"Eelmine"</string>
    <string name="import_bookmarks_wizard_cancel" msgid="4936061122806506634">"Tühista"</string>
    <string name="import_bookmarks_wizard_done" msgid="1446247092194489191">"Valmis"</string>
    <string name="import_bookmarks_dialog_add" msgid="1743359725294101189">"Lisa järjehoidjad Google\'i kontole"</string>
    <string name="import_bookmarks_dialog_import" msgid="6933613853573899218">"Lisage Androidi järjehoidjad konto <xliff:g id="GOOGLE_ACCOUNT">%s</xliff:g> järjehoidjatesse"</string>
    <string name="menu_share_url" msgid="5851814357333739700">"Jagamine"</string>
    <string name="max_tabs_warning" msgid="4122034303809457570">"Rohkem vahelehti pole saadaval"</string>
    <string name="instant_search_label" msgid="8769284297650716935">"Google koos Instantiga (Labs)"</string>
    <string name="preview" msgid="6450823514561689038">"Eelvaade"</string>
    <string name="local_bookmarks" msgid="533816851415228520">"Kohalikud"</string>
    <string name="ua_switcher_desktop" msgid="220097077327558435">"Taotle saidi arvutiversiooni"</string>
    <string name="permission_preload_label" msgid="4856971662337877316">"Tulemuste eellaadimine"</string>
    <string name="empty_snapshots_folder" msgid="7675378008107026013">"Salvestatud lehti ei ole."</string>
    <string name="remove_snapshot" msgid="1624447424544976849">"Kustuta salvestatud leht"</string>
    <string name="snapshot_go_live" msgid="1209542802541168497">"Ava originaal"</string>
    <string name="accessibility_button_back" msgid="6194680634245279407">"Mine tagasi"</string>
    <string name="accessibility_button_forward" msgid="1236827218480658168">"Mine edasi"</string>
    <string name="accessibility_button_refresh" msgid="1023441396241841313">"Värskenda lehte"</string>
    <string name="accessibility_button_stop" msgid="6793644120043222148">"Peata lehe laadimine"</string>
    <string name="accessibility_button_addbookmark" msgid="4787844912630006181">"Lisa leht järjehoidjatesse"</string>
    <string name="accessibility_button_search" msgid="5357014102136055376">"Otsing"</string>
    <string name="accessibility_button_voice" msgid="152016375096083337">"Alusta häälotsingut"</string>
    <string name="accessibility_button_bookmarks" msgid="7435055677299151649">"Järjehoidjad"</string>
    <string name="accessibility_button_closetab" msgid="6954807842756927737">"Sule vaheleht"</string>
    <string name="accessibility_button_newtab" msgid="4116986240706315748">"Ava uus vaheleht"</string>
    <string name="accessibility_button_newincognitotab" msgid="5254901889040012964">"Ava uus incognito vaheleht"</string>
    <string name="accessibility_button_clear" msgid="6943152307986161598">"Tühista sisestus"</string>
    <string name="accessibility_button_uaswitch" msgid="6286804719724282339">"Vaheta kasutajaagenti"</string>
    <string name="accessibility_button_go" msgid="1182818872083055958">"Mine"</string>
    <string name="accessibility_button_navscreen" msgid="9142904748728713075">"Lehe haldur"</string>
    <string name="accessibility_button_more" msgid="3054251446394224216">"Rohkem valikuid"</string>
    <string name="accessibility_state_incognito" msgid="5786038488425202355">"Incognito leht"</string>
    <string name="accessibility_state_frozen" msgid="8041539250447035570">"Salvestatud leht"</string>
    <string name="accessibility_transition_navscreen" msgid="2734915619351519547">"Vahelehtede haldamine"</string>
    <string name="accessibility_button_bookmarks_folder_up" msgid="9179389954714270505">"Eelmine kaust"</string>
</resources>
