<?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="yes" msgid="4676390750360727396">"Jah"</string>
    <string name="no" msgid="6731231425810196216">"Ei"</string>
    <string name="create" msgid="3578857613172647409">"Loo"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Tundmatu"</string>
    <string name="show_dev_countdown" msgid="5521163114237004821">"<xliff:g id="STEP_COUNT">%1$d</xliff:g> sammu veel ja olete arendaja."</string>
    <string name="show_dev_on" msgid="1110711554982716293">"Olete nüüd arendaja!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Ei ole vaja, olete juba arendaja."</string>
    <string name="header_category_wireless_networks" msgid="4944823405420438623">"TRAADITA ÜHENDUS JA VÕRGUD"</string>
    <string name="header_category_device" msgid="5781174212691167553">"SEADE"</string>
    <string name="header_category_personal" msgid="6225932173498802187">"ISIKLIK"</string>
    <string name="header_category_system" msgid="2073558547468647128">"SÜSTEEM"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Lülita raadio sisse"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Lülita raadio välja"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Lülitage sisse SMS üle IMS-i"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Lülitage SMS üle IMS-i välja"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Lülitage vajalik IMS-i registreerimine sisse"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Lülitage vajalik IMS-i registreerimine välja"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Lülita LTE mälutõmmis sisse"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Lülita LTE mälutõmmis välja"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Kuva SIM-i aadressiraamat"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Kuva määratud valimisnumbrid"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Kuva teenuse valimise numbrid"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Hangi pakettandmeprotokollide loend"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"Teenus toimib"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Ei toimi"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Ainult hädaabikõned"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Raadio väljas"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Rändlus"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Rändlus puudub"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Tegevusetu"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Helisemine"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Kõne on pooleli"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Ühendus katkestatud"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Ühendamine"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Ühendatud"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Peatatud"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"tundmatu"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pkts"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"baiti"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Lahuta USB-mäluseade"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"SD-kaardi lahutamine"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Kustuta USB-mäluseade"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Kustuta SD-kaart"</string>
    <string name="small_font" msgid="2295331917424072635">"Väike"</string>
    <string name="medium_font" msgid="2068475425515133701">"Keskmine"</string>
    <string name="large_font" msgid="599055175160971446">"Suur"</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"USB-mäluseade"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"SD-kaart"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Aku olek:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Toitepistik:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Aku skaala:"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Aku tase:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Aku seisukord:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Akutehnoloogia:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Akupinge:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Aku temperatuur:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"?? C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Aeg alates algkäivitusest:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Sisselülitusaeg akutoitel:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Laadimisaegne sisselülitusaeg:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Ekraani sisselülitusaeg:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Tundmatu"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Laadimine"</string>
    <string name="battery_info_status_charging_ac" msgid="5874340256342956252">"(VV)"</string>
    <string name="battery_info_status_charging_usb" msgid="4059070156126770959">"(USB)"</string>
    <string name="battery_info_status_charging_wireless" msgid="1822125795446772771">"(traadita võrk)"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Ei lae"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Ei lae"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Täis"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Ühenduseta"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"AC"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"traadita võrk"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"AC + USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Tundmatu"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Tundmatu"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Hea"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Ülekuumenemine"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Surnud"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Ülepinge"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Tundmatu viga"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Külm"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_visibility" msgid="2930835434091839916">"Leitav"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Ei ole nähtav teistele Bluetooth-seadmetele"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Nähtav ainult seotud seadmetele"</string>
    <string name="bluetooth_not_discoverable" msgid="128269993123955177">"Muuda seade leitavaks"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Nähtavuse ajalõpp"</string>
    <string name="bluetooth_visibility_timeout_summary" msgid="6483353842671501585">"Määrake seadme leitavuse aeg"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Lukusta häälvalimine"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Vältige Bluetoothi valija kasutamist, kui ekraan on lukustatud"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Bluetooth-seadmed"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Seadme nimi"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Seadme seaded"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Profiili seaded"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nimi on määramata, konto nime kasutamine"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Otsi seadmeid"</string>
    <string name="bluetooth_rename_device" product="tablet" msgid="787970073150631155">"Nimeta tahvelarvuti ümber"</string>
    <string name="bluetooth_rename_device" product="default" msgid="6267987985556136749">"Nimeta telefon ümber"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Nimeta ümber"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Kas katkestada ühendus?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"See lõpetab teie ühenduse seadmega:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Kas profiil keelata?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"See keelab:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;seadmest:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_connected" msgid="6038755206916626419">"Ühendatud"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Ühendatud (telefoni pole)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Ühendatud (meediat pole)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Ühendatud (pole telefoni ega meediat)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Ühendus katkestatud"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Ühenduse katkestamine ..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Ühendamine ..."</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Sidumine ..."</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Nimetu Bluetooth-seade"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Otsimine"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Läheduses ei leitud Bluetooth-seadmeid."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Bluetoothi sidumisettepanek"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Sidumistaotlus"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Puudutage seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühildamiseks."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Näita vastuvõetud faile"</string>
    <string name="device_picker" msgid="8398232791303186677">"Bluetooth-seadme valija"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetoothi loa taotlus"</string>
    <string name="bluetooth_ask_enablement" msgid="5279027758886569301">"Rakendus soovib Bluetoothi sisse lülitada. Kas lubada?"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4420151924834278808">"Tahvelarvutis olev rakendus soovib tahvelarvuti muuta teistele Bluetooth-seadmetele <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="4478906085771274647">"Telefonis olev rakendus soovib telefoni muuta teistele Bluetooth-seadmetele <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8737516188038252313">"Tahvelarvutis olev rakendus soovib tahvelarvuti muuta teistele Bluetooth-seadmetele alati nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="7751530664834149084">"Telefonis olev rakendus soovib telefoni muuta teistele Bluetooth-seadmetele alati nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="8504403125440086020">"Tahvelarvutis olev rakendus soovib Bluetoothi sisse lülitada ja muuta tahvelarvuti teistele seadmetele <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="3040361003987241057">"Teie telefonis olev rakendus soovib Bluetoothi sisse lülitada ja muuta telefoni teistele seadmetele <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="7254712987802497615">"Tahvelarvutis olev rakendus soovib Bluetoothi sisse lülitada ja muuta tahvelarvuti teistele seadmetele nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="3947789545028519103">"Teie telefonis olev rakendus soovib Bluetoothi sisse lülitada ja muuta telefoni teistele seadmetele nähtavaks. Kas lubada?"</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Bluetoothi sisselülitamine ..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Bluetoothi väljalülitamine ..."</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Automaatne ühendamine"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Bluetooth-ühenduse taotlus"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Puudutage seadmega „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>” ühendamiseks."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Kas soovite ühendada seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_phonebook_request" msgid="457033227379858269">"Telefoniraamatu taotlus"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s soovib juurdepääsu teie kontaktisikutele ja kõneajaloole. Kas lubate juurdepääsu kasutajale %2$s?"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Ära enam küsi"</string>
    <string name="date_and_time" msgid="4114084177056654663">"Kuupäeva ja kellaaja seaded"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Ajavööndi valimine"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Piirkondlik (<xliff:g id="DATE">%s</xliff:g>)"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Eelvaade:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Kirja suurus:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Saada <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Käivita <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Konto:"</string>
    <string name="proxy_settings_title" msgid="5912878565897294401">"Puhverserveri seaded"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Kustuta"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Puhverserveri port"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Puhverserverist mööduvad"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com, mycomp.test.com, localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Taasta vaikeväärtused"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Valmis"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Puhverserveri hosti nimi"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Tähelepanu"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Sisestatud hosti nimi on kehtetu."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Sisestatud välistusloend ei ole õigesti vormindatud. Sisestage välistatud domeenide komadega eraldatud loend."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Peate täitma pordi välja."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Pordi väli peab olema tühi, kui hosti väli on tühi."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Sisestatud port on kehtetu."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Brauser kasutab HTTP-puhverserverit, kuid muud rakendused ei tohi seda kasutada."</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Asukoht:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"Külgnev CID:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"Kärjeinfo:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Andmete katsed:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"GPRS-teenus:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Rändlus:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Kõne ümbersuunamine:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"PPP lähtestuste arv alates algkäivitusest:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"GSM katkestab:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Praegune võrk:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Andmeõnnestumised:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"PPP vastu võetud:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"GSM-teenus:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Signaali tugevus:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Kõne olek:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"PPP saadetud:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Raadiolähtestused:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Ootel sõnum:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Telefoninumber:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Vali raadioriba"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Võrgu tüüp:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Määra eelistatud võrgu tüüp:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Pingi IpAddr:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Pingi hostinime (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"HTTP-kliendi test:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Käivita pingimistest"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Värskenda"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Värskenda"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Lülita DNS-i kontroll sisse või välja"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"OEM-i teave/seaded"</string>
    <string name="band_mode_title" msgid="954174198903776205">"GSM-/UMTS-riba määramine"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Ribaloendi laadimine ..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Määra"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Ebaõnnestus"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Õnnestunud"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Muudatused jõustuvad siis, kui USB-kaabel on uuesti ühendatud."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"USB massmälu lubamine"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Baite kokku:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"USB-mäluseade on paigaldamata."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Puudub SD-kaart."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Saadaolevad baidid:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB on kasutusel massmäluna."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"SD-kaart on kasutusel massmäluseadmena."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"USB eemaldamine on nüüd ohutu."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"SD-kaardi eemaldamine on nüüd ohutu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB eemaldati kasutamise ajal"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"SD-kaart eemaldati kasutamise ajal."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Kasutatud baite:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"USB-st meediumi skaneering ..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"SD-kaardi skannimine meediumi jaoks ..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"USB-mälu on kirjutuskaitsega."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"SD-kaart on paigaldatud kirjutuskaitstuna."</string>
    <string name="skip_label" msgid="47510779345218297">"Edasi"</string>
    <string name="next_label" msgid="4693520878012668114">"Järgmine"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Keel"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Tegevuse valimine"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Seadme teave"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Aku teave"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekraan"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Teave tahvelarvuti kohta"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Telefoniteave"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"USB-mäluseade"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"SD-kaart"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Puhverserveri seaded"</string>
    <string name="cancel" msgid="6859253417269739139">"Tühista"</string>
    <string name="settings_label" msgid="1626402585530130914">"Seaded"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Seaded"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Seadete otsetee"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Lennurežiim"</string>
    <string name="radio_controls_title" msgid="6889937359495515769">"Rohkem ..."</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Traadita ühendus ja võrgud"</string>
    <string name="radio_controls_summary" msgid="2998818677094465517">"WiFi-, Bluetooth-, lennurežiimis ja mobiilsidevõrkude ning VPN-ide haldamine"</string>
    <string name="roaming" msgid="3596055926335478572">"Andmerändlus"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Kaotasite andmesideühenduse, kuna jätsite oma koduvõrgu andmerändluse väljalülitatuks."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Lülita sisse"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Kui lubate andmeside rändluse, siis võidakse teilt küsida suuri rändlustasusid."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Kui lubate andmeside rändluse, siis võivad sellega kaasneda rändlustasud!"\n\n"Seade mõjutab tahvelarvuti kõiki kasutajaid."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Kui lubate andmeside rändluse, siis võivad sellega kaasneda rändlustasud!"\n\n"Seade mõjutab telefoni kõiki kasutajaid."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Kas lubada andmeside rändlus?"</string>
    <string name="networks" msgid="6333316876545927039">"Operaatori valik"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Võrguoperaatori valimine"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Kuupäev ja kellaaeg"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Kuupäeva ja kellaaja määramine"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Määra kuupäev, kellaaeg, ajavöönd ja vormingud"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Autom. kuup. ja kellaaeg"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Võrgu pakutud kellaaja kasutamine"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Kasuta võrgu pakutud kellaaega"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automaatne ajavöönd"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Kasuta võrgu pakutud ajavööndit"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Kasuta võrgu pakutud ajavööndit"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"24-tunnise vormingu kasutamine"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Kellaaja määramine"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Valige ajavöönd"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Kuupäeva määramine"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Valige kuupäevavorming"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Sordi tähestiku järgi"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Sordi ajavööndi alusel"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Kuupäev"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Kellaaeg"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Paranda näosobitust"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Elavuse kontroll"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Avamiseks on nõutav silma pilgutamine"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Lukusta automaatselt"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast unerežiimi"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Kuva lukustusekraanil teave omaniku kohta"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Teave omaniku kohta"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Sisestage lukustusekraanil kuvatav tekst"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Kuva lukustusekraanil teave kasutaja kohta"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Kasutajateave"</string>
    <string name="location_settings_title" msgid="4483843407328665068">"Juurdepääs asukohale"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Turvalisus"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Määrake Minu asukoht, ekraani avamine, SIM-kaardi lukk, mandaadi talletuslukk"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Määrake oma asukoht, ekraani avamine, mandaadi talletuslukk"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Paroolid"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Tahvelarvuti krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Telefoni krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_summary" product="tablet" msgid="6291564408810586">"Igal telefoni sisselülitamisel on vaja numbrilist PIN-koodi või parooli tahvelarvuti dekrüpteerimiseks"</string>
    <string name="crypt_keeper_encrypt_summary" product="default" msgid="514138079795442371">"Igal telefoni sisselülitamisel on vaja numbrilist PIN-koodi või parooli telefoni dekrüpteerimiseks"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Krüpteeritud"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="3839235202103924154">"Saate krüpteerida oma kontosid, seadeid, allalaaditud rakendusi ja nende andmeid ning meediumi- ja muid faile. Kui tahvelarvuti on krüpteeritud, peate iga kord seadet sisse lülitades selle dekrüpteerimiseks sisestama numbrilise PIN-koodi või parooli. Tahvelarvuti krüpteeringut ei saa tühistada, välja arvatud tehaseandmete lähtestamisega, millega kustutatakse kõik teie andmed."\n\n"Krüpteerimine võtab aega tunni või rohkem. Aku peab olema täis ja tahvelarvuti sisse lülitatud, kuni krüpteerimine on lõpule viidud. Kui katkestate krüpteerimistoimingu, kaotate osa või kõik oma andmed."</string>
    <string name="crypt_keeper_desc" product="default" msgid="7663118199519229502">"Saate krüpteerida oma kontosid, seadeid, allalaaditud rakendusi ja nende andmeid ning meediumi- ja muid faile. Kui telefon on krüpteeritud, peate iga kord seda sisse lülitades sisestama dekrüpteerimiseks numbrilise PIN-koodi või parooli. Telefoni krüpteeringut ei saa tühistada, välja arvatud tehaseandmete lähtestamisega, millega kustutatakse kõik teie andmed."\n\n"Krüpteerimine võtab aega tunni või rohkem. Aku peab olema täis ja telefon sisse lülitatud, kuni krüpteerimine on lõpule viidud. Kui katkestate krüpteerimistoimingu, kaotate osa andmeid või kõik andmed."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Krüpteeri tahvelarvuti"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Krüpteeri telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Laadige akut ja proovige uuesti."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Ühendage laadija ja proovige uuesti."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Ekraaniluku PIN-koodi või parooli ei ole"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Enne krüpteerimist peate määrama lukustusekraani PIN-koodi või parooli."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Kas krüpteerida?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Krüpteerimistoiming on pöördumatu ja katkestamisel kaotate andmed. Krüpteerimiseks kulub tund või rohkem, mille jooksul tahvelarvuti taaskäivitub mitu korda."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Krüpteerimistoiming on pöördumatu ja selle katkestamisel kaotate andmed. Krüpteerimiseks kulub tund või rohkem, selle aja jooksul taaskäivitub telefon mitu korda."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Krüpteerimine"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Oodake, kuni teie tahvelarvutit krüpteeritakse. <xliff:g id="PERCENT">^1</xliff:g>% valmis."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Oodake, kuni teie telefon krüpteeritakse. <xliff:g id="PERCENT">^1</xliff:g>% valmis."</string>
    <string name="crypt_keeper_cooldown" msgid="685210918307862395">"Proovige uuesti <xliff:g id="DELAY">^1</xliff:g> sekundi pärast."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Sisestage parool"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Krüptimine ebaõnnestus"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Krüpteerimine katkestati ja seda ei saa lõpule viia. Seetõttu ei pääse te enam oma tahvelarvutis olevatele andmetele juurde. "\n\n" Tahvelarvuti kasutamise jätkamiseks peate lähtestama selle tehaseseadetele. Kui seadistate tahvelarvutit pärast lähtestamist, saate taastada kõik andmed, mis olid varundatud teie Google\'i kontole."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Krüpteerimine katkestati ja seda ei saa lõpule viia. Seetõttu ei pääse te enam oma telefonis olevatele andmetele juurde. "\n\n"Telefoni kasutamise jätkamiseks peate selle lähtestama tehaseseadetele. Kui seadistate telefoni pärast lähtestamist, saate taastada kõik andmed, mis olid varundatud teie Google\'i kontole."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Sisestusmeetodi vahetamine"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Ekraaniluku valimine"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Valige varukoopia lukk"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Ekraanilukk"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Ekraaniluku muutmine"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Muuda või keela mustri, PIN-koodi või parooli turve"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Valige ekraani lukustamise meetod"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Kui Face Unlock teid ei näe, siis kuidas soovite avada?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Puudub"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="2871898266296656162">"Lohistamine"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Turvamata"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Face Unlock"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Madal turvalisus, katseline"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Muster"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Keskmine turvalisus"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN-kood"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Keskmine kuni kõrge turvalisus"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Parool"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Kõrge turvalisus"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Keelanud admin., krüptimiseeskiri või mand. mälu"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Puudub"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5660014471997663139">"Lohistamine"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Face Unlock"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Muster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN-kood"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Parool"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Lülita ekraanilukk välja"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Eemalda avamismuster"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Eemalda avamise PIN-kood"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Eemalda avamise parool"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Avamismustri muutmine"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Muuda avamise PIN-koodi"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Avamisparooli muutmine"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Parool peab olema vähemalt %d tähemärgi pikkune"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"PIN-koodi pikkus peab olema vähemalt %d numbrit"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Puudutage käsku Jätka, kui olete lõpetanud"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Jätka"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Parool peab olema lühem kui <xliff:g id="NUMBER">%d</xliff:g> märki."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"PIN-kood peab olema lühem kui <xliff:g id="NUMBER">%d</xliff:g> numbrit."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"PIN-kood tohib sisaldada ainult numbreid 0–9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Seadme administraator ei luba kasutada viimast PIN-koodi."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Parool sisaldab lubamatut tähemärki."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Parool peab sisaldama vähemalt üht tähte."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Parool peab sisaldama vähemalt üht numbrit."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Parool peab sisaldama vähemalt üht sümbolit."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Parool peab sisaldama vähemalt üht tähte."</item>
    <item quantity="other" msgid="8186027808415585970">"Parool peab sisaldama vähemalt %d tähte."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Parool peab sisaldama vähemalt üht väiketähte."</item>
    <item quantity="other" msgid="2693910942679679225">"Parool peab sisaldama vähemalt %d väiketähte."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Parool peab sisaldama vähemalt üht suurtähte."</item>
    <item quantity="other" msgid="3030801209112209245">"Parool peab sisaldama vähemalt %d suurtähte."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Parool peab sisaldama vähemalt üht numbrit."</item>
    <item quantity="other" msgid="4703982391407595924">"Parool peab sisaldama vähemalt %d numbrit."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Parool peab sisaldama vähemalt üht erisümbolit."</item>
    <item quantity="other" msgid="1221290525051187757">"Parool peab sisaldama vähemalt %d erisümbolit."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Parool peab sisaldama vähemalt üht mittetähelist märki."</item>
    <item quantity="other" msgid="3952508584649046404">"Parool peab sisaldama vähemalt %d mittetähelist märki."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Seadme administraator ei luba viimast parooli kasutada."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Tühista"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Tühista"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Järgmine"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Seadistamine on lõpetatud."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Seadme haldamine"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Seadme ülemad"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Seadme ülemate kuvamine või desaktiveerimine"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Lülitage Bluetooth sisse"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Halda ühendusi, määra seadme nimi ja leitavus"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Bluetoothi sidumistaotlus"</string>
    <string name="bluetooth_enter_pin_msg" msgid="5698297871117529185">"Siduda seadmega:<xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Sisestage seadme nõutav PIN-kood:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="2220143735340367939">"Siduda seadmega:<xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Sisestage seadme nõutav parool:"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN-kood sisaldab tähti või sümboleid"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Tavaliselt 0000 või 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Võib-olla peate selle PIN-koodi sisestama ka teise seadmesse."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Võib-olla peate selle parooli sisestama ka teise seadmesse."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Sidumine seadmega&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Veenduge, et see kuvaks järgmist parooli:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Seadmelt: &lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt; Kas siduda seadmega?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Siduda seadmega:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Sisestage:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, seejärel vajutage naasmis- või sisestusklahvi."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Seo"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Tühista"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Ei saanud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> siduda."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Ei saanud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> siduda vale PIN-koodi või parooli tõttu."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ei saa sidet luua."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> hülgas sidumise."</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ei saanud ühendust."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Otsi seadmeid"</string>
    <string name="bluetooth_search_for_devices" msgid="5957007154213560390">"Otsi seadmeid"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Otsimine ..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Seadme seaded"</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Seotud seadmed"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Saadaval seadmed"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Ühenda"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Katkesta ühendus"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Seo ja ühenda"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Seo lahti"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Katkesta ühendus ja seo lahti"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Valikud ..."</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Täpsemad"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Täpsemad Bluetoothi seaded"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="4793562956642282639">"Seadmete kuvamiseks lülitage Bluetooth sisse."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Ühendamine ..."</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Meedia heli"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Telefoni heli"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Failiedastus"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Sisendseade"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Internetti juurdepääs"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Interneti-ühenduse jagamine"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus meediumiheliga katkestatakse."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus vabakäeseadme heliga katkestatakse."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus sisendseadmega katkestatakse."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Katkestatakse Interneti-ühendus seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> kaudu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> tahvelarvuti Interneti-ühenduse jagamine katkestatakse."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> telefoni Interneti-ühenduse jagamine katkestatakse."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Seotud Bluetooth-seade"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Ühenda"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Ühenda Bluetooth-seadmega"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="3764437426089639639">"Profiilid"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Nimeta ümber"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Luba sissetul. failiedastused"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Ühendatud meediumiheliga"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Ühendatud telefoniheliga"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Ühendatud failiedastuse serveriga"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Ei ole failiedastuse serveriga ühendatud"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Ühendatud sisendseade"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Ühendatud seadmega Internetti juurdepääsuks"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Kohaliku Interneti-ühenduse jagamine seadmega"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Kasuta meediumiheli jaoks"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Kasuta telefoniheli jaoks"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Kasutage failide edastamiseks"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Kasutage sisendi jaoks"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Interneti-juurdepääsuks kasutamine"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Doki seaded"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Kasutage heli jaoks dokki"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kõlartelefonina"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Muusika ja meediumi jaoks"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Jäta seaded meelde"</string>
    <string name="wifi_display_settings_title" msgid="564299108014609382">"Juhtmeta ekraaniühendus"</string>
    <string name="wifi_display_settings_empty_list_wifi_display_off" msgid="1225626898926363100">"Seadmete nägemiseks lülitage juhtmeta ekraaniühendus sisse."</string>
    <string name="wifi_display_settings_empty_list_wifi_display_disabled" msgid="7363832031876872257">"Juhtmeta ekraaniühendus on keelatud, sest WiFi-ühendus on välja lülitatud."</string>
    <string name="wifi_display_search_for_devices" msgid="5065526281193354502">"Ekraanide otsimine"</string>
    <string name="wifi_display_searching_for_devices" msgid="5172373825348672137">"Otsimine …"</string>
    <string name="wifi_display_no_devices_found" msgid="8180582698282377626">"Ei leitud WiFi-ekraane."</string>
    <string name="wifi_display_paired_devices" msgid="7395326840730024303">"Seotud ekraanid"</string>
    <string name="wifi_display_available_devices" msgid="4558314642853513487">"Saadaval seadmed"</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Ühendamine"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Ühendatud"</string>
    <string name="wifi_display_status_available" msgid="1924167525172207067">"Saadaval"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Kuvaseaded"</string>
    <string name="wifi_display_disconnect_title" msgid="1543715924639003599">"Kas katkestada ühendus?"</string>
    <string name="wifi_display_disconnect_text" msgid="4824860802264489088">"See lõpetab teie ühenduse seadmega:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Juhtmeta ekraaniühenduse valikud"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Unusta"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Valmis"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Nimi"</string>
    <string name="wifi_display_summary_on" msgid="3695429596604962531">"Sees"</string>
    <string name="wifi_display_summary_off" msgid="2445210133184740611">"Väljas"</string>
    <string name="wifi_display_summary_disabled" msgid="5318394806146587849">"Keelatud"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Lubab andmete vahetust, kui tahvelarvuti puudutab teist seadet"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Lubab andmete vahetust, kui telefon puudutab teist seadet"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Valmis edastama rakenduse sisu NFC kaudu"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Väljas"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Pole saadaval, kuna NFC on välja lülitatud"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Kui see funktsioon on sisse lülitatud, saate rakenduse sisu teise NFC-suutlikku seadmesse kiirega saata, hoides seadmeid üksteise lähedal. Nii saate edastada näiteks brauserilehti, YouTube\'i videoid, inimeste kontakte ja muud."\n\n"Lihtsalt hoidke seadmeid lähestikku (tavaliselt tagused koos) ja siis puudutage seadme ekraani. Rakendus otsustab, mida kiirega edastatakse."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Võrguteenuse avastus"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Luba muudes seadmetes olevatel rakendustel selle seadme rakendusi leida"</string>
    <string name="wifi_quick_toggle_title" msgid="874495178395350104">"WiFi"</string>
    <string name="wifi_quick_toggle_summary" msgid="1047950931623694366">"Lülitage WiFi sisse"</string>
    <string name="wifi_settings" msgid="1277428034634973011">"WiFi"</string>
    <string name="wifi_settings_category" msgid="2810363951104753710">"WiFi-seaded"</string>
    <string name="wifi_settings_title" msgid="4351120897298124250">"WiFi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Määra ja halda traadita pääsupunkte"</string>
    <string name="wifi_setup_wizard_title" msgid="70277346338812325">"WiFi valimine"</string>
    <string name="wifi_starting" msgid="6716593470710880000">"WiFi sisselülitamine ..."</string>
    <string name="wifi_stopping" msgid="244864762599017659">"WiFi väljalülitamine ..."</string>
    <string name="wifi_error" msgid="3207971103917128179">"Viga"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Lennurežiimis"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Võrke ei saa kontrollida"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Võrguteatis"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3038290727701553612">"Teata mulle, kui avatud võrk on saadaval"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Väldi halbu ühendusi"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2466956369738047669">"Ära kasuta WiFi-võrku, kui selle Interneti-ühendus on halb"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="9107237003911220057">"Sisselülitatud WiFi unerežiimis"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Seade muutmisel tekkis probleem"</string>
    <string name="wifi_suspend_optimizations" msgid="387215679583759376">"WiFi optimeerimine"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="7774946457510541054">"Minimeeri aku kasutamine, kui WiFi on sees"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Võrgu lisamine"</string>
    <string name="wifi_access_points" msgid="2664629396767022441">"WiFi-võrgud"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"WPS-nupp"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Rohkem valikuid"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"WPS-i PIN-koodi kirje"</string>
    <string name="wifi_menu_p2p" msgid="2575893749303670353">"Otsene WiFi"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skannimine"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Täpsemalt"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Loo võrguühendus"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Unusta võrk"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Võrgu muutmine"</string>
    <string name="wifi_empty_list_wifi_off" msgid="4722299515264875943">"Saadavate võrkude kuvamiseks lülitage WiFi sisse."</string>
    <string name="wifi_empty_list_wifi_on" msgid="3354911729026237372">"WiFi-võrkude otsimine ..."</string>
    <string name="wifi_other_network" msgid="1048006316504242214">"Muu võrk ..."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Rohkem"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automaatseadistus (WPS)"</string>
    <string name="wifi_required_info_text" msgid="9014073093293520112">"Seadistuse lõpule viimiseks vajab teie tahvelarvuti WiFi-ühendust. Pärast seadistust saate vahetada mobiilse andmeside ja WiFi vahel."</string>
    <string name="wifi_show_advanced" msgid="1793703023711426246">"Kuva täpsemad valikud"</string>
    <string name="wifi_wps_setup_title" msgid="6034518116333042484">"Kaitstud WiFi seadistamine"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"WPS-i käivitamine …"</string>
    <string name="wifi_wps_onstart_pbc" msgid="7204827509934892103">"Vajutage marsruuteril nuppu Kaitstud Wi-Fi seadistamine. Selle nimi võib olla ka „WPS” või see võib sisaldada sellist sümbolit:"</string>
    <string name="wifi_wps_onstart_pin" msgid="8067502591043979939">"Sisestage WiFi-ruuteril PIN-kood <xliff:g id="NUMBER">%1$s</xliff:g>. Seadistuse lõpuleviimiseks võib kuluda kuni kaks minutit."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"WPS õnnestus. Võrguga ühenduse loomine …"</string>
    <string name="wifi_wps_connected" msgid="5754399645462924103">"Ühendatud WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS on juba käimas ja selle lõpuleviimiseks võib kuluda kuni kaks minutit"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"WPS ebaõnnestus. Proovige mõne minuti pärast uuesti."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Ruuteri turvaseadet (WEP) ei toetata"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Ruuteri turvaseadet (TKIP) ei toetata"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Autentimine ebaõnnestus. Proovige uuesti."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Tuvastati teine WPS-i seanss. Proovige mõne minuti pärast uuesti."</string>
    <string name="wifi_ssid" msgid="641393708309146745">"Võrgu SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Turvalisus"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Signaali tugevus"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Olek"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Lingi kiirus"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP-aadress"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"EAP meetod"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"2. etapi autentimine"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"CA sertifikaat"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Kasutaja sertifikaat"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identiteet"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonüümne identiteet"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Parool"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Kuva parool"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP-seaded"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(muutmata)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(määramata)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Salvestatud"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Keelatud"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"Halba Interneti-ühendust välditi"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Autentimise probleem"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Pole vahemikus"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS on saadaval"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" WPS on saadaval"</string>
    <string name="wifi_secured_first_item" msgid="4072076186051083451">"Kaitstud turbega <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_secured_second_item" msgid="1326000076939056265">", kaitstud turbega <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Puudub"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Ühenda"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Võrguga ühenduse loomine ebaõnnestus"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Unusta"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Võrgu unustamine ebaõnnestus"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Salvesta"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Võrgu säilitamine ebaõnnestus"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Tühista"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Jäta siiski vahele"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Ära jäta vahele"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="3335132188969450252">"HOIATUS: operaatoril võib andmeedastusele kehtida lisahind."\n\n"Tahvelarvuti seadistamiseks võib olla vajalik suur võrguaktiivsus."</string>
    <string name="wifi_skipped_message" product="default" msgid="1192848364146401759">"HOIATUS: operaatoril võib andmeedastusele kehtida lisahind."\n\n"Telefoni seadistamiseks võib olla vajalik suur võrguaktiivsus."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="7682836089429990118">"HOIATUS: tahvelarvuti ei saa kontrollida, kas teie tarkvara on ajakohane."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="3324261421359832263">"HOIATUS: telefon ei saa kontrollida, kas teie tarkvara on ajakohane."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="6904081070290941807">"Tahvelarvutil ei õnnestunud luua ühendust selle WiFi-võrguga."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="3894921379368046855">"Telefonil ei õnnestunud luua ühendust selle WiFi-võrguga."</string>
    <string name="wifi_advanced_titlebar" msgid="1627063574532930090">"Täpsemad WiFi-seaded"</string>
    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"WiFi sagedusriba"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Tegevuse sagedusvahemiku määramine"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Sagedusriba määramisel tekkis probleem."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-aadress"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-aadress"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"IP-seaded"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Salvesta"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Tühista"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Sisestage kehtiv IP-aadress."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Sisestage kehtiv lüüsi aadress."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Sisestage kehtiv DNS-aadress."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Sisestage võrgu eesliide pikkusega 0 kuni 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Lüüs"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Võrgu prefiksi pikkus"</string>
    <string name="wifi_p2p_settings_title" msgid="400503541488064638">"WiFi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Seadme teave"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Pea see ühendus meeles"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Otsi seadmeid"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Otsing …"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Nimeta seade ümber"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Võrdõigusvõrgu seadmed"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Meeldejäetud rühmad"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Ühenduse loomine ebaõnnestus."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Seadme ümbernimetamine ebaõnnestus."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Kas katkestada ühendus?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Kui katkestate ühenduse, siis katkeb ühendus seadmega <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Kui katkestate ühenduse, siis lõpeb ühendus seadmega <xliff:g id="PEER_NAME">%1$s</xliff:g> ja veel <xliff:g id="PEER_COUNT">%2$s</xliff:g> seadmega."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Kas tühistada kutse?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Kas soovite tühistada kutse kasutajaga <xliff:g id="PEER_NAME">%1$s</xliff:g> ühenduse loomiseks?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Kas unustada see rühm?"</string>
    <string name="wifi_tether_checkbox_text" msgid="6961605862058056788">"Kantav WiFi-tööpunkt"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Leviala sisselülitamine ..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Leviala väljalülitamine ..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Kantav tööpunkt <xliff:g id="NETWORK_SSID">%1$s</xliff:g> on aktiivne"</string>
    <string name="wifi_tether_failed_subtext" msgid="2654888578056042315">"Kantava WiFi-tööpunkti viga"</string>
    <string name="wifi_tether_configure_ap_text" msgid="61237027772641155">"WiFi leviala seadistamine"</string>
    <string name="wifi_tether_configure_subtext" msgid="1927454307836232128">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g> kantav WiFi-tööpunkt"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Kuva"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Heli"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Telefoni helin"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Helitugevused"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Muusikaefektid"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Helina helitugevus"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibreeri hääletus režiimis"</string>
    <string name="notification_sound_title" msgid="312032901303146002">"Vaikimisi teade"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Vilkuv teatise tuli"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Helin"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Teatis"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Kasuta teatiste jaoks sissetuleva kõne helitugevust"</string>
    <string name="notification_sound_dialog_title" msgid="9052854168612951170">"Vali teatise helin"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Meedium"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Määra muusika ja videote helitugevus"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Äratus"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Ühendatud doki heliseaded"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Valimisklahvistiku puutetoonid"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Puuduta helisid"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Ekraaniluku heli"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Vibreeri puudutusel"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Mürasummutus"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muusika, video, mängud ja muu meedia"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Helin ja teated"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Teated"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmid"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Helinate ja teatiste summutamine"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Muusika ja muude meediumide summutamine"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Teatiste summutamine"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Äratuste summutamine"</string>
    <string name="vibrate_when_ringing_title" msgid="3885857358303178029">"Vibreerimine helina ajal"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dokk"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Doki seaded"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Heli"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Ühendatud töölaua doki seaded"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Ühendatud autodoki seaded"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tahvelarvuti on dokkimata"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon dokkimata"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Ühendatud doki seaded"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dokki ei leitud"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Enne doki heli seadistamist peate tahvelarvuti dokkima."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Enne doki heli seadistamist peate telefoni dokkima."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Dokki sisestamise heli"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Esita heli tahvelarvuti sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Esita heli telefoni sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Ära esita heli tahvelarvuti sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Ära esita heli telefoni sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="account_settings" msgid="6403589284618783461">"Kontod"</string>
    <string name="search_settings" msgid="1910951467596035063">"Otsing"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Otsinguseadete ja -ajaloo haldamine"</string>
    <string name="display_settings" msgid="7965901687241669598">"Kuva"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Pööra ekraani automaatselt"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Tahvelarvuti pööramisel automaatselt paigutuse ümberlülitamine"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Muuda telefoni pööramisel automaatselt orientatsiooni"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Tahvelarvuti pööramisel automaatselt paigutuse ümberlülitamine"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Muuda telefoni pööramisel automaatselt orientatsiooni"</string>
    <string name="brightness" msgid="2354961343555249270">"Eredus"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Reguleeri ekraani heledust"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Unerežiim"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Pärast <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> tegevusetust"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Taustapilt"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Taustapildi valimine:"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Unerežiim"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Kui on dokitud või puhkerežiimis ja laeb"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Kui on dokitud või laeb"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Laadimise ajal"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kui on dokitud"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Välja"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Kui soovite juhtida, mis juhtub telefoni dokkimisel ja/või puhkerežiimi lülitamisel, siis lülitage sisse unerežiim."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Millal lülitada sisse unerežiim?"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Alusta kohe"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Seaded"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automaatne eredus"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Fondi suurus"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Fondi suurus"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"SIM-kaardi luku seaded"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Seadista SIM-kaardi lukk"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"SIM-kaardi lukk"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"SIM-kaardi lukustamine"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Nõua tahvelarvuti kasutamiseks PIN-i"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Nõua telefoni kasutamiseks PIN-i"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Nõua tahvelarvuti kasutamiseks PIN-i"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Nõua telefoni kasutamiseks PIN-i"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Muuda SIM-i PIN-koodi"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"SIM-i PIN-kood"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"SIM-kaardi lukustamine"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Ava SIM-kaart"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Vana SIM-i PIN-kood"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Uus SIM-i PIN-kood"</string>
    <string name="sim_reenter_new" msgid="3178510434642201544">"Sisestage uus PIN uuesti:"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"SIM-i PIN-kood"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Vale PIN-kood"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"PIN-koodid ei kattu"</string>
    <string name="sim_change_failed" msgid="304964924772218382">"PIN-koodi ei saa muuta."\n"PIN-kood võib vale olla."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"SIM-i PIN-koodi muutmine õnnestus"</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"SIM-kaardi lukustusolekut ei saa muuta."\n"Võimalik, et PIN-kood on vale."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Tühista"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Tahvelarvuti olek"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Telefoni olek"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Süsteemivärskendused"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Androidi versioon"</string>
    <string name="model_number" msgid="3765737700545384794">"Mudeli number"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"Seadme ID"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Põhiribaversioon"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Tuuma versioon"</string>
    <string name="build_number" msgid="3075795840572241758">"Järgunumber"</string>
    <string name="selinux_status" msgid="6212165375172061672">"SELinuxi olek"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Pole saadaval"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Olek"</string>
    <string name="device_status" msgid="607405385799807324">"Olek"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Aku laetuse, võrgu ja muu teave"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefoninumber, signaal jne"</string>
    <string name="storage_settings" msgid="4211799979832404953">"Mäluruum"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Mäluruumi seaded"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"USB-mäluseadme lahutamine, saadaoleva mäluruumi kuvamine"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Eemalda SD-kaart, kuva saadaolev mäluruum"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Minu telefoninumber"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"PRL-versioon"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="3279383550222116235">"Mobiilsidevõrgu tüüp"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Mobiilsidevõrgu olek"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Teenuse olek"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Signaali tugevus"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Rändlus"</string>
    <string name="status_operator" msgid="2274875196954742087">"Võrk"</string>
    <string name="status_wifi_mac_address" msgid="33109409206264790">"WiFi MAC-aadress"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Bluetoothi aadress"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Seerianumber"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Pole saadaval"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Talitlusaeg"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Sisselülitusaeg"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Sisemälu"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"USB-mäluseade"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"SD-kaart"</string>
    <string name="memory_available" msgid="5052397223077021181">"Saadaval"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Saadaval (kirjutuskaitstud)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Kogu ruum"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Arvutamine ..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Rakendused (rakenduse andmed ja meediasisu)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Meedium"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Allalaadimised"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Pildid, videod"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Heli (muusika, helinad, Interneti-saated jne)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Muu"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Vahemälus olevad andmed"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Lahuta jagatud mälu"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Lahutage SD-kaart"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Sisemise USB lahutamine"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"SD-kaardi lahutamine ohutuks eemaldamiseks"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"USB sisest. paigaldam.-ks"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Sisestage SD-kaart ühendamiseks"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Paigalda USB-mäluseade"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"SD-kaardi ühendamine"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Kustuta USB-mäluseade"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Kustuta SD-kaart"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Sisemisest USB-mäluseadmest kõikide andmete, nagu muusika ja fotode, kustutamine"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Kustutab SD-kaardilt kõik andmed, nagu muusika ja fotod"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Kas soovite vahemälus olevad andmed tühjendada?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"See tühjendab kõikide rakenduste vahemälus olevad andmed."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"MTP või PTP funktsioon on aktiivne"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Kas lahutada USB-seade?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Kas lahutada SD-kaart?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"USB-mäluseadme lahutamisel peatuvad mõned kasutatavad rakendused ega pruugi olla saadaval enne, kui USB-mäluseadme uuesti paigaldate."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"SD-kaardi lahutamisel peatuvad mõned töös olevad rakendused ega pruugi olla saadaval enne, kui SD-kaardi uuesti paigaldate."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"USB-mäluseadet ei saanud lahutada. Proovige hiljem uuesti."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"SD-kaarti ei saanud lahutada. Proovige hiljem uuesti."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"USB-mäluseade lahutatakse."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"SD-kaart lahutatakse."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Eemaldamine"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Eemaldamine pooleli"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Talletusruum saab täis"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Mõned süsteemifunktsioonid, nt sünkroonimine, ei pruugi õigesti toimida. Proovige vabastada ruumi, kustutades üksusi, nt rakendusi või meediasisu, või eemaldades neid."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"USB-arvutiühendus"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"USB-arvutiühendus"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Ühenda kui"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Meediumiseade (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Võimaldab teisaldada meediafaile Windowsis või rakendusega Android File Transfer Macis (vt www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Kaamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Võimaldab edastada fotosid kaamera tarkvara abil ja edastada mis tahes faile arvutitest, mis ei toeta MTP-d."</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Installi faili teisaldamise tööriistad"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Teised kasutajad"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Aku olek"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Aku tase"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Pääsupunktinimed"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Pääsupunkti muutmine"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Määramata"</string>
    <string name="apn_name" msgid="4115580098369824123">"Nimi"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Pääsupunktnimi"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Puhverserver"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Kasutajanimi"</string>
    <string name="apn_password" msgid="5412301994998250968">"Parool"</string>
    <string name="apn_server" msgid="2436185314756372858">"Server"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"MMS-i puhverserver"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"MMS-port"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Autentimise tüüp"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Puudub"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP või CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Pääsupunktinime tüüp"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"APN-i protokoll"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"APN-i rändlusprotokoll"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Luba/keela APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN on lubatud"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN on keelatud"</string>
    <string name="bearer" msgid="594270280031923558">"Kandja"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Kustuta pääsupunktinimi"</string>
    <string name="menu_new" msgid="3014205883303921729">"Uus pääsupunktinimi"</string>
    <string name="menu_save" msgid="8109345640668285399">"Salvesta"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Loobu"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Nimeväli ei tohi tühi olla."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"APN ei saa olla tühi."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MCC-väli peab olema kolmekohaline."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"MNC-väli peab olema kahe- või kolmekohaline."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"APN-i vaikeseadete taastamine."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Lähtesta vaikeseadetele"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"APN-i vaikeseadete lähtestamine on lõpule viidud."</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Tehaseandmete lähtestamine"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Kustutab kõik tahvelarvutis olevad andmed"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Kustutab kõik andmed telefonis"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"See kustutab kõik andmed teie tahvelarvuti "<b>"sisemälust"</b>", sh:"\n\n<li>"teie Google\'i konto"</li>\n<li>"süsteemi ja rakenduste andmed ning seaded"</li>\n<li>"Allalaaditud rakendused"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"See kustutab kõik andmed telefoni "<b>"sisemälust"</b>", sh:"\n\n<li>"teie Google\'i konto"</li>\n<li>"süsteemi ja rakenduse andmed ning seaded"</li>\n<li>"Allalaaditud rakendused"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Olete praegu sisse logitud järgmistele kontodele:"\n</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muusika"</li>\n<li>"Fotod"</li>\n<li>"Muud kasutajaandmed"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Muusika, piltide ja muu kasutajateabe kustutamiseks tuleb tühjendada ka "<b>"USB-mäluseade"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Muusika, piltide ja muude kasutajaandmete kustutamiseks tuleb tühjendada ka "<b>"SD-kaart"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Kustuta USB-mäluseade"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Kustuta SD-kaart"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Sisemiselt USB-mäluseadmelt kõikide andmete (nt muusika või fotode) kustutamine"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"SD-kaardilt kõigi andmete (nt muusika või fotode) kustutamine"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Lähtesta tahvelarvuti"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Lähtesta telefon"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Kas kustutada kogu teie isiklik teave ja allalaaditud rakendused? Seda toimingut ei saa tagasi võtta."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Kustuta kõik"</string>
    <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Joonistage oma avamismuster"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Tehaseandmetele lähtestamise kinnitamiseks peate joonistama avamismustri."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Lähtestust ei tehtud, sest süsteemi kustutamise teenus pole saadaval."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Kas lähtestada?"</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Kustuta USB-mäluseade"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Kustuta SD-kaart"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Kustutab USB-lt kõik andmed"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Kustutab kõik SD-kaardil olevad andmed"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Kas kustutada kõik USB-mäluseadmel olevad andmed? Kaotate "<b>"kõik"</b>" salvestatud andmed."</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Kas soovite SD-kaardi tühjendada? Kaotate "<b>"kõik"</b>" kaardil olevad andmed."</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Kustuta USB-mäluseade"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Kustuta SD-kaart"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Kas tühjendada USB-mäluseade, kustutades kõik salvestatud failid? Toimingut ei saa tagasi võtta."</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Kas soovite SD-kaardi tühjendada, kustutades kõik sinna salvestatud failid? Toimingut ei saa tagasi võtta."</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Kustuta kõik"</string>
    <string name="media_format_gesture_prompt" msgid="3109349468816856670">"Joonistage oma avamismuster"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"USB-salvestusruumi kustutamise kinnitamiseks peate joonistama avamismustri."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"SD-kaardi kustutamise kinnitamiseks peate joonistama avamismustri."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Kõneseaded"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Seadista kõnepost, kõne edastamine, ootel kõne, helistaja ID"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"USB jagamine"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Kantav tööpunkt"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Bluetoothi jagamine"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Jagamine"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Jagam. ja kant. kuumkoht"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"USB jagamine"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"USB ühendatud, märkige jagamiseks"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Jagatud"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Ei saa jagada, kui USB-mäluseade on kasutusel"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB ei ole ühendatud"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"USB jagamise viga"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Bluetoothi jagamine"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Tahvelarvuti Interneti-ühendust jagatakse"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Telefoni Interneti-ühenduse jagamine"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Tahvelarvuti Interneti-ühendust jagatakse 1 seadmega"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Telefoni Interneti-ühenduse jagamine 1 seadmega"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Selle tahvelarvuti Interneti-ühendust jagatakse <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> seadmega"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Selle telefoni Interneti-ühendust jagatakse <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> seadmega"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Tahvelarvuti Interneti-ühendust ei jagata"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Telefoni Interneti-ühendust ei jagata"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Jagamata"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Ei saa jagada rohkem kui <xliff:g id="MAXCONNECTION">%1$d</xliff:g> seadmele."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühenduse jagamine lõpetatakse."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Abi"</string>
    <string name="network_settings_title" msgid="7967552516440151852">"Mobiilsidevõrgud"</string>
    <string name="location_title" msgid="1029961368397484576">"Minu asukoht"</string>
    <string name="location_network_based" msgid="7472814266821714527">"WiFi ja mobiilsidevõrgu asukoht"</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"Lubage rakendustel kasutada Google\'i asukohateenust, et asukohta kiiremini määrata. Kogutud anonüümsed asukohaandmed saadetakse Google\'ile."</string>
    <string name="location_neighborhood_level_wifi" msgid="7457348712272184793">"WiFi määratud asukoht"</string>
    <string name="location_gps" msgid="8392461023569708478">"GPS-i satelliidid"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Lubage rakendustel tahvelarvuti GPS-i abil teie asukohta määrata"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Lubage rakendustel telefoni GPS-i abil teie asukohta määrata"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Kasuta abistatud GPS-i"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Kasuta serverit GPS-i abistamiseks (eemaldage märge võrgukasutuse vähendamiseks)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Kasutage serverit GPS-i assisteerimiseks (eemaldage märge GPS-i toimivuse parandamiseks)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Asukoht ja Google\'i otsing"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Lubage Google\'il otsingutulemuste ja muude teenuste parandamiseks kasutada teie asukohta"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Juurdepääs minu asukohale"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Laske rakendustel, mis on palunud teie luba, kasutada teie asukohateavet"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Asukohaallikad"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Teave tahvelarvuti kohta"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Telefoni kohta"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Vaadake juriidilist teavet, olekut, tarkvara versiooni"</string>
    <string name="legal_information" msgid="5769301644270604095">"Juriidiline teave"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Kaasautorid"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Regulatiivteave"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autoriõigus"</string>
    <string name="license_title" msgid="1990487604356037871">"Litsents"</string>
    <string name="terms_title" msgid="7697580845616764642">"Nõuded ja tingimused"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Avatud lähtekoodiga litsentsid"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Litsentside laadimisega on probleem."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Laadimine ..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Ohutusteave"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Ohutusteave"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Teil ei ole andmesideühendust. Selle teabe vaatamiseks praegu minge Interneti-ühendusega arvutis aadressile %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Laadimine ..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Valige parool"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Mustri valimine"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Valige PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Kinnitage parool"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Kinnitage PIN-kood"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Paroolid ei ühti"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"PIN-koodid ei ühti"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Valiku avamine"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Parool on määratud"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"PIN-kood on määratud"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Muster on määratud"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Ekraani turvalisus"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Muuda avamismustrit"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Muuda avamise PIN-koodi"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Kinnitage salvestatud muster"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Proovige uuesti:"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Joonistage avamismuster"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Abi saamiseks vajutage valikut Menüü."</string>
    <string name="lockpattern_recording_inprogress" msgid="4622772178078818425">"Tõsta sõrm, kui on valmis."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3103250430366718996">"Ühendage vähemalt <xliff:g id="NUMBER">%d</xliff:g> punkti. Proovige uuesti:"</string>
    <string name="lockpattern_pattern_entered_header" msgid="8378617839439987962">"Muster on salvestatud."</string>
    <string name="lockpattern_need_to_confirm" msgid="5144676887162575050">"Koosta muster kinnitamiseks uuesti:"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2223856038485537716">"Teie uus avamismuster:"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Kinnita"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Koosta uuesti"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Proovige uuesti"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Jätka"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Avamismuster"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Mustri nõudmine"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Ekraani avamiseks tuleb koostada muster"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Tee muster nähtavaks"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibreeri puudutusel"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Lukus toitenupu vajutamisel"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Määra avamismuster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Muuda avamismustrit"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kuidas joonistada avamismustrit"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Liiga palju valesid katseid."</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Proovige uuesti <xliff:g id="NUMBER">%d</xliff:g> sekundi pärast."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Rakendus pole teie telefoni installitud."</string>
    <string name="skip_button_label" msgid="8680422740354436943">"Tühista"</string>
    <string name="next_button_label" msgid="8890792540116568321">"Järgmine"</string>
    <string name="lock_title" product="tablet" msgid="2909697418179419990">"Tahvelarvuti turvaliseks muutmine"</string>
    <string name="lock_title" product="default" msgid="4059246467204273930">"Telefoni turvaliseks muutmine"</string>
    <string name="lock_intro_message" product="tablet" msgid="8616353869251700776">"Kaitske oma tahvelarvutit volitamata kasutamise eest, luues ekraani isikliku avamismustri. Järgmisel ekraanil ühendage sõrmega punktid mis tahes järjekorras. Peate ühendama vähemalt neli punkti. "\n\n"Kas olete valmis alustama? Puudutage valikut Järgmine."</string>
    <string name="lock_intro_message" product="default" msgid="8393155371327584659">"Kaitske oma telefoni volitamata kasutamise eest, luues ekraani isikliku avamismustri. Järgmisel ekraanil ühendage sõrmega mis tahes järjekorras vähemalt neli punkti. "\n\n"Kas olete valmis alustama? Puudutage valikut Järgmine."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Halda rakendusi"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Installitud rakenduste haldamine ja eemaldamine"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Rakendused"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Rakenduste haldamine, kiirkäivituse otseteede seadistamine"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Rakenduse seaded"</string>
    <string name="install_applications" msgid="4872012136210802181">"Tundmatud allikad"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Luba tundmatutest allikatest pärinevate rakenduste installimine"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Teie tahvelarvuti ja isikuandmed on haavatavamad rünnakutele rakenduste kaudu, mis pärinevad tundmatutest allikatest. Nõustute, et olete ainuisikuliselt vastutav tahvelarvuti kahjustuste või andmekao eest, mis võivad tuleneda nende rakenduste kasutamisest."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Telefon ja isiklikud andmed on rünnakute suhtes haavatavamad tundmatutest allikatest pärit rakenduste kaudu. Nõustute, et olete ainuisikuliselt vastutav telefoni kahjustuste või andmekao eest, mis võivad tuleneda nende rakenduste kasutusest."</string>
    <string name="verify_applications" msgid="2959359554974828518">"Rakenduste kinnitamine"</string>
    <string name="verify_applications_summary" msgid="6737505521913263792">"Keela potentsiaalselt kahjulike rakenduste installimine või hoiata enne installimist"</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Täpsemad seaded"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Luba rohkem seadete valikuid"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Rakenduse teave"</string>
    <string name="storage_label" msgid="8700867073480107253">"Mäluruum"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Vaikekäivitus"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Vaikeseaded"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Ekraani ühilduvus"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Load"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Vahemälu"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Tühjenda vahemälu"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Vahemälu"</string>
    <string name="controls_label" msgid="7611113077086853799">"Juhtnupud"</string>
    <string name="force_stop" msgid="7435006169872876756">"Sunni peatuma"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Kokku"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Rakendus"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Rakendus USB-mäluseadmel"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Andmed"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"USB-mäluseadme andmed"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"SD-kaart"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Desinstalli"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Kõikidelt kasutajatelt desinstallimine"</string>
    <string name="install_text" msgid="884360662922471113">"Installi"</string>
    <string name="disable_text" msgid="6544054052049395202">"Keela"</string>
    <string name="enable_text" msgid="9217362512327828987">"Luba"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Kustuta andmed"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Desinstalli värskendused"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Olete otsustanud selle rakenduse mõne toimingu puhul käivitada vaikimisi."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Olete lubanud sellel rakendusel vidinaid luua ja nende andmetele juurde pääseda."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Vaikeväärtused pole määratud."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Kustuta vaikeväärtused"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"See rakendus ei pruugi teie ekraanile sobida. Sobivust saate kontrollida siin."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Küsi käivitamisel"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Skaleeri rakendus"</string>
    <string name="unknown" msgid="1592123443519355854">"Tundmatu"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Sordi nime alusel"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Sordi suuruse järgi"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Kuva töötavad teenused"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Kuva vahemällu salvestatud protsessid"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Läht. rakend. eelistused"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Läht. rakend. eelistused?"</string>
    <string name="reset_app_preferences_desc" msgid="1118129530999596317">"See lähtestab kõik eelistused rakendusele:"\n\n" "<li>"Keelatud rakendused"</li>\n" "<li>"Keelatud rakenduste teatised"</li>\n" "<li>"Vaikerakendused toimingutele"</li>\n" "<li>"Taustaandmete piirangud rakendustele"</li>\n\n" Te ei kaota mingeid rakenduse andmeid."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Lähtesta rakendused"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Halda ruumi"</string>
    <string name="filter" msgid="2018011724373033887">"Filter"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Filtrivalikute valimine"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Kõik"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Allalaaditud"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Töös"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"USB-mäluseade"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"SD-kaardil"</string>
    <string name="disabled" msgid="9206776641295849915">"Keelatud"</string>
    <string name="not_installed" msgid="1475144352069281880">"Installimata"</string>
    <string name="no_applications" msgid="7336588977497084921">"Rakendusi pole."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Sisemälu"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"USB-mäluseade"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"SD-kaardi mäluruum"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Suuruse ümberarvutamine ..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Kas kustutada rakenduse andmed?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Rakenduse kõik andmed kustutatakse lõplikult. See hõlmab kõiki faile, seadeid, kontosid, andmebaase jne."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Tühista"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Rakendust ei leitud installitud rakenduste loendist."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Rakenduse andmete kustutamine ebaõnnestus."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Kas desinstallida värskendused?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Kõik selle Androidi süsteemirakenduse värskendused desinstallitakse."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Kustuta andmed"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Rakenduse andmete tühjendamine ebaõnnestus."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"See rakendus pääseb teie tahvelarvutis juurde järgmisele:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Sel rakendusel on teie telefonis järgmised juurdepääsuõigused:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Sellel rakendusel on teie tahvelarvutis juurdepääs järgmisele. Toimivuse parandamiseks ja mälukasutuse vähendamiseks on mõned neist lubadest saadaval rakenduse <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> jaoks, kuna see töötab samas protsessis kui <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Sellel rakendusel on teie telefonis juurdepääs järgmisele. Toimivuse parandamiseks ja mälukasutuse vähendamiseks on mõned neist lubadest saadaval rakenduse <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> jaoks, kuna see töötab samas protsessis kui <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> ja <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> ja <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"See rakendus võib põhjustada tasusid:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Tasulise SMS-i saatmine"</string>
    <string name="computing_size" msgid="1599186977475211186">"Arvutamine ..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Paketi suurust ei saanud arvutada."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Teil pole ühtegi kolmanda osapoole rakendust installitud."</string>
    <string name="version_text" msgid="9189073826278676425">"versioon <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Teisalda"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Teisalda tahvelarvutisse"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Teisalda telefoni"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Teisalda USB-mällu"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Teisalda SD-kaardile"</string>
    <string name="moving" msgid="6431016143218876491">"Teisaldamine"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Ei ole piisavalt ruumi."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Rakendust ei ole olemas."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Rakendus on kopeerimiskaitstud."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Installimise asukoht ei ole kehtiv."</string>
    <string name="system_package" msgid="6222593098063037137">"Süsteemivärskendusi ei saa installida välisele kandjale."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Kas peatada sunniviisiliselt?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Kui sunnite rakenduse peatuma, võib see valesti käituda."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Ei saa rakendust teisaldada. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Eelistatud installiasukoht"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Muutke uute rakenduste eelistatud installiasukohta"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Kas keelata sisseeh. rakendus?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Kui keelate sisseehitatud rakenduse, võivad muud rakendused valesti käituda."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Kas kustutada andmed ja keelata rakendus?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Kui keelate sisseehitatud rakenduse, võib teiste rakenduste toimivus muutuda ebastabiilseks. Samuti kustutatakse teie andmed."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Kas lülitada teatised välja?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Kui lülitate selle rakenduse teatised välja, võivad olulised märguanded ja värskendused märkamata jääda."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Kasutatud mälu"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Vaadake rakenduste kasutatavat mälu"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Käitatud teenused"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Praegu käitatud teenuste vaatamine ja juhtimine"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Taaskäivitamine"</string>
    <string name="cached" msgid="1059590879740175019">"Vahemällu salvestatud taustaprotsess"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Midagi ei esitata"</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Käivitas rakendus"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> vaba"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> kasutusel"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Kasutaja: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Eemaldatud kasutaja"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsess ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenus"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsess ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenust"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsessi ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenus"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsessi ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenust"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Käitatav rakendus"</string>
    <string name="no_services" msgid="7133900764462288263">"Pole aktiivne"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Teenused"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Protsessid"</string>
    <string name="service_stop" msgid="6369807553277527248">"Peata"</string>
    <string name="service_manage" msgid="1876642087421959194">"Seaded"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Selle teenuse käivitas tema rakendus. Selle peatamine võib põhjustada rakenduse sulgemise."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Seda rakendust ei saa ohutult peatada. Peatamisel võite kaotada osa oma praegusest tööst."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"See on vana rakenduse protsess, mida igaks juhuks ikka veel käitatakse. Selle peatamiseks pole tavaliselt põhjust."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: praegu kasutusel. Puudutage selle juhtimiseks valikut Seaded."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Peamine protsess on kasutusel."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Teenus <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Teenusepakkuja <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Kas peatada süsteemi teenus?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Kui teenuse peatate, ei pruugi mõned tahvelarvuti funktsioonid õigesti töötada, kuni selle välja ja seejärel uuesti sisse lülitate."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Kui teenuse peatate, ei pruugi mõned telefoni funktsioonid õigesti töötada, kuni selle välja ja seejärel uuesti sisse lülitate."</string>
    <string name="language_settings" msgid="5292716747264442359">"Keeled ja sisestamine"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Keeled ja sisestamine"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Keeleseaded"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klaviatuur ja sisestusmeetodid"</string>
    <string name="phone_language" msgid="8870144109924299673">"Keel"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automaatne asendamine"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Paranda valesti sisestatud sõnad"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Autom. suurtähtede kasut."</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Lausete alguses suurtähtede kasutamine"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automaatsed kirjavahemärgid"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Füüsilise klaviatuuri seaded"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Vajutage kaks korda tühikuklahvi, et sisestada „.”"</string>
    <string name="show_password" msgid="3001113966880559611">"Muuda paroolid nähtavaks"</string>
    <string name="show_password_summary" msgid="7345931695292850058"></string>
    <string name="ime_security_warning" msgid="4135828934735934248">"See sisestusmeetod võib koguda kogu teie sisestatava teksti, sh isikuandmed (nt paroolid ja krediitkaardinumbrid). See pärineb rakendusest <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Kas soovite seda sisestusmeetodit kasutada?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"See õigekirjakontrollija võib koguda kogu sisestatava teksti, sh isiklikud andmed (nt paroolid ja krediitkaardinumbrid). See pärineb rakendusest <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Kas soovite seda õigekirjakontrolli kasutada?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Seaded"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Keel"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Rakenduse <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g> seadete avamine ebaõnnestus"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Hiir/puuteplaat"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Kursori kiirus"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Mängukontroller"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Kasuta värinat"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Suunab värina mängukontrollerisse, kui see on ühendatud."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Klaviatuuri paigutuse valimine"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Seadista klaviatuuri paigutus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Vahetamiseks vajutage Ctrl+tühikut"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Vaikepaigutus"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Klaviatuuri paigutused"</string>
    <string name="user_dict_settings_titlebar" msgid="765659257455000490">"Kasutajasõnastik"</string>
    <string name="user_dict_single_settings_title" msgid="524997218433540614">"Isiklik sõnastik"</string>
    <string name="user_dict_multiple_settings_title" msgid="3735224433307996276">"Isiklikud sõnastikud"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Lisa"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Lisa sõnastikku"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fraas"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Rohkem valikuid"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Vähem valikuid"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Sõna:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Otsetee:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Keel:"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Muuda sõna"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Muuda"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Kustuta"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"Teie kasutajasõnastikus ei ole ühtegi sõna. Sõna saate lisada, puudutades nuppu Lisa (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Kõikides keeltes"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Rohkem keeli ..."</string>
    <string name="testing" msgid="6584352735303604146">"Testimine"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Teave tahvelarvuti kohta"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Telefoni andmed"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Akuteave"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Kiirkäivitus"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Määra rakenduste käivitamiseks klaviatuuri otseteed"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Määra rakendus"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Otsetee puudub"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Otsing + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Kustutamine"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Teie otsetee <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) jaoks kustutatakse."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"OK"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Tühista"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Rakendused"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Otseteed"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Tekstisisestus"</string>
    <string name="input_method" msgid="5434026103176856164">"Sisestusmeetod"</string>
    <string name="current_input_method" msgid="234072873286056438">"Vaikimisi"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Sisestusmeetodi valija"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automaatne"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Kuva alati"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Peida alati"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Sisestusmeetodite seadistamine"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Seaded"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Seaded"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktiivsed sisestusmeetodid"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Süsteemi keele kasutamine"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Üksuse <xliff:g id="IME_NAME">%1$s</xliff:g> seaded"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Aktiivsete sisestusmeetodite valim."</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Ekraaniklaviatuuri seaded"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Füüsiline klaviatuur"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Füüsilise klaviatuuri seaded"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Arendaja valikud"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Rakenduse arenduse valikute määramine"</string>
    <string name="enable_adb" msgid="7982306934419797485">"USB silumine"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Silumisrežiim, kui USB on ühendatud"</string>
    <string name="bugreport_in_power" msgid="4548816486587403971">"Toitemenüü veaaruanded"</string>
    <string name="bugreport_in_power_summary" msgid="5764234382355067053">"Kaasa toitemenüüs veaaruande tegemise valik"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Jää sisselülitatuks"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Ekraan ei lähe kunagi laadimise ajal unerežiimi"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Luba võltsasukohti"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Luba võltsasukohti"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Luban USB silumise?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"USB-silumine on mõeldud ainult arendamiseks. Kasutage seda andmete kopeerimiseks oma arvuti ja seadme vahel, seadmesse rakenduste installimiseks ilma teatisteta ning logiandmete lugemiseks."</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Kas lubada arendajaseaded?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Need seaded on mõeldud ainult arendajatele. Need võivad põhjustada seadme ja seadmes olevate rakenduste rikkeid või valesti toimimist."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Kinnita rakendus USB kaudu"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Kontrolli, kas ADB/ADT-ga installitud rakendused on ohtlikud."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Kaitse USB-salvestusruumi"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Rakendused peavad USB-salvestusruumi lugemiseks loa taotlema"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Kas kaitsta USB-salvestusruumi?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Kui USB-salvestusruum on kaitstud, peavad rakendused välismäluseadmelt andmete lugemiseks loa taotlema."\n\n"Mõned rakendused ei pruugi töötada enne, kui arendaja on need värskendanud."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Kaitse SD-kaarti"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Rakendused peavad SD-kaardi lugemiseks loa taotlema"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Kas kaitsta SD-kaarti?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Kui SD-kaart on kaitstud, peavad rakendused välismäluseadmelt andmete lugemiseks loa taotlema."\n\n"Mõned rakendused ei pruugi töötada enne, kui arendaja on need värskendanud."</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Valige vidin"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Valige vidin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Kas luua vidin ja lubada juurdepääs?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Pärast vidina loomist saab <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> juurdepääsu kõikidele kuvatavatele andmetele."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Luba rakendusel <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> alati vidinaid luua ja nende andmetele juurdepääs hankida"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> p <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> m <xliff:g id="SECONDS">%4$d</xliff:g> s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> m <xliff:g id="SECONDS">%3$d</xliff:g> s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> m <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g>s"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Kasutusstatistika"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Kasutusstatistika"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Sortimisalus:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Rakendus"</string>
    <string name="launch_count_label" msgid="4019444833263957024">"Loenda"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Kasutusaeg"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Juurdepääsetavus"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Juurdepääsetavuse seaded"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Teenused"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Süsteem"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Suurendamisliigutused"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"Kui see funktsioon on sisse lülitatud, saate suurendada ja vähendada, kolmikpuudutades ekraani."\n\n"Suurendatult saab teha järgmist."\n<ul><li>"Paanida: lohistage kahe või enama sõrmega üle ekraani."</li>\n<li>"Korrigeerida suumitaset: liigutage kahte või enamat sõrme kokku või lahku."</li></ul>\n\n"Saate ka ajutiselt suurendada sõrme all olevat kujutist, kolmikpuudutades ekraani ja hoides sõrme ekraanil. Selles suurendatud olekus saate sõrme ekraanil lohistada, et vaadata kuva erinevaid osi. Eelmisesse olekusse naasmiseks tõstke sõrm ekraanilt."\n\n"Märkus: kolmikpuudutamine suurendamiseks toimib kõikjal, v.a klaviatuur ja navigeerimisriba."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Hõlbustuse otsetee"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Sees"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Välja"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Kui see funktsioon sisse lülitatud, saate kiiresti lubada juurdepääsetavuse funktsiooni kahe sammuga:"\n\n"1. samm: vajutage ja hoidke all toitenuppu, kuni kuulete heli või tunnete vibratsiooni."\n\n"2. samm: puudutage ja hoidke kahe sõrmega, kuni kuulete helikinnitust."\n\n"Kui seadmel on mitu kasutajat, kasutage lukustusekraanil seda otseteed, et ajutiselt lubada juurdepääs seadme avamiseni."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Suur tekst"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Ekraanisuurendus"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Ekraanisuurenduse värskendus"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Ekraanisuurenduse kasutus rakenduste vahetamisel"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Toitenupp lõpetab kõne"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Paroolide ettelugemine"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Puudutage ja hoidke viivitust"</string>
    <string name="accessibility_toggle_script_injection_preference_title" msgid="7950932054266694403">"Veebijuurdepääsu täiustamine"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Seaded"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Sees"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Väljas"</string>
    <string name="accessibility_script_injection_allowed" msgid="7624804397748427621">"Lubatud"</string>
    <string name="accessibility_script_injection_disallowed" msgid="8639525487720429182">"Ei ole lubatud"</string>
    <string name="accessibility_script_injection_button_allow" msgid="2201503285877102870">"Luba"</string>
    <string name="accessibility_script_injection_button_disallow" msgid="5697152768523270885">"Ära luba"</string>
    <string name="accessibility_service_security_warning_title" msgid="5421628151509995404">"Kas soovite kasutada teenust <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_security_warning_summary" product="tablet" msgid="8558441850832543571">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> võib koguda kogu teie sisestatud teksti, v.a paroolid. Siia kuuluvad ka isiklikud andmed, näiteks krediitkaardinumbrid. Teenus võib koguda andmeid ka tahvelarvuti kasutamise kohta."</string>
    <string name="accessibility_service_security_warning_summary" product="default" msgid="2869015914319424723">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> võib koguda kogu teie sisestatud teksti, v.a paroolid. Siia kuuluvad ka isiklikud andmed, näiteks krediitkaardinumbrid. Teenus võib koguda andmeid ka telefoni kasutamise kohta."</string>
    <string name="accessibility_service_disable_warning_title" msgid="3393956845814484859">"Kas soovite teenuse <xliff:g id="SERVICE">%1$s</xliff:g> peatada?"</string>
    <string name="accessibility_service_disable_warning_summary" msgid="625013894287895398">"Kui puudutate OK, siis teenus <xliff:g id="SERVICE">%1$s</xliff:g> peatub."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Ühtki teenust pole installitud"</string>
    <string name="accessibility_service_no_apps_title" msgid="5124097563864109821">"Kas vajate ekraanilugejat?"</string>
    <string name="accessibility_service_no_apps_message" msgid="7751662416377046539">"TalkBack esitab tagasiside suulise kõnena, mis aitab pimedaid ja vaegnägijaid. Kas soovite selle Android Marketist tasuta installida?"</string>
    <string name="accessibility_script_injection_security_warning_summary" msgid="7706858873495386310">"Kas lubate rakendustel installida Google\'ist pärinevaid skripte, mis muudavad veebisisu kättesaadavamaks?"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Kirjeldust ei ole sisestatud."</string>
    <string name="settings_button" msgid="3006713718908152930">"Seaded"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Aku"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Mis on akut kasutanud"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Aku andmed pole saadaval."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Akukasutus alates lahutamisest"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Akukasutus alates lähtestamisest"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> akutoitel"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> alates lahutamisest"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Laadimine"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Ekraan sees"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS on sisse lülitatud"</string>
    <string name="battery_stats_wifi_running_label" msgid="3093545080361658269">"WiFi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Sisse lülitatud"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Mobiilsidevõrgu signaal"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Seadme ärkveloleku aeg"</string>
    <string name="wifi_on_time" msgid="6310209835617490616">"WiFi õigel ajal"</string>
    <string name="bluetooth_on_time" msgid="6157799524996162271">"WiFi õigel ajal"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> – <xliff:g id="NUMBER">%2$s</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Ajaloo üksikasjad"</string>
    <string name="details_title" msgid="3792801565213935385">"Üksikasjade kasutamine"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Kasuta detaile"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Reguleerige energiakasutust"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Kaasnevad paketid"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekraan"</string>
    <string name="power_wifi" msgid="2382791137776486974">"WiFi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Mobiiltelefon ooterežiimil"</string>
    <string name="power_phone" msgid="5392641106474567277">"Tavakõned"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tahvelarvuti on ooterežiimis"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon tegevuseta"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"CPU kokku"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU esiplaanil"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Hoia ärkvel"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="8234997940652067049">"WiFi töötab"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tahvelarvuti"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="2857401966985425427">"Saadetud andmed"</string>
    <string name="usage_type_data_recv" msgid="7251090882025234185">"Vastuvõetud andmed"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Heli"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Kestus"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Aeg ilma signaalita"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Sunni peatuma"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Rakenduse teave"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Rakenduse seaded"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Ekraani seaded"</string>
    <string name="battery_action_wifi" msgid="2272741639606146903">"WiFi-seaded"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Bluetoothi ​​seaded"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Tavakõnede akukasutus"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Akukasutus tahvelarvuti ooterežiimis"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Akukasutus telefoni ooterežiimis"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Mobiiltelefoni raadio akukasutus"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Aku säästmiseks lülitu mobiililevita kohtades lennurežiimile"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Ekraani ja taustvalguse akukasutus"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Vähenda ekraani heledust ja/või ekraani ajalõppu"</string>
    <string name="battery_desc_wifi" msgid="1702486494565080431">"WiFi kasutatav aku"</string>
    <string name="battery_sugg_wifi" msgid="2085605314976704287">"Lülitage WiFi välja, kui te seda ei kasuta või kui see pole saadaval"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Bluetoothi akukasutus"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Kui te Bluetoothi ei kasuta, lülitage see välja"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Proovige ühendus luua teise Bluetoothi seadmega"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Rakenduse akukasutus"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Peatage või desinstallige rakendus"</string>
    <string name="battery_sugg_apps_gps" msgid="7287643439298561315">"Juhtige GPS-i käsitsi, et rakendus seda ei kasutaks"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Rakendus võib pakkuda akukasutust vähendavaid seadeid"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Kasutaja akukasutus"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> alates lahutamisest"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Alates viimasest lahutamisest <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Kasutus kokku"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Värskenda"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Android OS"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Meediumiserver"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Kõnesisend ja -väljund"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Kõnesisendi ja -väljundi seaded"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Häälotsing"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Androidi klaviatuur"</string>
    <string name="voice_category" msgid="1430370497125803904">"Kõne"</string>
    <string name="recognizer_title" msgid="3231385184559054457">"Hääletuvastaja"</string>
    <string name="recognizer_settings_title" msgid="432493301215113154">"Häälotsing"</string>
    <string name="recognizer_settings_summary" msgid="4472287934134546902">"Tuvastaja „<xliff:g id="RECOGNIZER_NAME">%s</xliff:g>” seaded"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Kõnesünteesi seaded"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Kõnesünteesi väljund"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Kasuta alati minu seadeid"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Allolevad vaikeseaded alistavad rakenduse seaded"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Vaikeseaded"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Vaikemootor"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Määrab räägitud teksti jaoks kasutatava kõnesünteesimootori"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Kõnekiirus"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Teksti rääkimise kiirus"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Helikõrgus"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Mõjutab räägitava teksti tooni"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Keel"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Määrab räägitud teksti keelespetsiifilise hääle"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Kuulake näidet"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Esita lühike kõnesünteesi demo"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Installi hääleandmed"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Installi kõnesünteesi jaoks vajalikud hääleandmed"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Kõnesünteesi jaoks vajalikud hääled on juba installitud."</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Teie seadeid on muudetud. See on näide, kuidas need võiks kõlada."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Valitud mootorit ei saa käitada."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Seadista"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Vali teine ​​mootor"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"See kõnesünteesimootor võib koguda kogu kõneldud teksti, sh isiklikke andmeid, nagu paroolid ja krediitkaardinumbrid. Selle aluseks on mootor <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Kas lubada kõnesünteesimootori kasutamine?"</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Mootorid"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Mootori <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> seaded"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> on lubatud"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> on keelatud"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Mootoriseaded"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Seaded: <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Keeled ja hääled"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Installitud"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Installimata"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Naine"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Mees"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Kõnesünteesimootor on installitud"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Lubage enne kasut. uus mootor."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Käivita mootori seaded"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Eelistatud mootor"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Üldine"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Toite juhtimine"</string>
    <string name="gadget_toggle_wifi" msgid="2382963973155082629">"WiFi-seade värskendamine"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Bluetoothi seade värskendamine"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"sees"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"väljas"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"sisselülitamine"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"väljalülitamine"</string>
    <string name="gadget_wifi" msgid="5960290421313061434">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_gps" msgid="1558173602059236567">"GPS"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sünkroonimine"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Heledus <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automaatne"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"täielik"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"poolik"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"väljas"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Mandaatide mälu"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Mälust installimine"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"SD-kaardilt installimine"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Installi sertifikaadid mälust"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Sertifikaatide installimine SD-kaardilt"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Kustuta mandaadid"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Kõikide sertifikaatide eemaldamine"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Usaldusväärsed mandaadid"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Usaldusväärsete CA-sertifikaatide kuvamine"</string>
    <string name="credentials_install_gesture_prompt" msgid="2207390278112395082">"Joonistage oma luku avamise muster"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Mandaadi installimise kinnitamiseks tuleb teil joonistada luku avamise muster."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Sisestage mandaadi salvestamise parool."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Kehtiv parool:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Kas eemaldada kogu sisu?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Parool peab olema vähemalt 8 tähemärki."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Vale parool."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Vale parool. Teil on veel üks võimalus, enne kui mandaatide mälu kustutatakse."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Vale parool. Teil on veel <xliff:g id="NUMBER">%1$d</xliff:g> võimalus(t) enne, kui mandaatide mälu kustutatakse."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Mandaatide mälu kustutatakse."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Mand. mälu ei saanud kustut."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Mandaadi mälu on lubatud."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Enne mandaatide salvestusruumi kasutamist peate määrama lukustusekraani PIN-koodi või parooli."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Hädaabitoon"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Määra käitumine hädaabikõne korral"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Varundamine ja lähtestamine"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Varundamine ja lähtestamine"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Varundamine ja taastamine"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Isikuandmed"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Minu andmete varundamine"</string>
    <string name="backup_data_summary" msgid="9157861529438245957">"Varundage rakenduste andmed, WiFi paroolid ja muud seaded Google\'i serverites"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Varukonto"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Ühelegi kontole ei ole praegu salvestatud varundatud andmeid"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automaatne taastamine"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Rakenduse uuesti installimisel taasta varundatud seaded ja andmed"</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Arvutivarunduse parool"</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Täielikud arvutivarundused pole praegu kaitstud"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Puudutage, et muuta või eemaldada täielike arvutivarunduste parool"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Uus varuparool on määratud"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Uus parool ja kinnitus ei ühti"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Varuparooli määramine ebaõnnestus"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="7218566008912418809">"Kas soovite WiFi paroolide, järjehoidjate, muude seadete ja rakenduste andmete varundamise lõpetada ja kõik Google\'i serverites olevad koopiad kustutada?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Seadme haldusseaded"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Seadme ülem"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Inaktiveeri"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Seadme ülemad"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Pole ühtegi seadme ülemat"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Aktiveerin seadme ülema?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Aktiveeri"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Seadme ülem"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Selle administraatori aktiveerimisel lubatakse rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"See administraator on aktiivne ja lubab rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid:"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Pealkirjata"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Üldine"</string>
    <string name="sound_category_notification_title" msgid="3502115998790286943">"Teatised"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Kõne helin ja vibratsioon"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Süsteem"</string>
    <string name="wifi_setup_title" msgid="661074868726906436">"WiFi seadistamine"</string>
    <string name="wifi_setup_title_editing_network" msgid="7304321031985059969">"WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g> ühenduse loomine"</string>
    <string name="wifi_setup_title_connecting_network" msgid="3747859666621319757">"WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g> ühenduse loomine ..."</string>
    <string name="wifi_setup_title_connected_network" msgid="209755856836003839">"WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g> on ühendus loodud"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Võrgu lisamine"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Ühendus puudub"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Lisa võrk"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Värskenda loendit"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Jäta vahele"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Järgmine"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Tagasi"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Võrgu üksikasjad"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Ühenda"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Unusta"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Salvesta"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Tühista"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Võrkude skaneering ..."</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Puudutage võrku sellega ühenduse loomiseks"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Ühenda olemasoleva võrguga"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Turvamata võrguga ühenduse loomine"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Sisestage võrgu konfigureerimine"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Uue võrguga ühenduse loomine"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Ühendamine ..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Minge järgmise sammu juurde"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"EAP-d ei toetata."</string>
    <string name="wifi_setup_eap_not_supported" msgid="595556546597351489">"Seadistamise ajal ei saa häälestada EAP WiFi-ühendust. Saate seda teha pärast seadistamise lõppu. Selleks tehke valikud Seaded &gt; Traadita võrgud."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Ühendamiseks võib kuluda mõni minut ..."</string>
    <string name="wifi_setup_description_connected" msgid="5235991893829582459">"Seadistamise jätkamiseks puudutage nuppu "<b>"Järgmine"</b>"."\n\n"Kui tahate teise Wifi-võrguga ühendust luua, vajutage nuppu "<b>"Tagasi"</b>"."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sünkroonimine lubatud"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sünkroonimine keelatud"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Sünkroonimise viga"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sünkroonimine ebaõnnestus"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sünkroonimine on aktiivne"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sünkroonimine"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sünkroonimisega on praegu probleeme. See on varsti tagasi."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Lisa konto"</string>
    <string name="background_data" msgid="5779592891375473817">"Taustaandmed"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Rakendused saavad andmeid sünkroonida, saata ja vastu võtta"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Keel. taustaandmed?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Taustaandmete keelamine pikendab aku kestvust ja vähendab andmekasutust. Mõned rakendused võivad siiski andmesideühendusi taustal kasutada."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Rakenduse andmete automaatne sünkr."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sünkroonim. on SEES"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sünkroonimine VÄLJAS"</string>
    <string name="sync_error" msgid="5060969083117872149">"Sünkroonimise viga"</string>
    <string name="last_synced" msgid="4242919465367022234">"Viimati sünkroonitud <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sünkroonimine ..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Varunda seaded"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Minu seadete varundamine"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sünkrooni kohe"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Loobu sünkroonimisest"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Puudutage kohe sünkroonimiseks<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalender"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontaktid"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Tere tulemast Google Synci!"</font>" "\n"See on Google\'i meetod andmete sünkroonimiseks, mis tagab teile kõikjal juurdepääsu kontaktisikutele, kokkusaamistele ja muule."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Rakenduse sünkroonimisseaded"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Andmed ja sünkroonimine"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Parooli muutmine"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Konto seaded"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Eemalda konto"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Konto lisamine"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Lõpeta"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Kas eemaldada konto?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Selle konto eemaldamisel kustutatakse kõik seal olevad sõnumid, kontaktid ja muud tahvelarvutis olevad andmed."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Selle konto eemaldamisel kustutatakse kõik seal olevad sõnumid, kontaktid ja muud telefonis olevad andmed."</string>
    <string name="remove_account_failed" product="tablet" msgid="3086620478225952725">"See konto on mõne rakenduse jaoks vajalik. Saate selle eemaldada vaid siis, kui lähtestate tahvelarvuti tehaseseadetele (sel juhul kustutatakse kõik teie isikuandmed) asukohas Seaded &gt; Varundamine ja lähtestamine."</string>
    <string name="remove_account_failed" product="default" msgid="6217238709175617517">"See konto on mõne rakenduse jaoks vajalik. Saate selle eemaldada vaid siis, kui lähtestate telefoni tehaseseadetele (sel juhul kustutatakse kõik teie isikuandmed) asukohas Seaded &gt; Varundamine ja lähtestamine."</string>
    <string name="provider_label" msgid="7724593781904508866">"Vajutage tellimusi"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Ei saa käsitsi sünkroonida"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Selle üksuse sünkroonimine on praegu keelatud. Seade muutmiseks lülitage ajutiselt sisse taustaandmed ja automaatne sünkroonimine."</string>
    <string name="wimax_settings" msgid="1574837328738396794">"4G seaded"</string>
    <string name="wimax_settings_summary" msgid="3207355006084135453">"Seadistage ja hallake 4G võrku ning modemit"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"4G MAC-aadress"</string>
    <string name="enter_password" msgid="4131758584074246224">"Mälu dekrüpteerimiseks sisestage parool"</string>
    <string name="try_again" msgid="4272075051293936921">"Proovige uuesti."</string>
    <string name="delete" msgid="4219243412325163003">"Kustuta"</string>
    <string name="misc_files" msgid="6720680815969643497">"Mitmesugused failid"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"valitud <xliff:g id="NUMBER">%1$d</xliff:g>/<xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g>/<xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Vali kõik"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"HDCP-kontrollimine"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"HDCP käitumise määramine"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Silumine"</string>
    <string name="debug_app" msgid="8349591734751384446">"Valige silumisrakendus"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Ühtegi silumisrakendust pole määratud"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Silumisrakendus: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Rakenduse valimine"</string>
    <string name="no_application" msgid="2813387563129153880">"Mitte ühtegi"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Oodake silurit"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Silutud rakendus ootab toimimiseks siluri lisamist"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Sisend"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Joonis"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Jälgimine"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Range režiim on lubatud"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Ekr. vilgub, kui rakend. teevad peateemal toiming."</string>
    <string name="pointer_location" msgid="6084434787496938001">"Kursori asukoht"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Praegusi puuteandmeid kuvav ekraani ülekate"</string>
    <string name="show_touches" msgid="1356420386500834339">"Näita puuteid"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Kuva visuaalset tagasisidet puudete kohta"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Näita pinna värskendusi"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Akna pinna värskendam. kirjuta kogu akna pind üle"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Näita GPU kuva värskend."</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"GPU-ga joonistades kirjuta akende kuvad üle"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Kuva riistv. kiht. värsk."</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Riistvara kihid vilguvad värskendamisel roheliselt"</string>
    <string name="show_hw_overdraw" msgid="1136884304711318251">"Kuva GPU ülejoonistamine"</string>
    <string name="show_hw_overdraw_summary" msgid="4295714000923082647">"Parimast halvimani: sin., roh., helepunane, punane"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Keela HW ülekatted"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Kasuta alati GPU-d kuva koostamisel"</string>
    <string name="enable_traces_title" msgid="7448835465859512430">"Luba jälgimine"</string>
    <string name="enable_traces_dialog_title" msgid="5026490474669452929">"Vali lubatud jälgimised"</string>
    <string name="enable_traces_summary_none" msgid="1867562808503494163">"Praegu pole lubatud ükski jälgimine"</string>
    <string name="enable_traces_summary_num" msgid="8978230237777454269">"<xliff:g id="NUM">%1$d</xliff:g> jälgimist on praegu lubatud"</string>
    <string name="enable_traces_summary_all" msgid="3950139649125158247">"Kõik jälgimised on praegu lubatud"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Luba OpenGL-i jälgimine"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Näita paigutuse piire"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Kuva klipi piirid, veerised jms"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"CPU-kasutuse kuvamine"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Praegust CPU-kasutust kuvav ekraani ülekate"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Jõusta GPU renderdamine"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Jõusta GPU kasutam. kahemõõtmeliste jooniste puhul"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Jõusta 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Luba 4x MSAA OpenGL ES 2.0 rakendustes"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profiili GPU renderdamine"</string>
    <string name="track_frame_time_summary" msgid="447577515813970287">"Mõõda renderdusaega adb-kestas: dumpsys gfxinfo"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Akna animatsiooni skaala"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Ülemineku animats. skaala"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Animaatori kestuse skaala"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Modelleeri teisi ekraane"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Rakendused"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Ära hoia tegevusi alles"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Kõigi tegev. hävit. kohe, kui kasutaja neist lahk."</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Taustaprotsesside piir"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Näita kõiki ANR-e"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Kuva taustarakendustele dial. Rakendus ei reageeri"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Andmekasutus"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Andmete kasutamistsükkel"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Andmerändlus"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Piira taustaandmeid"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Eraldi 4G kasutamine"</string>
    <string name="data_usage_menu_show_wifi" msgid="8266875319417201085">"WiFi kasutamise kuvamine"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Kuva Etherneti-kasutus"</string>
    <string name="data_usage_menu_metered" msgid="5056695223222541863">"Mobiilside leviala"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Andmete automaatne sünkroonimine"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Tsükli muutmine ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Kuupäev andmekasutustsükli lähtestamiseks:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Sel perioodil ei kasut. andmeid ükski rakendus."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Esiplaan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Taust"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"piiratud"</string>
    <string name="data_usage_disable_mobile" msgid="5211007048880167438">"Kas soovite mobiilse andmeside keelata?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Seadke mobiilandmeside piirang"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Määrake 4G andmemahupiirang"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Määrake 2G-3G andmemahupiirang"</string>
    <string name="data_usage_disable_wifi_limit" msgid="8575537650560665657">"Määrake WiFi andmepiirang"</string>
    <string name="data_usage_tab_wifi" msgid="1728851922959017766">"WiFi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobiil"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G–3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobiilne"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Mitte ükski"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobiiliandmed"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"2G–3G-andmeside"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"4G-andmeside"</string>
    <string name="data_usage_app_settings" msgid="8430240158135453271">"Kuva rakenduse seadeid"</string>
    <string name="data_usage_app_restrict_background" msgid="9149728936265100841">"Piira taustaandmeid"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="518658001418490405">"Keelab mobiilsidevõrkude taustaandmed. Võimalusel kasutatakse muid võrke."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Rakend. taustandm. piiramiseks määrake mob. andmeside piirang."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Funktsiooni tõttu võivad taustaandmetel põhinev rakendus töötamast lakata, kui saadaval on ainult mobiilsidevõrgud."\n\n"Andmekasutuse täpsemad juhtelemendid leiate rakenduse seadetest."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="7086969103661420799">"Taustandmete piiramine on võimalik vaid juhul, kui olete määranud mobiilse andmeside piirangu."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Kas lülitan andmete automaatse sünkroonimise sisse?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="7312283529426636845">"Veebis kontodel tehtud muudatused kopeeritakse automaatselt teie tahvelarvutisse."\n\n"Mõned kontod võivad ka kõik tahvelarvutis tehtud muudatused automaatselt veebi kopeerida. Google\'i konto töötab nii."\n\n"Igal kontol sünkroonitava teabe valimiseks avage jaotis Seaded &gt; Kontod."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="2374996799819303283">"Veebis kontodel tehtud muudatused kopeeritakse automaatselt teie telefoni."\n\n"Mõned kontod võivad ka kõik telefonis tehtud muudatused automaatselt veebi kopeerida. Google\'i konto töötab nii."\n\n"Igal kontol sünkroonitava teabe valimiseks avage jaotis Seaded &gt; Kontod."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Kas lülitan andmete automaatse sünkroonimise välja?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"See säästab andmemahu ja aku kasutust, kuid teil tuleb hiljutise teabe hankimiseks sünkroonida iga konto eraldi ja värskenduste ilmumisel ei kuvata teatist."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Kasutustsükli lähtestuskuupäev"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Igakuine kuupäev:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Määra"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Andmekasutuse hoiatuse määramine"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Andmekasutuse piirangu määramine"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Andmekasutuse piiramine"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="3893348029612821262">"Määratud limiidi saavutamisel keelatakse mobiilne andmesideühendus."\n\n"Kaaluge konservatiivse limiidi kasutamist, kuna andmekasutust mõõdab teie tahvelarvuti ja teenusepakkuja võib arvestada kasutust teisiti."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="7962145861903746827">"Määratud limiidi saavutamisel keelatakse mobiilne  andmesideühendus."\n\n"Kaaluge konservatiivse limiidi kasutamist, kuna andmekasutust mõõdab teie telefon ja teenusepakkuja võib arvestada kasutust teisiti."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_restrict_background" msgid="6387252645350792955">"Kui piirate mobiilside taustandmed, siis WiFi-võrgu puudumisel mõned rakendused ja teenused ei tööta."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="2609163428726042269">"Kui piirate mobiilset taustandmevahetust, siis teatud rakendused ja teenused ei tööta, välja arvatud juhul, kui olete ühenduses WiFi-võrguga."\n\n"Seade mõjutab kõiki tahvelarvuti kasutajaid."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="8025473178302056174">"Kui piirate mobiilset taustandmevahetust, siis teatud rakendused ja teenused ei tööta, välja arvatud juhul, kui olete ühenduses WiFi-võrguga."\n\n"Seade mõjutab kõiki telefoni kasutajaid."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"hoiatus"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"piir"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Eemaldatud rakendused"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Eemaldatud rakendused ja kasutajad"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> vastu võetud, <xliff:g id="SENT">%2$s</xliff:g> saadetud"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: kasutatud umbes <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g>: tahvelarvuti mõõdetud kasutus u <xliff:g id="TOTAL">%1$s</xliff:g>. Oper. andmekasutuse arvestus võib erineda."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g>: telef. mõõdetud kasutus on u <xliff:g id="TOTAL">%1$s</xliff:g>. Operaatori andmekasutuse arvestus võib erineda."</string>
    <string name="data_usage_metered_title" msgid="6204750602856383278">"Mobiilside leviala"</string>
    <string name="data_usage_metered_body" msgid="2446827764036316131">"Valige WiFi-võrgud, mis töötavad mobiilside levialadena. Taustarakendusi on võimalik takistada neid võrke kasutamast. Teid võidakse enne hoiatada, kui rakendused laadivad võrkude kaudu alla mahukaid üksusi."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobiilsidevõrgud"</string>
    <string name="data_usage_metered_wifi" msgid="4151511616349458705">"WiFi-võrgud"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="7566012564261138417">"Mobiilside levialade valimiseks lülitage WiFi sisse."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Hädaabikõne"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Tagasi kõne juurde"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Nimi"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Tüüp"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Serveri aadress"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"PPP krüpteerimine (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"L2TP saladus"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"IPSeci tunnus"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"IPSeci eeljagatud võti"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"IPSeci kasutaja sertifikaat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"IPSeci CA-sertifikaat"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Serveri IPSeci sertifikaat"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Kuva täpsemad valikud"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"DNS-i otsingudomeenid"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"DNS-serverid (nt 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Edastamismarsruudid (nt 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Kasutajanimi"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Parool"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Salvesta kontoteave"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(ei kasutata)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(ära kinnita serverit)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(serverist saadud)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Tühista"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Salvesta"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Ühenda"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"VPN-i profiili muutmine"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Profiiliga <xliff:g id="PROFILE">%s</xliff:g> ühendamine"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"VPN-i profiili lisamine"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Muuda profiili"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Kustuta profiil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Alati sees VPN"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Valige VPN-i profiil, millega olla alati ühendatud. Võrguliiklus on lubatud ainult siis, kui olete ühendatud selle VPN-iga."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Puudub"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Alati sees VPN-i jaoks on vaja IP-aadressi nii serverile kui ka DNS-ile."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Võrguühendus puudub. Proovige hiljem uuesti."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Sertifikaat on puudu. Muutke profiili."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Süsteem"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Kasutaja"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Keela"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Luba"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Eemalda"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Kas lubada süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Kas keelata süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Kas eemaldada kasutaja CA-sertifikaat jäädavalt?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Õigekirjakontroll"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sisestage oma täieliku varukoopia praegune parool siia"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sisestage täielike varukoopiate uus parool siia"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Sisestage siia uuesti oma täieliku varukoopia uus parool"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Varukoopia määramine"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Tühista"</string>
    <string name="percentage" msgid="5866131581207788624">"<xliff:g id="NUMBER">%d</xliff:g>%%"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Süsteemi lisavärskendused"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Keelatud"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Lubav"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Jõustumisel"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Kasutajad"</string>
    <string name="user_you_section" msgid="6247838798859425408">"Teie"</string>
    <string name="user_list_title" msgid="8866161687358773982">"Teised kasutajad"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Kasutaja lisamine"</string>
    <string name="user_summary_active" msgid="4740649452346004418">"Aktiivne"</string>
    <string name="user_summary_inactive" msgid="3758296246095054572">"Pole aktiivne"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Pole seadistatud"</string>
    <string name="user_owner" msgid="3879126011135546571">"Omanik"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Hüüdnimi"</string>
    <string name="user_add_user_title" msgid="3961861593718285403">"Uue kasutaja lisamine"</string>
    <string name="user_add_user_message_long" msgid="2278524063301283723">"Võite jagada seadet teiste kasutajatega, luues uusi kasutajaid. Igal kasutajal on oma ruum, mida saab kohandada rakenduste, taustapildi ja muuga. Kasutajad saavad kohandada ka tahvelarvuti seadeid, näiteks WiFi valikuid, mis mõjutavad kõiki kasutajaid."\n\n"Pärast uue kasutaja loomist peab kasutaja läbima seadistusprotsessi."\n\n"Iga kasutaja saab teiste kasutajate nimel võtta vastu värskendatud rakenduste lubasid."</string>
    <string name="user_add_user_message_short" msgid="3310933423737035428">"Pärast uue kasutaja loomist peab kasutaja läbima seadistusprotsessi."\n\n"Iga kasutaja saab teiste kasutajate nimel võtta vastu värskendatud rakenduste lubasid."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Kas seadistada nüüd kasutaja?"</string>
    <string name="user_setup_dialog_message" msgid="614037943337008555">"Veenduge, et isik saab tahvelarvutit kasutada ja oma ruumi seadistada"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Seadista nüüd"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Mitte praegu"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Ainult tahvelarvuti omanik saab hallata kasutajaid."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Ainult telefoni omanik saab hallata kasutajaid."</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Kustuta seadmest <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Uus kasutaja"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Kas soovite kustutada iseenda?"</string>
    <string name="user_confirm_remove_title" msgid="3856148232937245711">"Kas eemaldada kasutaja?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"Kaotate selles tahvelarvutis olevad ruumi ja andmed. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"Kaotate selles telefonis olevad ruumi ja andmed. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_confirm_remove_message" product="tablet" msgid="4610106937214870034">"Kasutaja ruum ja andmed kaovad tahvelarvutist. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_confirm_remove_message" product="default" msgid="8130264611683731142">"Kasutaja ruum ja andmed kaovad telefonist. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Uue kasutaja lisamine ..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Kasutaja kustutamine"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Kustuta"</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Seade mõjutab kõiki tahvelarvuti kasutajaid."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Seade mõjutab kõiki telefoni kasutajaid."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Muuda keelt"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Fondi suuruse muutmine"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Kuva teatised"</string>
    <string name="help_label" msgid="1107174367904110532">"Abi"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Sisu konto"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"Foto ID"</string>
    <string name="cell_broadcast_settings" msgid="8415582011920085222">"Kärjeteated"</string>
    <string name="cell_broadcast_settings_summary" msgid="3301339398950905913">"Valige kuvamiseks hädaolukorra märguannete tüübid."</string>
</resources>
