<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="5973789783504771878">"kB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="8897567456150907538">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="durationDays" msgid="6652371460511178259">"<xliff:g id="DAYS">%1$d</xliff:g> päeva"</string>
    <string name="durationDayHours" msgid="2713107458736744435">"<xliff:g id="DAYS">%1$d</xliff:g> päev <xliff:g id="HOURS">%2$d</xliff:g> h"</string>
    <string name="durationDayHour" msgid="7293789639090958917">"<xliff:g id="DAYS">%1$d</xliff:g> päev <xliff:g id="HOURS">%2$d</xliff:g> h"</string>
    <string name="durationHours" msgid="4266858287167358988">"<xliff:g id="HOURS">%1$d</xliff:g> h"</string>
    <string name="durationHourMinutes" msgid="9029176248692041549">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="durationHourMinute" msgid="2741677355177402539">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="durationMinutes" msgid="3134226679883579347">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="durationMinute" msgid="7155301744174623818">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="durationMinuteSeconds" msgid="1424656185379003751">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="durationMinuteSecond" msgid="3989228718067466680">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="durationSeconds" msgid="8050088505238241405">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="durationSecond" msgid="985669622276420331">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Pealkirjata&gt;"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Telefoninumbrit pole)"</string>
    <string name="unknownName" msgid="6867811765370350269">"Teadmata"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Kõnepost"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Ühendusprobleem või kehtetu MMI-kood."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Toiming on ainult fikseeritud valimisnumbritele."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Teenus on lubatud."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Teenus oli lubatud järgmisele:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Teenus on keelatud."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registreerimine õnnestus."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Kustutamine oli edukas."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Vale parool."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI on lõpule viidud."</string>
    <string name="badPin" msgid="9015277645546710014">"Sisestatud vana PIN-kood pole õige."</string>
    <string name="badPuk" msgid="5487257647081132201">"Sisestatud PUK-kood pole õige."</string>
    <string name="mismatchPin" msgid="609379054496863419">"Sisestatud PIN-koodid ei kattu."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Sisestage 4–8-numbriline PIN-kood."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Sisestage 8- või enamanumbriline PUK-kood."</string>
    <string name="needPuk" msgid="919668385956251611">"SIM-kaart on PUK-lukustatud. Avamiseks sisestage PUK-kood."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Sisestage SIM-kaardi blokeeringu tühistamiseks PUK2-kood."</string>
    <string name="enablePin" msgid="209412020907207950">"Ebaõnnestus, SIM-i/RUIM-i lukustuse lubamine."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1251012001539225582">
      <item quantity="other">Teil on enne SIM-kaardi lukustumist jäänud veel <xliff:g id="NUMBER_1">%d</xliff:g> katset.</item>
      <item quantity="one">Teil on enne SIM-kaardi lukustumist jäänud veel <xliff:g id="NUMBER_0">%d</xliff:g> katse.</item>
    </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Sissetuleva kõne helistaja ID"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Väljuva kõne helistaja ID"</string>
    <string name="ColpMmi" msgid="3065121483740183974">"Ühendatud liini ID"</string>
    <string name="ColrMmi" msgid="4996540314421889589">"Ühendatud liini ID piiramine"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Kõnede suunamine"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Koputus"</string>
    <string name="BaMmi" msgid="455193067926770581">"Kõnepiirang"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Parooli muutmine"</string>
    <string name="PinMmi" msgid="3113117780361190304">"PIN-koodi muutmine"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Helistaja number olemas"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Helistaja number piiratud"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Kolmesuunaline kõne"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Soovimatute tüütute kõnede hülgamine"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Helistaja numbri kohaletoimetamine"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Mitte häirida"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Helistaja ID vaikimisi piiratud. Järgmine kõne: piiratud"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Helistaja ID vaikimisi piiratud. Järgmine kõne: pole piiratud"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Vaikimisi pole helistaja ID piiratud. Järgmine kõne: piiratud"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Helistaja ID pole vaikimisi piiratud. Järgmine kõne: pole piiratud"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Teenus pole ette valmistatud."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Helistaja ID seadet ei saa muuta."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Piiratud juurdepääs muutunud"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Andmesideteenus on blokeeritud."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Hädaabiteenus on blokeeritud."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Häälteenus on blokeeritud."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Kõik häälteenused on blokeeritud."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"SMS-teenus on blokeeritud."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Hääl-/andmeteenused on blokeeritud."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Hääl-/SMS-teenused on blokeeritud."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Kõik hääl-/andme-/SMS-teenused on blokeeritud."</string>
    <string name="peerTtyModeFull" msgid="6165351790010341421">"Partner taotles TTY-režiimi TÄIELIK"</string>
    <string name="peerTtyModeHco" msgid="5728602160669216784">"Partner taotles TTY-režiimi HCO"</string>
    <string name="peerTtyModeVco" msgid="1742404978686538049">"Partner taotles TTY-režiimi VCO"</string>
    <string name="peerTtyModeOff" msgid="3280819717850602205">"Partner taotles TTY-režiimi VÄLJAS"</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Hääl"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Andmed"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAKS"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Asünkrooni"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sünkroonimine"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Pakett"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Rändlusindikaator sees"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Rändlusindikaator väljas"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Rändlusindikaator vilgub"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Naabruskonnast väljas"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Arendusest väljas"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Rändlus – eelistatud süsteem"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Rändlus – saadaolev süsteem"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Rändlus – Alliance\'i partner"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Rändlus – Premiumi partner"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Rändlus - täisteenuse funktsionaalsus"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Rändlus - osaline teenusefunktsionaalsus"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Rändluse bänner sees"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Rändlusbänner väljas"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Teenuse otsimine"</string>
    <string name="wfcRegErrorTitle" msgid="2301376280632110664">"WiFi-kõned"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
  </string-array>
    <string name="wfcSpnFormat" msgid="8211621332478306568">"%s"</string>
    <string name="wfcDataSpnFormat" msgid="1118052028767666883">"%s"</string>
    <string name="wifi_calling_off_summary" msgid="8720659586041656098">"Väljas"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1994113411286935263">"WiFi eelistusega"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="5920549484600758786">"Mobiilside eelistusega"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="2379919155237869320">"Ainult WiFi"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: pole suunatud"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> <xliff:g id="TIME_DELAY">{2}</xliff:g> sekundi pärast"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: pole suunatud"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: pole edastatud"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Funktsioonikood valmis."</string>
    <string name="fcError" msgid="3327560126588500777">"Ühendusprobleem või kehtetu funktsioonikood."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"OK"</string>
    <string name="httpError" msgid="7956392511146698522">"Ilmnes võrgu viga."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"URL-i ei leita."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Saidi autentimise skeemi ei toetata."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Autentimine ebaõnnestus."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Puhverserveri kaudu autentimine ebaõnnestus."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Serveriga ei saanud ühendust."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Serveriga ei saanud ühendust. Proovige hiljem uuesti."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Ühendus serveriga aegunud."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Leht sisaldab liiga palju serveri ümbersuunamisi."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokolli ei toetata."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Turvalist ühendust ei saanud luua."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Lehte pole võimalik avada, kuna URL on vale."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Failile ei pääse juurde."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Soovitud faili ei leitud."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Töötlemisel on liiga palju taotlusi. Proovige hiljem uuesti."</string>
    <string name="notification_title" msgid="8967710025036163822">"Viga kontole <xliff:g id="ACCOUNT">%1$s</xliff:g> sisselogimisel"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sünkroonimine"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Sünkroonimine"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Liiga palju üksuse <xliff:g id="CONTENT_TYPE">%s</xliff:g> kustutusi."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Tahvelarvuti mäluruum on täis. Ruumi vabastamiseks kustutage mõned failid."</string>
    <string name="low_memory" product="watch" msgid="4415914910770005166">"Kella talletusruum on täis. Ruumi vabastamiseks kustutage mõned failid."</string>
    <string name="low_memory" product="tv" msgid="516619861191025923">"Teleri salvestusruum on täis. Kustutage mõni fail ruumi vabastamiseks."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Telefonimälu on täis. Ruumi vabastamiseks kustutage mõned failid."</string>
    <string name="ssl_ca_cert_warning" msgid="5848402127455021714">"Võrku võidakse jälgida"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Tundmatu kolmas osapool:"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="550758088185764312">"Teie tööprofiili administraatori poolt"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"Domeen: <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5005572078641980632">"Tööprofiil on kustutatud"</string>
    <string name="work_profile_deleted_description" msgid="6305147513054341102">"Tööprofiil on kustutatud puuduva administraatori rakenduse tõttu."</string>
    <string name="work_profile_deleted_details" msgid="226615743462361248">"Tööprofiili administraatori rakendus puudub või on rikutud. Seetõttu on teie tööprofiil ja seotud andmed kustutatud. Abi saamiseks võtke ühendust administraatoriga."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="6019770344820507579">"Teie tööprofiil pole selles seadmes enam saadaval."</string>
    <string name="factory_reset_warning" msgid="5423253125642394387">"Seade kustutatakse"</string>
    <string name="factory_reset_message" msgid="4905025204141900666">"Administraatori rakendusel on puuduvaid osi või on see rikutud ja seda ei saa kasutada. Seade kustutatakse. Abi saamiseks võtke ühendust administraatoriga."</string>
    <string name="me" msgid="6545696007631404292">"Mina"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Tahvelarvuti valikud"</string>
    <string name="power_dialog" product="tv" msgid="6153888706430556356">"Teleri valikud"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Telefonivalikud"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Hääletu režiim"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Lülitage traadita side sisse"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Lülitage raadioside välja"</string>
    <string name="screen_lock" msgid="799094655496098153">"Ekraanilukk"</string>
    <string name="power_off" msgid="4266614107412865048">"Lülita välja"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Helin on väljas"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Vibreeriv helin"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Helin on sees"</string>
    <string name="reboot_to_update_title" msgid="6212636802536823850">"Androidi süsteemivärskendus"</string>
    <string name="reboot_to_update_prepare" msgid="6305853831955310890">"Värskendamise ettevalmistamine …"</string>
    <string name="reboot_to_update_package" msgid="3871302324500927291">"Värskenduspaketi töötlemine …"</string>
    <string name="reboot_to_update_reboot" msgid="6428441000951565185">"Taaskäivitamine ..."</string>
    <string name="reboot_to_reset_title" msgid="4142355915340627490">"Tehase andmetele lähtestamine"</string>
    <string name="reboot_to_reset_message" msgid="2432077491101416345">"Taaskäivitamine ..."</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Väljalülitamine ..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Teie tahvelarvuti lülitub välja."</string>
    <string name="shutdown_confirm" product="tv" msgid="476672373995075359">"Teler suletakse."</string>
    <string name="shutdown_confirm" product="watch" msgid="3490275567476369184">"Teie kell lülitub välja."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Teie telefon lülitub välja."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Kas soovite välja lülitada?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Ohutus režiimis taaskäivitamine"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Kas soovite taaskäivitada ohutus režiimis? See keelab kõik installitud kolmandate osapoolte rakendused. Need taastatakse pärast uuesti taaskäivitamist."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Hiljutised"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Hiljutisi rakendusi pole."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Tahvelarvuti valikud"</string>
    <string name="global_actions" product="tv" msgid="7240386462508182976">"Teleri valikud"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Telefonivalikud"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Ekraanilukk"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Lülita välja"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Veaaruanne"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Veaaruande võtmine"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Nii kogutakse teavet teie seadme praeguse oleku kohta, et saata see meilisõnumina. Enne kui saate veaaruande ära saata, võtab selle loomine natuke aega; varuge kannatust."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Hääletu režiim"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Heli on VÄLJAS"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Heli on SEES"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Lennurežiim"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Lennurežiim on SEES"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Lennurežiim on VÄLJAS"</string>
    <string name="global_action_settings" msgid="1756531602592545966">"Seaded"</string>
    <string name="global_action_assist" msgid="3892832961594295030">"Abi"</string>
    <string name="global_action_voice_assist" msgid="7751191495200504480">"Häälabi"</string>
    <string name="global_action_lockdown" msgid="8751542514724332873">"Lukusta kohe"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="safeMode" msgid="2788228061547930246">"Turvarežiim"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Android-süsteem"</string>
    <string name="user_owner_label" msgid="2804351898001038951">"Isiklik"</string>
    <string name="managed_profile_label" msgid="6260850669674791528">"Töö"</string>
    <string name="permgrouplab_contacts" msgid="3657758145679177612">"Kontaktid"</string>
    <string name="permgroupdesc_contacts" msgid="6951499528303668046">"juurdepääs kontaktidele"</string>
    <string name="permgrouplab_location" msgid="7275582855722310164">"Asukoht"</string>
    <string name="permgroupdesc_location" msgid="1346617465127855033">"pääseda juurde selle seadme asukohale"</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalender"</string>
    <string name="permgroupdesc_calendar" msgid="3889615280211184106">"juurdepääs kalendrile"</string>
    <string name="permgrouplab_sms" msgid="228308803364967808">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="4656988620100940350">"saata ja vaadata SMS-sõnumeid"</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Mäluruum"</string>
    <string name="permgroupdesc_storage" msgid="637758554581589203">"juurde pääseda seadmesse salvestatud fotodele, meediale ja failidele"</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="4988812113943554584">"heli salvestamine"</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Kaamera"</string>
    <string name="permgroupdesc_camera" msgid="3250611594678347720">"pildistamine ja video salvestamine"</string>
    <string name="permgrouplab_phone" msgid="5229115638567440675">"Telefon"</string>
    <string name="permgroupdesc_phone" msgid="6234224354060641055">"helistamine ja telefonikõnede haldamine"</string>
    <string name="permgrouplab_sensors" msgid="416037179223226722">"Kehaandurid"</string>
    <string name="permgroupdesc_sensors" msgid="7147968539346634043">"juurdepääs anduri andmetele teie eluliste näitajate kohta"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Akna sisu toomine"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Tutvuge kasutatava akna sisuga."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Puudutusega sirvimise sisselülitamine"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Puudutatud üksuste nimesid esitatakse häälega ning ekraani saab sirvida puudutustega."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Veebi täiustatud juurdepääsu sisselülitamine"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Rakenduse sisu kättesaadavamaks muutmiseks võidakse installida skripte."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Sisestatud teksti jälgimine"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Sisaldab isiklikke andmeid, nt krediitkaardi numbreid ja paroole."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"keela või muuda olekuriba"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Võimaldab rakendusel keelata olekuriba või lisada ja eemaldada süsteemiikoone."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"olekuriba"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Võimaldab rakendusel olla olekuriba."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"laienda/ahenda olekuriba"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Võimaldab rakendusel laiendada või ahendada olekuriba."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"otseteede installimine"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Lubab rakendusel lisada avaekraani otseteid ilma kasutaja sekkumiseta."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"otseteede desinstallimine"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Lubab rakendusel eemaldada avaekraani otseteid ilma kasutaja sekkumiseta."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"marsruutige väljuvad kõned uuesti"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5156385005547315876">"Lubab rakendusel näha, mis number valitakse väljahelistamisel, ning laseb suunata kõne teisele numbrile või selle üldse katkestada."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"võtke vastu tekstisõnumeid (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Võimaldab rakendusel vastu võtta ja töödelda SMS-sõnumeid. See tähendab, et rakendus võib jälgida või kustutada teie seadmele saadetud sõnumeid neid teile näitamata."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"võtke vastu tekstisõnumeid (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Võimaldab rakendusel vastu võtta ja töödelda multimeediumsõnumeid. See tähendab, et rakendus võib jälgida või kustutada teie seadmele saadetud sõnumeid neid teile näitamata."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"mobiilsidesõnumite lugemine"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Võimaldab rakendusel lugeda seadme vastu võetud mobiilsidesõnumeid. Mobiilsidemärguandeid edastatakse mõnes asukohas eriolukorrast teavitamiseks. Pahatahtlikud rakendused võivad segada seadme toimivust või tööd eriolukorra sõnumi vastuvõtmisel."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"loe tellitud kanaleid"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Võimaldab rakendusel saada üksikasju praegu sünkroonitavate voogude kohta."</string>
    <string name="permlab_sendSms" msgid="7544599214260982981">"saata ja vaadata SMS-sõnumeid"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Võimaldab rakendusel saata SMS-sõnumeid. See võib kaasa tuua ootamatuid tasusid. Pahatahtlikud rakendused võivad teile tekitada kulusid, saates sõnumeid teie kinnituseta."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"lugege oma tekstisõnumeid (SMS või MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Võimaldab rakendusel lugeda tahvelarvutisse või SIM-kaardile salvestatud SMS-sõnumeid. See võimaldab rakendusel lugeda kõiki SMS-sõnumeid sisust või konfidentsiaalsusest hoolimata."</string>
    <string name="permdesc_readSms" product="tv" msgid="5102425513647038535">"Lubab rakendusel lugeda telerisse või SIM-kaardile salvestatud SMS-sõnumeid. See võimaldab rakendusel lugeda kõiki SMS-sõnumeid, olenemata nende sisust või konfidentsiaalsusest."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Võimaldab rakendusel lugeda telefoni või SIM-kaardile salvestatud SMS-sõnumeid. See võimaldab rakendusel lugeda kõiki SMS-sõnumeid sisust või konfidentsiaalsusest hoolimata."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"võtke vastu tekstisõnumeid (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Võimaldab rakendusel vastu võtta ja töödelda WAP-sõnumeid. See luba hõlmab võimet jälgida või kustutada teile saadetud sõnumeid neid teile näitamata."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"Käitatud rakenduste toomine"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Võimaldab rakendusel tuua teavet praegu ja hiljuti käitatud ülesannete kohta. See võib lubada rakendusel avastada teavet selle kohta, milliseid rakendusi seadmes kasutatakse."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="5979288447973722097">"Profiili- ja seadmeomanike haldamine"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="106894851498657169">"Võimaldab rakendustel määrata profiiliomanikud ja seadmeomaniku."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"käitatud rakenduste ümberjärjestamine"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Võimaldab rakendusel teisaldada ülesanded esiplaanile ja taustale. Rakendus võib seda teha teie sisendita."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"autorežiimi lubamine"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Võimaldab rakendusel autorežiimi lubada."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"sulgege teised rakendused"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Võimaldab rakendusel lõpetada teiste rakenduste taustaprotsesse. See võib peatada teiste rakenduste töö."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"tõmmake üle teiste rakenduste"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Lubab rakendusel joonistada teistele rakendustele või nende kasutajaliidestele. See võib segada ükskõik millise rakenduse liidese kasutamist või muuta seda, mida arvate nägevat."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"Rakenduste pidev töös hoidmine"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Võimaldab rakendusel muuta oma osi mälus püsivaks. See võib piirata teistele (tahvelarvutit aeglasemaks muutvatele) rakendustele saadaolevat mälu."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="5086862529499103587">"Lubab rakendusel muuta enda osasid mälus püsiüksusteks. See võib piirata teistele rakendustele saadaolevat mälumahtu ja muuta teleri aeglasemaks."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Võimaldab rakendusel muuta oma osi mälus püsivaks. See võib piirata teistele (telefoni aeglasemaks muutvatele) rakendustele saadaolevat mälu."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"Rakenduse mäluruumi mõõtmine"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Võimaldab rakendusel tuua oma koodi, andmed ja vahemälu suurused"</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"muutke süsteemi seadeid"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Võimaldab rakendusel muuta süsteemiseadete andmeid. Pahatahtlikud rakendused võivad rikkuda teie süsteemi konfiguratsiooni."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"käitage käivitamisel"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Võimaldab rakendusel käivituda ise kohe, kui süsteem on käivitunud. See võib tahvelarvuti käivitamist aeglustada ja lubab rakendusel muuta tahvelarvuti ka üldiselt aeglasemaks, kuna töötab pidevalt."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="4525890122209673621">"Võimaldab rakendusel käivituda kohe, kui süsteem on käivitunud. Selle tõttu võib teleri käivitumiseks kuluda rohkem aega ja selle tulemusel võib aeglustada tahvelarvuti üldine toimimine, sest rakendus töötab alati."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Võimaldab rakendusel käivituda ise kohe, kui süsteem on käivitunud. See võib telefoni käivitamist aeglustada ja lubab rakendusel muuta telefoni ka üldiselt aeglasemaks, kuna töötab pidevalt."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"kleepsaate saatmine"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Võimaldab rakendusel saata püsivaid edastusi, mis jäävad pärast saate lõppemist alles. Ülemäärane kasutamine võib muuta tahvelarvuti aeglaseks või ebastabiilseks, põhjustades selle liiga suure mälukasutuse."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="6839285697565389467">"Lubab rakendusel saata püsiülekandeid, mis jäävad alles pärast ülekande lõppemist. Liigne kasutamine võib muuta teleri aeglaseks või ebastabiilseks, sest teler kasutab selleks liigselt mälu."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Võimaldab rakendusel saata püsivaid edastusi, mis jäävad pärast saate lõppemist alles. Ülemäärane kasutamine võib muuta telefoni aeglaseks või ebastabiilseks, põhjustades selle liiga suure mälukasutuse."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"lugege oma kontakte"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Võimaldab rakendusel lugeda andmeid teie tahvelarvutisse salvestatud kontaktide kohta, näiteks seda, kui tihti te kellelegi helistate, meilite või nendega muul viisil suhtlete. See luba võimaldab rakendustel salvestada teie kontaktandmeid ja pahatahtlikud rakendused võivad teie teadmata kontaktandmeid jagada."</string>
    <string name="permdesc_readContacts" product="tv" msgid="1839238344654834087">"Lubab rakendusel lugeda telerisse salvestatud kontaktide andmeid, sh seda, kui sageli olete konkreetsele isikule helistanud, meilinud või temaga muul viisil suhelnud. See luba võimaldab rakendustel kontaktandmeid salvestada ja pahatahtlikud rakendused võivad jagada kontaktandmeid teie teadmata."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Võimaldab rakendusel lugeda andmeid teie telefoni salvestatud kontaktide kohta, näiteks seda, kui tihti te kellelegi helistate, meilite või nendega muul viisil suhtlete. See luba võimaldab rakendustel salvestada teie kontaktandmeid ja pahatahtlikud rakendused võivad teie teadmata kontaktandmeid jagada."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"muutke oma kontakte"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Võimaldab rakendusel muuta tahvelarvutisse salvestatud kontaktide andmeid, sealhulgas seda, kui tihti olete konkreetsetele kontaktidele helistanud, meilinud või nendega muul viisil suhelnud. See luba võimaldab rakendustel kustutada kontaktandmeid."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="5438230957000018959">"Lubab rakendusel muuta telefoni salvestatud kontaktide andmeid, sealhulgas seda, kui tihti olete konkreetsetele kontaktidele helistanud, meilinud või nendega muul viisil suhelnud. See luba võimaldab rakendustel kustutada kontaktandmeid."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Võimaldab rakendusel muuta telefoni salvestatud kontaktide andmeid, sealhulgas seda, kui tihti olete konkreetsetele kontaktidele helistanud, meilinud või nendega muul viisil suhelnud. See luba võimaldab rakendustel kustutada kontaktandmeid."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"kõnelogi lugemine"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Võimaldab rakendusel lugeda teie tahvelarvuti kõnelogi, sh andmeid sissetulevate ja väljuvate kõnede kohta. See luba võimaldab rakendustel salvestada teie kõnelogi andmeid ja pahatahtlikud rakendused võivad teie teadmata kõnelogi andmeid jagada."</string>
    <string name="permdesc_readCallLog" product="tv" msgid="5611770887047387926">"Lubab rakendusel lugeda teleri kõnelogi, sh teavet sissetulevate ja väljuvate kõnede kohta. See luba võimaldab rakendusel logiandmeid salvestada ja pahatahtlikud rakendused võivad teie teadmata kõnelogi andmeid jagada."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Võimaldab rakendusel lugeda teie telefoni kõnelogi, sh andmeid sissetulevate ja väljuvate kõnede kohta. See luba võimaldab rakendustel salvestada teie kõnelogi andmeid ja pahatahtlikud rakendused võivad teie teadmata kõnelogi andmeid jagada."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"kõnelogi kirjutamine"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Lubab rakendusel muuta tahvelarvuti kõnelogi, sh sissetulevate ja väljaminevate kõnede andmeid. Pahatahtlikud rakendused võivad kasutada seda kõnelogi kustutamiseks või muutmiseks."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="4225034892248398019">"Lubab rakendusel muuta teleri kõnelogi, sh sissetulevate ja väljaminevate kõnede andmeid. Pahatahtlikud rakendused võivad kasutada seda kõnelogi kustutamiseks või muutmiseks."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Lubab rakendusel muuta telefoni kõnelogi, sh sissetulevate ja väljaminevate kõnede andmeid. Pahatahtlikud rakendused võivad kasutada seda kõnelogi kustutamiseks või muutmiseks."</string>
    <string name="permlab_bodySensors" msgid="4871091374767171066">"kehaandurid (nt pulsilugeja)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="4380015021754180431">"Lubab rakendusel hankida juurdepääsu andmetele anduritest, mis jälgivad teie füüsilist seisundit, nt südame löögisagedust."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"kalendrisündmuste lugemine ja konfidentsiaalne teave"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Võimaldab rakendusel lugeda kõiki tahvelarvutisse salvestatud kalendrisündmusi, sh sõprade või töökaaslaste omi. See võib lubada rakendusel jagada või salvestada teie kalendriandmeid, hoolimata konfidentsiaalsusest või tundlikkusest."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="3191352452242394196">"Lubab rakendusel lugeda telerisse salvestatud kalendrisündmusi, sh sõprade ja töökaaslaste sündmusi. See võib võimaldada rakendusel kalendriandmeid jagada või salvestada, olenemata nende konfidentsiaalsusest või tundlikkusest."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Võimaldab rakendusel lugeda kõiki telefoni salvestatud kalendrisündmusi, sh sõprade või töökaaslaste omi. See võib lubada rakendusel jagada või salvestada teie kalendriandmeid, hoolimata konfidentsiaalsusest või tundlikkusest."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"kalendrisündmuste lisamine või muutmine ja külalistele omanike teadmata meili saatmine"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Võimaldab rakendusel lisada, eemaldada ja muuta sündmusi, mida saate muuta oma tahvelarvutis, sh sõprade ja töökaaslaste omi. See võib võimaldada rakendusel saata sõnumeid, mis näivad tulevat kalendri omanikelt, või muuta sündmusi omaniku teadmata."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="1273290605500902507">"Lubab rakendusel lisada, kustutada ja muuta sündmusi, mida saate teleris muuta, sealhulgas sõprade ja töökaaslaste omi. See lubab rakendusel saata sõnumeid, mis pärinevad näiliselt kalendrite omanikelt, või muuta sündmusi omanike teadmata."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Võimaldab rakendusel lisada, eemaldada ja muuta sündmusi, mida saate muuta oma telefonis, sh sõprade ja töökaaslaste omi. See võib võimaldada rakendusel saata sõnumeid, mis näivad tulevat kalendri omanikelt, või muuta sündmusi omaniku teadmata."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"juurdepääs asukohapakkuja lisakäskudele"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="6078307221056649927">"Võimaldab rakendusel juurde pääseda asukohapakkuja erikäskudele. See võib lubada rakendusel mõjutada GPS-i või muude asukohaallikate tööd."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"täpne asukoht (GPS- ja võrgupõhine)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Lubab rakendusel hankida teie täpse asukoha globaalse positsioneerimissüsteemi (GPS) või võrgu asukohaallikate (nt mobiilimastide ja WiFi) järgi. Need asukohateenused peavad olema sisse lülitatud ja teie seadme jaoks saadaval, et rakendus saaks neid kasutada. Rakendused võivad kasutada seda teie asukoha tuvastamiseks ja tarbida akut."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"ligikaudne asukoht (võrgupõhine)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Lubab rakendusel hankida juurdepääsu ligikaudsele asukohale. Asukoht tuletatakse asukohateenuste järgi, kasutades võrgu asukohaallikaid, nt mobiilimastid ja WiFi. Need asukohateenused peavad olema sisse lülitatud ja teie seadme jaoks saadaval, et rakendus saaks neid kasutada. Rakendused võivad kasutada seda teie ligikaudse asukoha tuvastamiseks."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"muuda heliseadeid"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Võimaldab rakendusel muuta üldiseid heliseadeid, näiteks helitugevust ja seda, millist kõlarit kasutatakse väljundiks."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"salvesta heli"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Võimaldab rakendusel salvestada mikrofoniga heli. See luba võimaldab rakendusel salvestada heli igal ajal ilma teie kinnituseta."</string>
    <string name="permlab_sim_communication" msgid="1180265879464893029">"side SIM-kaardiga"</string>
    <string name="permdesc_sim_communication" msgid="5725159654279639498">"Lubab rakendusel saata käske SIM-kaardile. See on väga ohtlik."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"piltide ja videote tegemine"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Võimaldab rakendusel teha kaameraga pilte ja videoid. See luba võimaldab rakendusel kasutada kaamerat mis tahes ajal teie kinnituseta."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"juhtige vibreerimist"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Võimaldab rakendusel juhtida vibreerimist."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"juhi taskulampi"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Võimaldab rakendusel juhtida taskulampi."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"helista otse telefoninumbritele"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Võimaldab rakendusel teie sekkumiseta telefoninumbritele helistada. See võib põhjustada ootamatuid tasusid või telefonikõnesid. Pange tähele, et see ei luba rakendusel helistada hädaabinumbritele. Pahatahtlikud rakendused võivad teile kulusid tekitada, tehes telefonikõnesid teie kinnituseta."</string>
    <!-- no translation found for permlab_accessImsCallService (3574943847181793918) -->
    <skip />
    <!-- no translation found for permdesc_accessImsCallService (8992884015198298775) -->
    <skip />
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"lugege telefoni olekut ja identiteeti"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Annab rakendusele juurdepääsu seadme telefonifunktsioonidele. See luba võimaldab rakendusel määrata telefoninumbri ja seadme ID-d ning kontrollida, kas kõne on aktiivne ja kaugnumber on kõne kaudu telefoniga ühendatud."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"tahvelarvuti uinumise vältimine"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2601193288949154131">"teleri unerežiimi lülitumise takistamine"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"väldi telefoni uinumist"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Võimaldab rakendusel vältida tahvelarvuti uinumist."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="3208534859208996974">"Lubab rakendusel takistada teleri unerežiimi lülitumist."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Võimaldab rakendusel vältida telefoni uinumist."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"infrapunaedastus"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Lubab rakendusel kasutada tahvelarvuti infrapunasaatjat."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3926790828514867101">"Lubab rakendusel kasutada teleri infrapunasaatjat."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Lubab rakendusel kasutada telefoni infrapunasaatjat."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"määra taustapilt"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Võimaldab rakendusel määrata süsteemi taustapildi."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"korrigeerige oma taustapildi suurust"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Võimaldab rakendusel määrata süsteemi taustapildi suuruse vihjeid."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"määra ajavöönd"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Võimaldab rakendusel muuta tahvelarvuti ajavööndit."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="888864653946175955">"Lubab rakendusel muuta teleri ajavööndit."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Võimaldab rakendusel muuta telefoni ajavööndit."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"leidke seadmest kontod"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Võimaldab rakendusel hankida tahvelarvutile teadaolevaid kontoloendeid. See võib hõlmata mis tahes kontosid, mille on loonud teie installitud rakendused."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="4190633395633907543">"Lubab rakendusel hankida telerile teadaolevate kontode loendi. See võib sisaldada kõiki installitud rakenduste loodud kontosid."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Võimaldab rakendusel hankida telefonile teadaolevaid kontoloendeid. See võib hõlmata mis tahes kontosid, mille on loonud teie installitud rakendused."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"vaadake võrguühendusi"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Lubab rakendusel vaadata teavet võrguühenduste kohta, näiteks seda, millised võrgud on olemas ja ühendatud."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"täielik juurdepääs võrgule"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Võimaldab rakendusel luua võrgupesasid ja kasutada kohandatud võrguprotokolle. Brauser ja teised rakendused annavad vahendid andmete saatmiseks Internetti, nii et seda luba ei ole vaja andmete saatmiseks Internetti."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"muuda võrguühenduvust"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Võimaldab rakendusel muuta võrguühenduvuse olekut."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"Jagatud ühenduvuse muutmine"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Võimaldab rakendusel muuta jagatud võrgu ühenduvuse olekut."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"vaadake WiFi-ühendusi"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Võimaldab rakendusel vaadata teavet WiFi-võrgu kohta, näiteks ühendatud WiFi-seadmete nimesid ja seda, kas WiFi on lubatud."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"ühendage ja katkestage ühendus WiFi-ga"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Võimaldab rakendusel luua ja katkestada ühenduse WiFi-pääsupunktidega ning teha muudatusi seadme konfiguratsioonis WiFi-võrkudesse."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"luba WiFi multiedastusvastuvõtt"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Võimaldab rakendusel vastu võtta pakette, mis on saadetud kõikidele WiFi-võrguga ühendatud seadmetele, mis kasutavad multiedastuse aadresse, mitte ainult teie tahvelarvutit. See võtab rohkem energiat kui mittemultiedastuse režiim."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="9031975661145014160">"Lubab rakendusel võtta vastu pakette, mis on multiülekande aadresside abil saadetud WiFi-võrgu kõikidele seadmetele, mitte ainult teie telerile. Kasutab rohkem toidet kui mitte-multiülekande režiim."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Võimaldab rakendusel vastu võtta pakette, mis on saadetud kõikidele WiFi-võrguga ühendatud seadmetele, mis kasutavad multiedastuse aadresse, mitte ainult teie telefoni. See võtab rohkem energiat kui mittemultiedastuse režiim."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"juurdepääs Bluetoothi ​​seadetele"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Võimaldab rakendusel seadistada kohalikku Bluetooth-tahvelarvutit ning leida ja siduda seda kaugseadmetega."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="3373125682645601429">"Lubab rakendusel seadistada kohalikku Bluetoothi telerit ning avastada kaugseadmeid ja siduda nendega."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Võimaldab rakendusel seadistada kohalikku Bluetooth-telefoni ning leida ja siduda seda kaugseadmetega."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"WiMAX-iga ühenduse loomine ja ühenduse katkestamine"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Võimaldab rakendusel määrata, kas WiMAX on lubatud, ja vaadata teavet kõikide ühendatud WiMAX-võrkude kohta."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"WiMAX-i oleku muutmine"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Võimaldab rakendusel luua ja katkestada tahvelarvuti ühenduse WiMAX-i võrkudega."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="6022307083934827718">"Lubab rakendusel ühendada teleri WiMAX-i võrku ja ühenduse katkestada."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Võimaldab rakendusel luua ja katkestada telefoni ühenduse WiMAX-i võrkudega."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"siduge Bluetoothi seadmetega"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Võimaldab rakendusel vaadata tahvelarvuti Bluetooth-konfiguratsiooni ning luua ja heaks kiita ühendusi seotud seadmetega."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="3974124940101104206">"Lubab rakendusel näha teleri Bluetoothi seadistust ning luua ja aktsepteerida seotud seadmete ühendusi."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Võimaldab rakendusel vaadata telefoni Bluetooth-konfiguratsiooni ning luua ja heaks kiita ühendusi seotud seadmetega."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"lähiväljaside juhtimine"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Võimaldab rakendusel suhelda lähiväljaside (NFC) märgendite, kaartide ja lugeritega."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"keelake ekraanilukk"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Võimaldab rakendusel keelata klahviluku ja muu seotud parooli turvalisuse. Näiteks keelab telefon klahviluku sissetuleva kõne vastuvõtmisel ja lubab klahviluku uuesti, kui kõne on lõpetatud."</string>
    <string name="permlab_manageFingerprint" msgid="5640858826254575638">"sõrmejälje riistvara haldamine"</string>
    <string name="permdesc_manageFingerprint" msgid="178208705828055464">"Võimaldab rakendusel tühistada meetodid kasutatavate sõrmejäljemallide lisamiseks ja kustutamiseks."</string>
    <string name="permlab_useFingerprint" msgid="3150478619915124905">"sõrmejälje riistvara kasutamine"</string>
    <string name="permdesc_useFingerprint" msgid="9165097460730684114">"Võimaldab rakendusel autentimiseks kasutada sõrmejälje riistvara"</string>
    <string name="fingerprint_acquired_partial" msgid="735082772341716043">"Tuvastati osaline sõrmejälg. Proovige uuesti."</string>
    <string name="fingerprint_acquired_insufficient" msgid="4596546021310923214">"Sõrmejälge ei õnnestunud töödelda. Proovige uuesti."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="1087209702421076105">"Sõrmejäljeandur on must. Puhastage see ja proovige uuesti."</string>
    <string name="fingerprint_acquired_too_fast" msgid="6470642383109155969">"Sõrm liikus liiga kiiresti. Proovige uuesti."</string>
    <string name="fingerprint_acquired_too_slow" msgid="59250885689661653">"Sõrm liikus liiga aeglaselt. Proovige uuesti."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_error_hw_not_available" msgid="7955921658939936596">"Sõrmejälje riistvara pole saadaval."</string>
    <string name="fingerprint_error_no_space" msgid="1055819001126053318">"Sõrmejälge ei saa salvestada. Eemaldage olemasolev sõrmejälg."</string>
    <string name="fingerprint_error_timeout" msgid="3927186043737732875">"Sõrmejälje riistvara taimeri ajalõpp. Proovige uuesti."</string>
    <string name="fingerprint_error_canceled" msgid="4402024612660774395">"Sõrmejälje toiming tühistati."</string>
    <string name="fingerprint_error_lockout" msgid="5536934748136933450">"Liiga palju katseid. Proovige hiljem uuesti."</string>
    <string name="fingerprint_error_unable_to_process" msgid="6107816084103552441">"Proovige uuesti."</string>
    <string name="fingerprint_name_template" msgid="5870957565512716938">"Sõrm <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"loe sünkroonimisseadeid"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Võimaldab rakendusel lugeda konto sünkroonimisseadeid. Näiteks võib see määrata, kas rakendus Inimesed on kontoga sünkroonitud."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"lülitage sünkroonimine sisse ja välja"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Võimaldab rakendusel muuta konto sünkroonimisseadeid. Näiteks saab seda kasutada, et lubada rakenduse Inimesed sünkroonimine kontoga."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"loe sünkroonimisstatistikat"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Võimaldab rakendusel lugeda konto sünkroonimisstatistikat, sh sünkroonimissündmuste ajalugu ja sünkroonitud andmete hulka."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"lugege USB-salvestusruumi sisu"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"lugege oma SD-kaardi sisu"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"Lubab rakendusel lugeda USB-salvestusruumi sisu."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"Lubab rakendusel lugeda SD-kaardi sisu."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"muutke, kustut. USB-ruumi sisu"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"SD-kaardi sisu muutmine või kustutamine"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Võimaldab rakendusel kirjutada USB-mäluseadmele."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Võimaldab rakendusel kirjutada SD-kaardile."</string>
    <string name="permlab_use_sip" msgid="2052499390128979920">"SIP-kõnede tegemine/vastuvõtmine"</string>
    <string name="permdesc_use_sip" msgid="2297804849860225257">"Lubab rakendusel teha ja vastu võtta SIP-kõnesid."</string>
    <string name="permlab_register_sim_subscription" msgid="3166535485877549177">"uute telekommunikatsiooni SIM-kaardi ühenduste registreerimine"</string>
    <string name="permdesc_register_sim_subscription" msgid="2138909035926222911">"Lubab rakendusel registreerida uusi telekommunikatsiooni SIM-kaartide ühendusi."</string>
    <string name="permlab_register_call_provider" msgid="108102120289029841">"uute telekommunikatsiooni ühenduste registreerimine"</string>
    <string name="permdesc_register_call_provider" msgid="7034310263521081388">"Lubab rakendusel registreerida uusi telekommunikatsiooni ühendusi."</string>
    <string name="permlab_connection_manager" msgid="1116193254522105375">"telekommunikatsiooni ühenduste haldamine"</string>
    <string name="permdesc_connection_manager" msgid="5925480810356483565">"Lubab rakendusel hallata telekommunikatsiooni ühendusi."</string>
    <string name="permlab_bind_incall_service" msgid="6773648341975287125">"ekraani Kõne pooleli kasutamine"</string>
    <string name="permdesc_bind_incall_service" msgid="8343471381323215005">"Lubab rakendusel juhtida, millal ja kuidas kasutajale kuvatakse ekraan Kõne pooleli."</string>
    <string name="permlab_bind_connection_service" msgid="3557341439297014940">"telefoniteenustega suhtlemine"</string>
    <string name="permdesc_bind_connection_service" msgid="4008754499822478114">"Võimaldab rakendusel telefoniteenustega kõnede tegemiseks ja vastuvõtmiseks suhelda."</string>
    <string name="permlab_control_incall_experience" msgid="9061024437607777619">"funktsiooni Kõne pooleli kasutuskogemuse pakkumine"</string>
    <string name="permdesc_control_incall_experience" msgid="915159066039828124">"Lubab rakendusel pakkuda kasutuskogemust funktsiooni Kõne pooleli kasutamisel."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"võrgukasutuse ajaloo lugemine"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Võimaldab rakendusel lugeda võrgukasutuse ajalugu teatud võrkude ja rakenduste puhul."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"võrgueeskirjade haldamine"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Võimaldab rakendusel hallata võrgueeskirju ja määratleda rakendusespetsiifilisi reegleid."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"võrgukasutuse arvestamise muutmine"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Võimaldab rakendusel muuta võrgukasutuse loendamist rakenduste suhtes. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"juurdepääsu märguanded"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Võimaldab rakendusel tuua, kontrollida ja kustutada märguandeid, sh neid, mille on postitanud teised rakendused."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"seo märguannete kuulamisteenusega"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Võimaldab omanikul siduda märguannete kuulamisteenuse ülemise taseme kasutajaliidese. Seda ei tohiks tavarakenduste puhul kunagi vaja olla."</string>
    <string name="permlab_bindConditionProviderService" msgid="1180107672332704641">"seo tingimuse pakkuja teenusega"</string>
    <string name="permdesc_bindConditionProviderService" msgid="1680513931165058425">"Lubab omanikul siduda tingimuse pakkuja teenuse ülataseme liidesega. Pole kunagi vajalik tavaliste rakenduste puhul."</string>
    <string name="permlab_bindDreamService" msgid="4153646965978563462">"sidumine uneteenusega"</string>
    <string name="permdesc_bindDreamService" msgid="7325825272223347863">"Lubab omanikul siduda uneteenuse ülataseme liidesega. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"operaatoripoolse konfiguratsioonirakenduse aktiveerimine"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Lubab omanikul aktiveerida operaatoripoolse konfiguratsioonirakenduse. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"võrgutingimuste teabe kuulamine"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Lubab rakendusel kuulata võrgutingimuste teavet. Ei ole kunagi vajalik tavaliste rakenduste puhul."</string>
    <string name="permlab_setInputCalibration" msgid="4902620118878467615">"sisendseadme kalibreerimise muutmine"</string>
    <string name="permdesc_setInputCalibration" msgid="4527511047549456929">"Lubab rakendusel muuta puuteekraani kalibreerimisparameetreid. Ei tohiks kunagi olla vajalik tavaliste rakenduste puhul."</string>
    <string name="permlab_accessDrmCertificates" msgid="7436886640723203615">"juurdepääs DRM-i sertifikaatidele"</string>
    <string name="permdesc_accessDrmCertificates" msgid="8073288354426159089">"Lubab rakendusel ette valmistada ja kasutada DRM-i sertifikaate. Tavarakenduste puhul ei tohiks see vajalik olla."</string>
    <string name="permlab_handoverStatus" msgid="1159132046126626731">"Android Beami ülekande oleku vastuvõtmine"</string>
    <string name="permdesc_handoverStatus" msgid="4788144087245714948">"Lubab rakendusel saada teavet praeguste Android Beami ülekannete kohta"</string>
    <string name="permlab_removeDrmCertificates" msgid="7044888287209892751">"DRM-sertifikaatide eemaldamine"</string>
    <string name="permdesc_removeDrmCertificates" msgid="7272999075113400993">"Lubab rakendusel eemaldada DRM-sertifikaate. Pole kunagi vajalik tavaliste rakenduste puhul."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="1490229371796969158">"seose loomine operaatori sõnumisideteenusega"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="2762882888502113944">"Lubab omanikul luua seose operaatori sõnumisideteenuse ülataseme liidesega. Pole kunagi vajalik tavalise rakenduse puhul."</string>
    <string name="permlab_bindCarrierServices" msgid="3233108656245526783">"sidumine operaatoriteenustega"</string>
    <string name="permdesc_bindCarrierServices" msgid="1391552602551084192">"Lubab omanikul siduda operaatoriteenustega. Seda ei tohiks tavarakenduste puhul kunagi tarvis minna."</string>
    <string name="permlab_access_notification_policy" msgid="4247510821662059671">"juurdepääs funktsioonile Mitte segada"</string>
    <string name="permdesc_access_notification_policy" msgid="3296832375218749580">"Võimaldab rakendusel lugeda ja kirjutada funktsiooni Mitte segada seadistusi."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Parooli reeglite määramine"</string>
    <string name="policydesc_limitPassword" msgid="2502021457917874968">"Juhitakse ekraaniluku paroolide ja PIN-koodide pikkusi ning lubatud tähemärkide seadeid."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Ekraani avamiskatsed"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Jälgib ekraani avamisel valesti sisestatud paroolide arvu ja lukustab tahvelarvuti või kustutab kõik selle andmed, kui vale parool sisestatakse liiga palju kordi."</string>
    <string name="policydesc_watchLogin" product="TV" msgid="2707817988309890256">"Ekraani avamiseks valesti sisestatud paroolide arvu jälgimine ja teleri lukustamine või teleri andmete kustutamine, kui parool sisestatakse liiga mitu korda valesti."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Jälgib ekraani avamisel valesti sisestatud paroolide arvu ja lukustab telefoni või kustutab kõik selle andmed, kui vale parool sisestatakse liiga palju kordi."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="4280246270601044505">"Jälgitakse ekraani avamisel sisestatud valede paroolide arvu ja lukustatakse tahvelarvuti või kustutatakse kõik selle kasutaja andmed, kui vale parool sisestatakse liiga palju kordi."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="TV" msgid="3484832653564483250">"Jälgitakse ekraani avamisel sisestatud valede paroolide arvu ja lukustatakse teler või kustutatakse kõik selle kasutaja andmed, kui vale parool sisestatakse liiga palju kordi."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="2185480427217127147">"Jälgitakse ekraani avamisel sisestatud valede paroolide arvu ja lukustatakse telefon või kustutatakse kõik selle kasutaja andmed, kui vale parool sisestatakse liiga palju kordi."</string>
    <string name="policylab_resetPassword" msgid="4934707632423915395">"Ekraaniluku muutmine"</string>
    <string name="policydesc_resetPassword" msgid="1278323891710619128">"Muudetakse ekraanilukku."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Ekraani lukustamine"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Määrake, kuidas ja millal ekraan lukustub."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Kõikide andmete kustutamine"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Kustutage tahvelarvuti andmed hoiatamata, lähtestades arvuti tehaseandmetele."</string>
    <string name="policydesc_wipeData" product="tv" msgid="5816221315214527028">"Teleri andmete hoiatamata kustutamine tehase andmetele lähtestamise abil."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Kustuta telefoniandmed hoiatuseta, lähtestades telefoni tehaseandmetele."</string>
    <string name="policylab_wipeData_secondaryUser" msgid="8362863289455531813">"Kasutaja andmete kustutamine"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="6336255514635308054">"Kustutatakse selle kasutaja andmed sellest tahvelarvutist ilma hoiatamata."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2086473496848351810">"Kustutatakse selle kasutaja andmed sellest telerist ilma hoiatamata."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="6787904546711590238">"Kustutatakse selle kasutaja andmed sellest telefonist ilma hoiatamata."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Määra seadme globaalne puhverserver"</string>
    <string name="policydesc_setGlobalProxy" msgid="8459859731153370499">"Määratakse kasutatava seadme üldine puhverserver, kui reegel on lubatud. Üldise puhverserveri saab määrata ainult seadme omanik."</string>
    <string name="policylab_expirePassword" msgid="5610055012328825874">"Ekraaniluku parooli aegum. määram."</string>
    <string name="policydesc_expirePassword" msgid="5367525762204416046">"Muudetakse ekraaniluku parooli, PIN-koodi või mustri kohustusliku muutmise sagedust."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Salvestamise krüpt. määramine"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Nõua salvestatud rakenduse andmete krüpteerimist."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Keela kaamerad"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Vältige seadme kõigi kaamerate kasutamist."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="8552277871075367771">"Ekraaniluku mõne funktsiooni keelamine"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="2044755691354158439">"Takistatakse ekraaniluku mõne funktsiooni kasutamist."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Kodu"</item>
    <item msgid="869923650527136615">"Mobiil"</item>
    <item msgid="7897544654242874543">"Töö"</item>
    <item msgid="1103601433382158155">"Tööfaks"</item>
    <item msgid="1735177144948329370">"Kodufaks"</item>
    <item msgid="603878674477207394">"Piipar"</item>
    <item msgid="1650824275177931637">"Muu"</item>
    <item msgid="9192514806975898961">"Kohandatud"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Kodu"</item>
    <item msgid="7084237356602625604">"Töö"</item>
    <item msgid="1112044410659011023">"Muu"</item>
    <item msgid="2374913952870110618">"Kohandatud"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Kodu"</item>
    <item msgid="5629153956045109251">"Töö"</item>
    <item msgid="4966604264500343469">"Muu"</item>
    <item msgid="4932682847595299369">"Kohandatud"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Kodu"</item>
    <item msgid="1359644565647383708">"Töö"</item>
    <item msgid="7868549401053615677">"Muu"</item>
    <item msgid="3145118944639869809">"Kohandatud"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Töö"</item>
    <item msgid="4378074129049520373">"Muu"</item>
    <item msgid="3455047468583965104">"Kohandatud"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Kohandatud"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Kodune telefon"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobiil"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Töökoha telefon"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Töökoha faksinumber"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Kodune faksinumber"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Piipar"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Muu"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Tagasihelistus"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Auto"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Ettevõtte üldtelefon"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Peamine"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Teine faks"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Raadiotelefon"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Teleksinumber"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Töökoha mobiiltelefon"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Töökoha piipar"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Assistent"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Kohandatud"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Sünnipäev"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Aastapäev"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Muu"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Kohandatud"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Kodune e-post"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Töökoha e-post"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Muu"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobiil"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Kohandatud"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Kodune aadress"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Töökoha aadress"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Muu"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Kohandatud"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Kodune IM-aadress"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Töökoha IM-aadress"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Muu"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Kohandatud"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Töö"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Muu"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Kohandatud"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Kohandatud"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Assistent"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Vend"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Laps"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Elukaaslane"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Isa"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Sõber"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Haldur"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Ema"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Vanem"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Viitas:"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Sugulane"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Õde"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Abikaasa"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Kohandatud"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Kodu"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Töö"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Muu"</string>
    <string name="quick_contacts_not_available" msgid="746098007828579688">"Selle kontakti kuvamiseks ei leitud ühtegi rakendust."</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Sisestage PIN-kood"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Sisestage PUK-kood ja uus PIN-kood"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK-kood"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Uus PIN-kood"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Puudutage parooli sisestamiseks"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Avamiseks sisestage parool"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Avamiseks sisestage PIN-kood"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Vale PIN-kood."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Avamiseks vajutage menüüklahvi, seejärel klahvi 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Hädaabinumber"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Teenus puudub."</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Ekraan lukus."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Vajutage avamiseks või hädaabikõne tegemiseks menüünuppu"</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Vajutage avamiseks menüüklahvi."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Avamiseks joonistage muster"</string>
    <string name="lockscreen_emergency_call" msgid="5298642613417801888">"Hädaabi"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Kõne juurde tagasi"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Õige."</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Proovige uuesti"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Proovige uuesti"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Maksimaalne teenusega Face Unlock avamise katsete arv on ületatud"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"SIM-kaarti pole"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Tahvelarvutis pole SIM-kaarti."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="1943633865476989599">"Teleris pole SIM-kaarti."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Telefonis pole SIM-kaarti."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Sisestage SIM-kaart."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"SIM-kaart puudub või on loetamatu. Sisestage SIM-kaart."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Kasutamiskõlbmatu SIM-kaart."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"SIM-kaart on jäädavalt keelatud.\n Teise SIM-kaardi saamiseks võtke ühendust oma traadita side teenusepakkujaga."</string>
    <string name="lockscreen_transport_prev_description" msgid="6300840251218161534">"Eelmine lugu"</string>
    <string name="lockscreen_transport_next_description" msgid="573285210424377338">"Järgmine lugu"</string>
    <string name="lockscreen_transport_pause_description" msgid="3980308465056173363">"Peata"</string>
    <string name="lockscreen_transport_play_description" msgid="1901258823643886401">"Esita"</string>
    <string name="lockscreen_transport_stop_description" msgid="5907083260651210034">"Peata"</string>
    <string name="lockscreen_transport_rew_description" msgid="6944412838651990410">"Keri tagasi"</string>
    <string name="lockscreen_transport_ffw_description" msgid="42987149870928985">"Keri edasi"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Ainult hädaabikõned"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Võrk suletud"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM-kaart on PUK-lukus."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Vaadake kasutusjuhendit või võtke ühendust klienditeenindusega."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM-kaart on lukus."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"SIM-kaardi avamine ..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"Olete oma avamismustrit <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti koostanud. \n\nProovige <xliff:g id="NUMBER_1">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Olete parooli <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti sisestanud. \n\nProovige <xliff:g id="NUMBER_1">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"Olete PIN-koodi <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti sisestanud. \n\nProovige <xliff:g id="NUMBER_1">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Joonistasite oma avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset palutakse teil tahvelarvuti avada Google\'i sisselogimisega.\n\n Proovige <xliff:g id="NUMBER_2">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="5316664559603394684">"Olete avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti joonistanud. Kui joonistate mustri veel <xliff:g id="NUMBER_1">%d</xliff:g> korda valesti, palutakse teil avada teler Google\'i sisselogimisandmete abil.\n\n Proovige uuesti <xliff:g id="NUMBER_2">%d</xliff:g> sekundi pärast."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Joonistasite oma avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset palutakse teil telefon avada Google\'i sisselogimisega.\n\n Proovige <xliff:g id="NUMBER_2">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Olete üritanud <xliff:g id="NUMBER_0">%d</xliff:g> korda tahvelarvutit valesti avada. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> edutut katset lähtestatakse tahvelarvuti tehase vaikeseadetele ja kõik kasutajaandmed lähevad kaotsi."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="950408382418270260">"Teleri avamine on <xliff:g id="NUMBER_0">%d</xliff:g> korda ebaõnnestunud. Kui veel <xliff:g id="NUMBER_1">%d</xliff:g> katset ebaõnnestub, lähtestatakse teler tehaseseadetele ja kasutajaandmed lähevad kaotsi."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Olete üritanud <xliff:g id="NUMBER_0">%d</xliff:g> korda telefoni valesti avada. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset lähtestatakse telefon tehase vaikeseadetele ja kõik kasutajaandmed lähevad kaotsi."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Olete püüdnud tahvelarvutit <xliff:g id="NUMBER">%d</xliff:g> korda valesti avada. Tahvelarvuti lähtestatakse nüüd tehase vaikeseadetele."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="3195755534096192191">"Teleri avamine on <xliff:g id="NUMBER">%d</xliff:g> korda ebaõnnestunud. Teler lähtestatakse tehaseseadetele."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Olete püüdnud telefoni <xliff:g id="NUMBER">%d</xliff:g> korda valesti avada. Telefon lähtestatakse nüüd tehase vaikeseadetele."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Proovige uuesti <xliff:g id="NUMBER">%d</xliff:g> sekundi pärast."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Kas unustasite mustri?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Konto avamine"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Liiga palju mustrikatseid"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Avamiseks logige sisse oma Google\'i kontoga."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Kasutajanimi (e-post)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Parool"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Logi sisse"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Vale kasutajanimi või parool."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Kas unustasite oma kasutajanime või parooli?\nKülastage aadressi "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Kontrollimine ..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Ava"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Heli sisse"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Heli välja"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Mustri koostamisega on alustatud"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Muster on kustutatud"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Lahter on lisatud"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="7264580781744026939">"Lisati lahter <xliff:g id="CELL_INDEX">%1$s</xliff:g>"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Muster on valmis"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Vidin %2$d/%3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Vidina lisamine."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Tühi"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Avamisala on laiendatud."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Avamisala on ahendatud."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Vidin <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Kasutaja valija"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Olek"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Kaamera"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Meedia juhtnupud"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Vidina ümberkorraldamine algas."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Vidina ümberkorraldamine lõppes."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Vidin <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> on kustutatud."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Avamisala laiendamine."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Lohistamisega avamine."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Mustriga avamine."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Näoga avamine."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"PIN-koodiga avamine."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Parooliga avamine."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Mustri ala."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Lohistamisala."</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"tähemärk"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"sõna"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"link"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"rida"</string>
    <string name="hour_ampm" msgid="4584338083529355982">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="2083465992940444366">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%p</xliff:g>"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Tehasetest ebaõnnestus"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Toimingut FACTORY_TEST toetatakse ainult kausta \\system\\app installitud pakettide puhul."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Ei leitud ühtegi paketti, mis võimaldaks toimingut FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Taaskäivita"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Leht  „<xliff:g id="TITLE">%s</xliff:g>” ütleb järgmist."</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Navigeerimise kinnitamine"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Lahku sellelt lehelt"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Jää sellele lehele"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nKas soovite kindlasti sellelt lehelt lahkuda?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Kinnita"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Vihje: suurendamiseks ja vähendamiseks puudutage kaks korda."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Automaatne täitmine"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Automaatse täitmise seadistamine"</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Provints"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Sihtnumber"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Olek"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Sihtnumber"</string>
    <string name="autofill_county" msgid="237073771020362891">"Maakond"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Saar"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Piirkond"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Osakond"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektuur"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Vald"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Piirkond"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emiraat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"lugege oma veebijärjehoidjaid ja -ajalugu"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Võimaldab rakendusel lugeda kõikide URL-ide ajalugu, mida brauser on külastanud, ja kõiki brauseri järjehoidjaid. Märkus: see luba ei pruugi jõustuda kolmanda osapoole brauseritega või teiste veebisirvimisvõimega rakendustega."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"kirjutage veebijärjehoidjaid ja -ajalugu"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Võimaldab rakendusel muuta tahvelarvutisse salvestatud brauseri ajalugu või järjehoidjaid. See võimaldab rakendusel kustutada või muuta brauseri andmeid. Märkus: see luba ei pruugi jõustuda kolmanda osapoole brauserites või teistes veebisirvimisvõimega rakendustes."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="7007393823197766548">"Lubab rakendusel muuta telerisse salvestatud brauseri ajalugu või järjehoidjaid. See võib lubada rakendusel brauseri andmeid kustutada või muuta. Märkus: seda luba ei või jõustada kolmanda osapoole brauserid või muud veebisirvimise võimalustega rakendused."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Võimaldab rakendusel muuta telefoni salvestatud brauseri ajalugu või järjehoidjaid. See võimaldab rakendusel kustutada või muuta brauseri andmeid. Märkus: see luba ei pruugi jõustuda kolmanda osapoole brauserites või teistes veebisirvimisvõimega rakendustes."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"määrake äratus"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Võimaldab rakendusel seada installitud äratuskellarakenduses äratuse. Mõned äratuskellarakendused ei pruugi seda funktsiooni juurutada."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"lisa kõneposti"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Võimaldab rakendusel lisada sõnumeid teie kõneposti postkasti."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"Brauseri geolokatsiooniõiguste muutmine"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Võimaldab rakendusel muuta brauseri geolokatsiooniõigusi. Pahatahtlikud rakendused võivad seda kasutada asukohateabe saatmise lubamiseks suvalistele veebisaitidele."</string>
    <string name="save_password_message" msgid="767344687139195790">"Kas soovite, et brauser jätaks selle parooli meelde?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Mitte praegu"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Pidage meeles"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Mitte kunagi"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Teil pole luba selle lehe avamiseks."</string>
    <string name="text_copied" msgid="4985729524670131385">"Lõikelauale kopeeritud tekst."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Rohkem"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menüü+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"tühik"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"sisestusklahv"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"kustuta"</string>
    <string name="search_go" msgid="8298016669822141719">"Otsing"</string>
    <string name="search_hint" msgid="1733947260773056054">"Otsimine …"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Otsing"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Otsingupäring"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Tühjenda päring"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Päringu esitamine"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Häälotsing"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Kas lubada puudutusega uurimine?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> soovib lubada puudutusega uurimise. Kui puudutusega uurimine on sisse lülitatud, kuulete või näete kirjeldusi asjade kohta, mis on teie sõrme all, või saate suhelda tahvelarvutiga liigutuste abil."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> soovib lubada puudutusega uurimise. Kui puudutusega uurimine on sisse lülitatud, kuulete või näete kirjeldusi asjade kohta, mis on teie sõrme all, või saate suhelda telefoniga liigutuste abil."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"1 kuu tagasi"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Varem kui 1 kuu tagasi"</string>
    <plurals name="last_num_days" formatted="false" msgid="5104533550723932025">
      <item quantity="other">Viimased <xliff:g id="COUNT_1">%d</xliff:g> päeva</item>
      <item quantity="one">Viimane <xliff:g id="COUNT_0">%d</xliff:g> päev</item>
    </plurals>
    <string name="last_month" msgid="3959346739979055432">"Eelmisel kuul"</string>
    <string name="older" msgid="5211975022815554840">"Vanem"</string>
    <string name="preposition_for_date" msgid="9093949757757445117">"kuupäeval <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"kell <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"aastal <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8144195776058119424">"päev"</string>
    <string name="days" msgid="4774547661021344602">"päeva"</string>
    <string name="hour" msgid="2126771916426189481">"tund"</string>
    <string name="hours" msgid="894424005266852993">"tundi"</string>
    <string name="minute" msgid="9148878657703769868">"min"</string>
    <string name="minutes" msgid="5646001005827034509">"min"</string>
    <string name="second" msgid="3184235808021478">"s"</string>
    <string name="seconds" msgid="3161515347216589235">"s"</string>
    <string name="week" msgid="5617961537173061583">"nädal"</string>
    <string name="weeks" msgid="6509623834583944518">"nädalat"</string>
    <string name="year" msgid="4001118221013892076">"aasta"</string>
    <string name="years" msgid="6881577717993213522">"aastat"</string>
    <plurals name="duration_seconds" formatted="false" msgid="4527986939729687805">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundit</item>
      <item quantity="one">1 sekund</item>
    </plurals>
    <plurals name="duration_minutes" formatted="false" msgid="643786953939956125">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutit</item>
      <item quantity="one">1 minut</item>
    </plurals>
    <plurals name="duration_hours" formatted="false" msgid="6826233369186668274">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> tundi</item>
      <item quantity="one">1 tund</item>
    </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Probleem videoga"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"See video ei sobi voogesituseks selles seadmes."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Videot ei saa esitada."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"OK"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"keskpäev"</string>
    <string name="Noon" msgid="3342127745230013127">"Keskpäev"</string>
    <string name="midnight" msgid="7166259508850457595">"kesköö"</string>
    <string name="Midnight" msgid="5630806906897892201">"Kesköö"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Vali kõik"</string>
    <string name="cut" msgid="3092569408438626261">"Lõika"</string>
    <string name="copy" msgid="2681946229533511987">"Kopeeri"</string>
    <string name="paste" msgid="5629880836805036433">"Kleebi"</string>
    <string name="replace" msgid="5781686059063148930">"Asenda..."</string>
    <string name="delete" msgid="6098684844021697789">"Kustuta"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopeeri URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Valige tekst"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Teksti valimine"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Lisa sõnastikku"</string>
    <string name="deleteText" msgid="6979668428458199034">"Kustuta"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Sisestusmeetod"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Tekstitoimingud"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Talletusruum saab täis"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Mõned süsteemifunktsioonid ei pruugi töötada"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="6935190099204693424">"Süsteemis pole piisavalt talletusruumi. Veenduge, et seadmes oleks 250 MB vaba ruumi, ja käivitage seade uuesti."</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"<xliff:g id="APP_NAME">%1$s</xliff:g> töötab"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Puudutage lisateabe saamiseks või rakenduse peatamiseks."</string>
    <string name="ok" msgid="5970060430562524910">"OK"</string>
    <string name="cancel" msgid="6442560571259935130">"Tühista"</string>
    <string name="yes" msgid="5362982303337969312">"OK"</string>
    <string name="no" msgid="5141531044935541497">"Tühista"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Tähelepanu"</string>
    <string name="loading" msgid="7933681260296021180">"Laadimine ..."</string>
    <string name="capital_on" msgid="1544682755514494298">"SEES"</string>
    <string name="capital_off" msgid="6815870386972805832">"VÄLJAS"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Lõpetage toiming rakendusega"</string>
    <string name="whichApplicationNamed" msgid="8260158865936942783">"Toimingu lõpetamine, kasutades rakendust %1$s"</string>
    <string name="whichViewApplication" msgid="3272778576700572102">"Avamine:"</string>
    <string name="whichViewApplicationNamed" msgid="2286418824011249620">"Avamine rakendusega %1$s"</string>
    <string name="whichEditApplication" msgid="144727838241402655">"Muutmine:"</string>
    <string name="whichEditApplicationNamed" msgid="1775815530156447790">"Muutmine rakendusega %1$s"</string>
    <string name="whichSendApplication" msgid="6902512414057341668">"Jagamine:"</string>
    <string name="whichSendApplicationNamed" msgid="2799370240005424391">"Jagamine rakendusega %1$s"</string>
    <string name="whichHomeApplication" msgid="4307587691506919691">"Avaekraani rakenduse valimine"</string>
    <string name="whichHomeApplicationNamed" msgid="4493438593214760979">"Rakenduse %1$s kasutamine avaekraanina"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Kasuta vaikimisi selleks toiminguks."</string>
    <string name="use_a_different_app" msgid="8134926230585710243">"Teise rakenduse kasutamine"</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Tühjendage vaikeandmed valikutes Süsteemiseaded &gt; Rakendused &gt; Allalaaditud."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Toimingu valimine"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"USB-seadme jaoks rakenduse valimine"</string>
    <string name="noApplications" msgid="2991814273936504689">"Ükski rakendus ei saa seda toimingut teostada."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Kahjuks on rakendus <xliff:g id="APPLICATION">%1$s</xliff:g> peatunud."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Kahjuks on protsess <xliff:g id="PROCESS">%1$s</xliff:g> peatunud."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"<xliff:g id="APPLICATION">%2$s</xliff:g> ei vasta.\n\nKas soovite selle sulgeda?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Tegevus <xliff:g id="ACTIVITY">%1$s</xliff:g> ei vasta.\n\nKas soovite selle sulgeda?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"<xliff:g id="APPLICATION">%1$s</xliff:g> ei vasta. Kas soovite selle sulgeda?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Protsess <xliff:g id="PROCESS">%1$s</xliff:g> ei vasta.\n\nKas soovite selle sulgeda?"</string>
    <string name="force_close" msgid="8346072094521265605">"OK"</string>
    <string name="report" msgid="4060218260984795706">"Teata"</string>
    <string name="wait" msgid="7147118217226317732">"Oodake"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Leht ei reageeri.\n\nKas soovite selle sulgeda?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Rakendus on ümber suunatud"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"<xliff:g id="APP_NAME">%1$s</xliff:g> on nüüd käivitunud."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"Algselt käivitati rakendus <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Mõõtkava"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Kuva alati"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Lubage see uuesti valikutes Süsteemiseaded &gt; Rakendused &gt; Allalaaditud."</string>
    <string name="smv_application" msgid="3307209192155442829">"Rakendus <xliff:g id="APPLICATION">%1$s</xliff:g> (protsess <xliff:g id="PROCESS">%2$s</xliff:g>) on rikkunud isekehtestatud StrictMode\'i eeskirju."</string>
    <string name="smv_process" msgid="5120397012047462446">"Protsess <xliff:g id="PROCESS">%1$s</xliff:g> on rikkunud isejõustatud StrictMode\'i eeskirju."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Android viiakse üle uuemale versioonile ..."</string>
    <string name="android_start_title" msgid="8418054686415318207">"Android käivitub ..."</string>
    <string name="android_upgrading_fstrim" msgid="8036718871534640010">"Salvestusruumi optimeerimine."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"<xliff:g id="NUMBER_0">%1$d</xliff:g>. rakenduse <xliff:g id="NUMBER_1">%2$d</xliff:g>-st optimeerimine."</string>
    <string name="android_preparing_apk" msgid="8162599310274079154">"Rakenduse <xliff:g id="APPNAME">%1$s</xliff:g> ettevalmistamine."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Rakenduste käivitamine."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Käivitamise lõpuleviimine."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"<xliff:g id="APP">%1$s</xliff:g> töötab"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Puudutage rakendusele lülitumiseks"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Kas lülituda teisele rakendusele?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Teine rakendus juba töötab ja see tuleb peatada, et saaksite uue käivitada."</string>
    <string name="old_app_action" msgid="493129172238566282">"Tagasi rakendusse <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Ärge käivitage uut rakendust."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Käivitage rakendus <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Peatage vana rakendus salvestamata."</string>
    <string name="dump_heap_notification" msgid="2618183274836056542">"Protsess <xliff:g id="PROC">%1$s</xliff:g> ületas mälupiirangu"</string>
    <string name="dump_heap_notification_detail" msgid="2075673362317481664">"Mälutõmmis salvestati; puudutage jagamiseks"</string>
    <string name="dump_heap_title" msgid="5864292264307651673">"Kas jagada mälutõmmist?"</string>
    <string name="dump_heap_text" msgid="4809417337240334941">"Protsess <xliff:g id="PROC">%1$s</xliff:g> ületas protsessi mälupiirangu <xliff:g id="SIZE">%2$s</xliff:g>. Saate mälutõmmist jagada selle arendajaga. Olge ettevaatlik: see mälutõmmis võib sisaldada teie isiklikke andmeid, millele rakendusel on juurdepääs."</string>
    <string name="sendText" msgid="5209874571959469142">"Valige teksti jaoks toiming"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Helina helitugevus"</string>
    <string name="volume_music" msgid="5421651157138628171">"Meediumi helitugevus"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Esitatakse Bluetoothi kaudu"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Valitud on hääletu märguanne"</string>
    <string name="volume_call" msgid="3941680041282788711">"Kõne helitugevus"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Bluetoothi kõne helitugevus"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Alarmi helitugevus"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Teadistusheli"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Helitugevus"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Bluetoothi maht"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Helina tugevus"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Kõne helitugevus"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Meediumi helitugevus"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Teatise helitugevus"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Vaikehelin"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Vaikehelin (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Puudub"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Helinad"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Tundmatu helin"</string>
    <plurals name="wifi_available" formatted="false" msgid="7900333017752027322">
      <item quantity="other">WiFi-võrgud on saadaval</item>
      <item quantity="one">WiFi-võrk on saadaval</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1140699367193975606">
      <item quantity="other">Avatud WiFi-võrgud on saadaval</item>
      <item quantity="one">Avatud WiFi-võrk on saadaval</item>
    </plurals>
    <string name="wifi_available_sign_in" msgid="9157196203958866662">"Logi sisse WiFi-võrku"</string>
    <string name="network_available_sign_in" msgid="1848877297365446605">"Võrku sisselogimine"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_no_internet" msgid="8451173622563841546">"WiFi-l pole juurdepääsu Internetile"</string>
    <string name="wifi_no_internet_detailed" msgid="7593858887662270131">"Puudutage valikute nägemiseks"</string>
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Ei saanud WiFi-ga ühendust"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" on halb Interneti-ühendus."</string>
    <string name="wifi_connect_alert_title" msgid="8455846016001810172">"Kas lubada ühendus?"</string>
    <string name="wifi_connect_alert_message" msgid="6451273376815958922">"Rakendus %1$s soovib luua ühenduse WiFi-võrguga %2$s"</string>
    <string name="wifi_connect_default_application" msgid="7143109390475484319">"Rakendus"</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"WiFi Direct"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Käivitage WiFi otseühendus. See lülitab välja WiFi kliendi/leviala."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"WiFi otseühenduse käivitamine ebaõnnestus."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"WiFi Direct on sees"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Puuted seadete jaoks"</string>
    <string name="accept" msgid="1645267259272829559">"Nõustu"</string>
    <string name="decline" msgid="2112225451706137894">"Keeldu"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Kutse on saadetud"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Kutse ühendamiseks"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Saatja:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Saaja:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Sisestage nõutav PIN-kood:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN-kood:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"Tahvelarvuti ühendus WiFi-ga katkestatakse ajutiselt, kui see on ühendatud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tv" msgid="3087858235069421128">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendamisel katkestatakse ajutiselt teleri ühendus WiFi-ga"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"Telefoni ühendus WiFi-ga katkestatakse ajutiselt, kui see on ühendatud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="select_character" msgid="3365550120617701745">"Sisesta tähemärk"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"SMS-sõnumite saatmine"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; saadab suurel hulgal SMS-sõnumeid. Kas tahate lubada sellel rakendusel ka edaspidi sõnumeid saata?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Luba"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Keela"</string>
    <string name="sms_short_code_confirm_message" msgid="1645436466285310855">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; soovib saata sõnumi aadressile &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="5873295990846059400">"Sellega võivad teie mobiilikontol "<b>"kaasneda kulud"</b>"."</string>
    <string name="sms_premium_short_code_details" msgid="7869234868023975"><b>"Sellega kaasnevad teie mobiilikontol kulud."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Saada"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Tühista"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Jäta minu valik meelde"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Saate muuta jaotises Seaded &gt; Rakendused"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Luba alati"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Ära luba"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM-kaart eemaldatud"</string>
    <string name="sim_removed_message" msgid="5450336489923274918">"Mobiilsidevõrk ei ole saadaval, kuni sisestate kehtiva SIM-kaardi ja taaskäivitate seadme."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Valmis"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"SIM-kaart lisatud"</string>
    <string name="sim_added_message" msgid="7797975656153714319">"Mobiilsidevõrku pääsemiseks taaskäivitage seade."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Taaskäivita"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Kellaaja määramine"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Kuupäeva määramine"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Määra"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Valmis"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"UUS: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Teenusepakkuja: <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Lube pole vaja"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"see võib olla tasuline"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"USB-massmälu"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB ühendatud"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Teil on arvutiga ühendus USB kaudu. Puudutage allolevat nuppu, kui soovite faile arvuti ja Androidi USB-salvestusruumi vahel kopeerida."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Olete arvutiga ühendatud USB kaudu. Puudutage allolevat nuppu, kui soovite faile arvuti ja Androidi SD-kaardi vahel kopeerida."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Lülita USB-mäluseade sisse"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Probleem USB-salvestusruumi kasutamisel USB-mäluseadmena."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Probleem SD-kaardi kasutamisel USB-mäluseadmena."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB ühendatud"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Puudutage, et kopeerida faile arvutist/arvutisse."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Lülita USB-mäluseade välja"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"USB-salvestusruumi väljalülitamiseks puudutage."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"USB kasutusel"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Enne USB-salvestusruumi väljalülitamist eraldage (väljutage) Androidi USB-salvestusruum arvutist."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Enne USB-salvestusruumi väljalülitamist eemaldage (väljutage) Androidi SD-kaart arvutist."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Lülita USB-mäluseade välja"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Tekkis probleem USB-salvestusruumi väljalülitamisega. Kontrollige, kas olete USB-hosti eemaldanud, ja proovige seejärel uuesti."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Lülita USB-mäluseade sisse"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Kui lülitate USB-salvestusruumi sisse, võivad mõned kasutatavad rakendused peatuda ega pruugi olla saadaval enne USB-salvestusruumi väljalülitamist."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"USB toiming ebaõnnestus"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="usb_charging_notification_title" msgid="4004114449249406402">"USB laadimiseks"</string>
    <string name="usb_mtp_notification_title" msgid="8396264943589760855">"USB failide edastamiseks"</string>
    <string name="usb_ptp_notification_title" msgid="1347328437083192112">"USB fotode edastamiseks"</string>
    <string name="usb_midi_notification_title" msgid="4850904915889144654">"USB MIDI jaoks"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Ühendatud installijana"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Ühendatud USB-lisaseadmega"</string>
    <string name="usb_notification_message" msgid="7347368030849048437">"Puudutage rohkemate valikute kuvamiseks."</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"USB-silumine ühendatud"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Puudutage USB-silumise keelamiseks."</string>
    <string name="select_input_method" msgid="8547250819326693584">"Klaviatuuri muutmine"</string>
    <string name="configure_input_methods" msgid="4769971288371946846">"Vali klaviatuurid"</string>
    <string name="show_ime" msgid="9157568568695230830">"Sisestusmeetodi kuvamine"</string>
    <string name="hardware" msgid="7517821086888990278">"Riistvara"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Klaviatuuri paigutuse valimine"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Puudutage klaviatuuri paigutuse valimiseks."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" ABCDEFGHIJKLMNOPQRSŠZŽTUVWÕÄÖÜXY"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSŠZŽTUVWÕÄÖÜXY"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"kandidaadid"</u></string>
    <string name="ext_media_checking_notification_title" msgid="5734005953288045806">"Üksuse <xliff:g id="NAME">%s</xliff:g> ettevalmistamine"</string>
    <string name="ext_media_checking_notification_message" msgid="4747432538578886744">"Vigade kontrollimine"</string>
    <string name="ext_media_new_notification_message" msgid="7589986898808506239">"Tuvastati uus üksus <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_ready_notification_message" msgid="4083398150380114462">"Fotode ja meedia ülekandmiseks"</string>
    <string name="ext_media_unmountable_notification_title" msgid="8295123366236989588">"Rikutud <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="1586311304430052169">"Üksus <xliff:g id="NAME">%s</xliff:g> on rikutud. Parandamiseks puudutage."</string>
    <string name="ext_media_unsupported_notification_title" msgid="3797642322958803257">"Toetamata <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unsupported_notification_message" msgid="8789610369456474891">"See seade ei toeta üksust <xliff:g id="NAME">%s</xliff:g>. Puudutage toetatud vormingus seadistamiseks."</string>
    <string name="ext_media_badremoval_notification_title" msgid="3206248947375505416">"Üksus <xliff:g id="NAME">%s</xliff:g> eemaldati ootamatult"</string>
    <string name="ext_media_badremoval_notification_message" msgid="380176703346946313">"Andmekao vältimiseks lahutage üksus <xliff:g id="NAME">%s</xliff:g> enne eemaldamist"</string>
    <string name="ext_media_nomedia_notification_title" msgid="1704840188641749091">"Üksus <xliff:g id="NAME">%s</xliff:g> on eemaldatud"</string>
    <string name="ext_media_nomedia_notification_message" msgid="6471542972147056586">"Üksus <xliff:g id="NAME">%s</xliff:g> eemaldati; sisestage uus"</string>
    <string name="ext_media_unmounting_notification_title" msgid="640674168454809372">"Üksust <xliff:g id="NAME">%s</xliff:g> ikka eemaldatakse …"</string>
    <string name="ext_media_unmounting_notification_message" msgid="4182843895023357756">"Ärge eemaldage"</string>
    <string name="ext_media_init_action" msgid="7952885510091978278">"Seadistus"</string>
    <string name="ext_media_unmount_action" msgid="1121883233103278199">"Eemaldamine"</string>
    <string name="ext_media_browse_action" msgid="8322172381028546087">"Avastamine"</string>
    <string name="ext_media_missing_title" msgid="620980315821543904">"Üksust <xliff:g id="NAME">%s</xliff:g> pole"</string>
    <string name="ext_media_missing_message" msgid="5761133583368750174">"Sisestage see seade uuesti"</string>
    <string name="ext_media_move_specific_title" msgid="1471100343872375842">"Seadme <xliff:g id="NAME">%s</xliff:g> teisaldamine"</string>
    <string name="ext_media_move_title" msgid="1022809140035962662">"Andmete teisaldamine"</string>
    <string name="ext_media_move_success_title" msgid="8575300932957954671">"Teisaldamine lõpetati"</string>
    <string name="ext_media_move_success_message" msgid="4199002148206265426">"Andmed teisaldati üksusesse <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="7613189040358789908">"Andmeid ei saanud teisaldada"</string>
    <string name="ext_media_move_failure_message" msgid="1978096440816403360">"Andmed on algses asukohas alles"</string>
    <string name="ext_media_status_removed" msgid="6576172423185918739">"Eemaldatud"</string>
    <string name="ext_media_status_unmounted" msgid="2551560878416417752">"Väljutatud"</string>
    <string name="ext_media_status_checking" msgid="6193921557423194949">"Kontrollimine ..."</string>
    <string name="ext_media_status_mounted" msgid="7253821726503179202">"Valmis"</string>
    <string name="ext_media_status_mounted_ro" msgid="8020978752406021015">"Kirjutuskaitstud"</string>
    <string name="ext_media_status_bad_removal" msgid="8395398567890329422">"Eemaldamine polnud turvaline"</string>
    <string name="ext_media_status_unmountable" msgid="805594039236667894">"Rikutud"</string>
    <string name="ext_media_status_unsupported" msgid="4691436711745681828">"Ei toetata"</string>
    <string name="ext_media_status_ejecting" msgid="5463887263101234174">"Väljutamine …"</string>
    <string name="ext_media_status_formatting" msgid="1085079556538644861">"Vormindamine ..."</string>
    <string name="ext_media_status_missing" msgid="5638633895221670766">"Pole sisestatud"</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Sobivat tegevust ei leitud"</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Meediaväljundi teekonna koostamine"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Võimaldab rakendusel koostada teekonna meediaväljundist teistesse välistesse seadmetesse."</string>
    <string name="permlab_readInstallSessions" msgid="6165432407628065939">"Installiseansside lugemine"</string>
    <string name="permdesc_readInstallSessions" msgid="2049771699626019849">"Lubab rakendusel lugeda installiseansse. See võimaldab näha aktiivse paketi installimise üksikasju."</string>
    <string name="permlab_requestInstallPackages" msgid="1772330282283082214">"Installipakettide taotlemine"</string>
    <string name="permdesc_requestInstallPackages" msgid="5740101072486783082">"Võimaldab rakendusel pakettide installimist taotleda."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Suumi juhtimiseks puudutage kaks korda"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Vidinat ei saanud lisada."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Mine"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Otsing"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Saada"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Järgmine"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Valmis"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Eelm."</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Täida"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Vali number\n kasutades numbrit <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Loo kontakt\nnumbriga <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Üks või mitu rakendust taotlevad luba pääseda nüüd ja edaspidi teie kontole juurde."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Kas soovite taotluse lubada?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Juurdepääsutaotlus"</string>
    <string name="allow" msgid="7225948811296386551">"Luba"</string>
    <string name="deny" msgid="2081879885755434506">"Keela"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Taotletud luba"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Luba on taotletud\nkontole <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="forward_intent_to_owner" msgid="1207197447013960896">"Kasutate rakendust väljaspool tööprofiili"</string>
    <string name="forward_intent_to_work" msgid="621480743856004612">"Kasutate seda rakendust oma tööprofiilil"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Sisestusmeetod"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sünkroonimine"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Juurdepääsetavus"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Taustapilt"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Muutke taustapilti"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Märguannete kuulamisteenus"</string>
    <string name="condition_provider_service_binding_label" msgid="1321343352906524564">"Tingimuse pakkuja"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN on aktiveeritud"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"VPN-i aktiveeris <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Võrgu haldamiseks puudutage."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Ühendatud seansiga <xliff:g id="SESSION">%s</xliff:g>. Võrgu haldamiseks puudutage."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Ühendamine alati sees VPN-iga …"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Ühendatud alati sees VPN-iga"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Alati sees VPN-i viga"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Puudutage seadistamiseks"</string>
    <string name="upload_file" msgid="2897957172366730416">"Valige fail"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Ühtegi faili pole valitud"</string>
    <string name="reset" msgid="2448168080964209908">"Lähtesta"</string>
    <string name="submit" msgid="1602335572089911941">"Saada"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Autorežiim lubatud"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Autorežiimist väljumiseks puudutage."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Jagamine või tööpunkt on aktiivne"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Seadistamiseks puudutage."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Tagasi"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Järgmine"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Jäta vahele"</string>
    <string name="no_matches" msgid="8129421908915840737">"Vasted puuduvad"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Otsige lehelt"</string>
    <plurals name="matches_found" formatted="false" msgid="1210884353962081884">
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> vastet <xliff:g id="TOTAL">%d</xliff:g>-st</item>
      <item quantity="one">1 vaste</item>
    </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Valmis"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"USB-salvestusruumi eemaldamine ..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"SD-kaardi eemaldamine ..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"USB-salvestusruumi kustutamine ..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"SD-kaardi kustutamine ..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"USB-mäluseadme tühjendamine ebaõnnestus."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"SD-kaardi kustutamine ebaõnnestus."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"SD-kaart eemaldati enne lahutamist."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"USB-mäluseadet kontrollitakse praegu."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"SD-kaarti kontrollitakse praegu."</string>
    <string name="media_removed" msgid="7001526905057952097">"SD-kaart on eemaldatud."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"Praegu kasutab USB-mäluseadet arvuti."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"Praegu kasutab SD-kaarti arvuti."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Väline meedium on tundmatus olekus."</string>
    <string name="share" msgid="1778686618230011964">"Jaga"</string>
    <string name="find" msgid="4808270900322985960">"Otsi"</string>
    <string name="websearch" msgid="4337157977400211589">"Veebiotsing"</string>
    <string name="find_next" msgid="5742124618942193978">"Leia järgmine"</string>
    <string name="find_previous" msgid="2196723669388360506">"Leia eelmine"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Asukohapäring kasutajalt <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Asukohapäring"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Taotleja: <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Jah"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Ei"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Kustutamiste piirarv on ületatud"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Kustutatavad üksused kontol <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g> sünkroonimistüübi <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> jaoks: <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g>. Mida soovite teha?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Kustuta üksused"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Võtke kustutamised tagasi"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Ära tee praegu midagi"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Konto valimine"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Konto lisamine"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Lisa konto"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Suurendamine"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Vähendamine"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g> puudutage ja hoidke."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Suurendamiseks lohistage üles, vähendamiseks alla."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Minutite suurendamine"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Minutite vähendamine"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Tundide suurendamine"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Tundide vähendamine"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"PM-i seadmine"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"AM-i seadmine"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Kuu suurendamine"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Kuu vähendamine"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Päeva suurendamine"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Päeva vähendamine"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Aasta suurendamine"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Aasta vähendamine"</string>
    <string name="date_picker_prev_month_button" msgid="2858244643992056505">"Eelmine kuu"</string>
    <string name="date_picker_next_month_button" msgid="5559507736887605055">"Järgmine kuu"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Tühista"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Kustuta"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Valmis"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Režiimi muutmine"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Tõstuklahv"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Sisestusklahv"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Valige rakendus"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Rakendust <xliff:g id="APPLICATION_NAME">%s</xliff:g> ei õnnestunud käivitada"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Jaga:"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Jaga rakendusega <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Libistamispide. Puudutage ja hoidke all."</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Avamiseks tõmmake sõrmega."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Paroolide kuulamiseks ühendage peakomplekt."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Punkt."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Liigu avalehele"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Liigu üles"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Rohkem valikuid"</string>
    <string name="action_bar_home_description_format" msgid="7965984360903693903">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="6985546530471780727">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="4891916833657929263">"Sisemine salvestusruum"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD-kaart"</string>
    <string name="storage_sd_card_label" msgid="6347111320774379257">"Tootja <xliff:g id="MANUFACTURER">%s</xliff:g> SD-kaart"</string>
    <string name="storage_usb_drive" msgid="6261899683292244209">"USB-ketas"</string>
    <string name="storage_usb_drive_label" msgid="4501418548927759953">"Tootja <xliff:g id="MANUFACTURER">%s</xliff:g> USB-ketas"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB-mäluseade"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Andmete kasutamise hoiatus"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Kasutuse/sätete vaat. puudutage."</string>
    <string name="data_usage_3g_limit_title" msgid="4361523876818447683">"2G-, 3G-andmeside limiit on täis"</string>
    <string name="data_usage_4g_limit_title" msgid="4609566827219442376">"4G-andmeside limiit on täis"</string>
    <string name="data_usage_mobile_limit_title" msgid="557158376602636112">"Mobiilse andmes. limiit on täis"</string>
    <string name="data_usage_wifi_limit_title" msgid="5803363779034792676">"WiFi-andmeside limiit on täis"</string>
    <string name="data_usage_limit_body" msgid="291731708279614081">"Andmed on ülej. tsükliks peatat."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"2G-3G andmemahupiirang ületatud"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"4G andmemahupiirang ületatud"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="4941346653729943789">"Mob. andmeside limiit ületatud"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"WiFi-andmete piir on ületatud"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> üle määratud piirmäära."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Taustandmed on piiratud"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Piirangu eemaldamiseks puudut."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Turvasertifikaat"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"See sertifikaat on kehtiv."</string>
    <string name="issued_to" msgid="454239480274921032">"Väljastatud subjektile:"</string>
    <string name="common_name" msgid="2233209299434172646">"Pärisnimi:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organisatsioon:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organisatsiooniüksus:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Väljastaja:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Kehtivus:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Väljastamiskuupäev:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Aegumiskuupäev:"</string>
    <string name="serial_number" msgid="758814067660862493">"Seerianumber:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Sõrmejäljed:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"SHA-256 sõrmejälg:"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"SHA-1 sõrmejälg:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Kuva kõik"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Tegevuse valimine"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Jagamine rakendusega:"</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Saatmine ..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Kas käivitada brauser?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Kas vastata kõnele?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Alati"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Ainult üks kord"</string>
    <string name="activity_resolver_work_profiles_support" msgid="185598180676883455">"%1$s ei toeta tööprofiili"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tahvelarvuti"</string>
    <string name="default_audio_route_name" product="tv" msgid="9158088547603019321">"Teler"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefon"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Kõrvaklapid"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Doki kõlarid"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Süsteem"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth-heli"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Juhtmeta ekraan"</string>
    <string name="media_route_button_content_description" msgid="591703006349356016">"Ülekandmine"</string>
    <string name="media_route_chooser_title" msgid="1751618554539087622">"Seadmega ühendamine"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3395541745872017583">"Ekraanikuva ülekandmine seadmesse"</string>
    <string name="media_route_chooser_searching" msgid="4776236202610828706">"Seadmete otsimine …"</string>
    <string name="media_route_chooser_extended_settings" msgid="87015534236701604">"Seaded"</string>
    <string name="media_route_controller_disconnect" msgid="8966120286374158649">"Katkesta ühendus"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Skaneering ..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Ühendan..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Saadaval"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Ei ole saadaval"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"Kasutusel"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Sisseehitatud ekraan"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI-ekraan"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Ülekate nr .<xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="652124517672257172">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g> x <xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="6022119702628572080">", turvaline"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Unustasin mustri"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Vale muster"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Vale parool"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Vale PIN-kood"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Proovige uuesti <xliff:g id="NUMBER">%1$d</xliff:g> sekundi pärast."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Joonistage oma muster"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Sisestage SIM-i PIN-kood"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Sisestage PIN-kood"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Sisestage parool"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"SIM on nüüd keelatud. Jätkamiseks sisestage PUK-kood. Üksikasju küsige operaatorilt."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Sisestage soovitud PIN-kood"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Kinnitage soovitud PIN-kood"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"SIM-kaardi avamine ..."</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Vale PIN-kood."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Sisestage 4–8-numbriline PIN-kood."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="6025069204539532000">"PUK-kood peab koosnema 8 numbrist."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Sisestage uuesti õige PUK-kood. Korduvkatsete korral keelatakse SIM jäädavalt."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"PIN-koodid ei ole vastavuses"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Liiga palju mustrikatseid"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Avamiseks logige sisse oma Google\'i kontoga."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Kasutajanimi (e-post)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Parool"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Logi sisse"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Vale kasutajanimi või parool."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Kas unustasite kasutajanime või parooli?\nKülastage aadressi "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Konto kontrollimine ..."</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"Olete PIN-koodi <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti sisestanud.\n\nProovige <xliff:g id="NUMBER_1">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"Olete parooli <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti sisestanud. \n\nProovige uuesti <xliff:g id="NUMBER_1">%d</xliff:g> sekundi pärast."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"Joonistasite oma avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti.\n\nProovige <xliff:g id="NUMBER_1">%d</xliff:g> sekundi pärast uuesti."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"Olete üritanud <xliff:g id="NUMBER_0">%d</xliff:g> korda tahvelarvutit valesti avada. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset lähtestatakse tahvelarvuti tehase vaikeseadetele ja kõik kasutajaandmed lähevad kaotsi."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="5621231220154419413">"Teleri avamine on <xliff:g id="NUMBER_0">%d</xliff:g> korda ebaõnnestunud. Kui veel <xliff:g id="NUMBER_1">%d</xliff:g> katset ebaõnnestub, lähtestatakse teler tehaseseadetele ja kasutajaandmed lähevad kaotsi."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"Olete üritanud <xliff:g id="NUMBER_0">%d</xliff:g> korda telefoni valesti avada. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset lähtestatakse telefon tehase vaikeseadetele ja kõik kasutajaandmed lähevad kaotsi."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"Olete püüdnud tahvelarvutit <xliff:g id="NUMBER">%d</xliff:g> korda valesti avada. Tahvelarvuti lähtestatakse nüüd tehase vaikeseadetele."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="4987878286750741463">"Teleri avamine on <xliff:g id="NUMBER">%d</xliff:g> korda ebaõnnestunud. Teler lähtestatakse tehaseseadetele."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"Olete püüdnud telefoni <xliff:g id="NUMBER">%d</xliff:g> korda valesti avada. Telefon lähtestatakse nüüd tehase vaikeseadetele."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"Joonistasite oma avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset palutakse teil tahvelarvuti avada meilikontoga.\n\n Proovige uuesti <xliff:g id="NUMBER_2">%d</xliff:g> sekundi pärast."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="4224651132862313471">"Olete avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti joonistanud. Kui joonistate mustri veel <xliff:g id="NUMBER_1">%d</xliff:g> korda valesti, siis palutakse teil avada teler meilikonto abil.\n\n Proovige uuesti <xliff:g id="NUMBER_2">%d</xliff:g> sekundi pärast."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"Joonistasite oma avamismustri <xliff:g id="NUMBER_0">%d</xliff:g> korda valesti. Pärast veel <xliff:g id="NUMBER_1">%d</xliff:g> ebaõnnestunud katset palutakse teil telefon avada meilikontoga.\n\n Proovige uuesti <xliff:g id="NUMBER_2">%d</xliff:g> sekundi pärast."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Eemalda"</string>
    <string name="safe_media_volume_warning" product="default" msgid="2276318909314492312">"Kas suurendada helitugevuse taset üle soovitatud taseme?\n\nPikaajaline valju helitugevusega kuulamine võib kuulmist kahjustada."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Hõlbustuse lubamiseks hoidke kaht sõrme all."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Hõlbustus on lubatud."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Hõlbustus on tühistatud."</string>
    <string name="user_switched" msgid="3768006783166984410">"Praegune kasutaja <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="2871009331809089783">"Üleminek kasutajale <xliff:g id="NAME">%1$s</xliff:g> ..."</string>
    <string name="owner_name" msgid="2716755460376028154">"Omanik"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Viga"</string>
    <string name="error_message_change_not_allowed" msgid="1347282344200417578">"Administraator ei luba sellist muudatust teha"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Selle toimingu käsitlemiseks ei leitud ühtegi rakendust"</string>
    <string name="revoke" msgid="5404479185228271586">"Tühista"</string>
    <string name="mediasize_iso_a0" msgid="1994474252931294172">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="3333060421529791786">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="3097535991925798280">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3023213259314236123">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="231745325296873764">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3484327407340865411">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="4861908487129577530">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="5890208588072936130">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="4319425041085816612">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="4882220529506432008">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="2382866026365359391">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="3651827147402009675">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="6072859628278739957">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="1348731852150380378">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="2612510181259261379">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="695151378838115434">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="4863754285582212487">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="5305816292139647241">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="531673542602786624">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="9164474595708850034">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="282102976764774160">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="4517141714407898976">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="3103521357901591100">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1231954105985048595">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="927702816980087462">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="835154173518304159">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="5095951985108194011">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="1985397450332305739">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8147421924174693013">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="8993994925276122950">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="6871178104139598957">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="7983532635227561362">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="5040764293406765584">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="2841414839888344296">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="5295836838862962809">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8621364037680465666">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3309324162155085904">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="5567030340509075333">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="4571735038501661757">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="5182901917818625126">"Index Card 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Index Card 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Index Card 5x8"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Tundmatu vertikaalpaigutuses"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Tundmatu horisontaalpaigutuses"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Tühistatud"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Viga sisu kirjutamisel"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"teadmata"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Printimisteenus pole lubatud"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"Teenus <xliff:g id="NAME">%s</xliff:g> on installitud"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Lubamiseks puudutage"</string>
    <string name="restr_pin_enter_admin_pin" msgid="783643731895143970">"Administraatori PIN-koodi sisestamine"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Sisestage PIN-kood"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Vale"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Praegune PIN-kood"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Uus PIN-kood"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Kinnitage uus PIN-kood"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Looge PIN-kood piirangute muutmiseks"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"PIN-kood ei sobi. Proovige uuesti."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"PIN-kood on liiga lühike. Peab olema vähemalt 4-kohaline."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="9061246974881224688">
      <item quantity="other">Proovige uuesti <xliff:g id="COUNT">%d</xliff:g> sekundi pärast</item>
      <item quantity="one">Proovige uuesti 1 sekundi pärast</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Proovige hiljem uuesti"</string>
    <string name="immersive_cling_title" msgid="8394201622932303336">"Kuvamine täisekraanil"</string>
    <string name="immersive_cling_description" msgid="3482371193207536040">"Väljumiseks pühkige ülevalt alla."</string>
    <string name="immersive_cling_positive" msgid="5016839404568297683">"Selge"</string>
    <string name="done_label" msgid="2093726099505892398">"Valmis"</string>
    <string name="hour_picker_description" msgid="6698199186859736512">"Ringikujuline tunniliugur"</string>
    <string name="minute_picker_description" msgid="8606010966873791190">"Ringikujuline minutiliugur"</string>
    <string name="select_hours" msgid="6043079511766008245">"Tundide valimine"</string>
    <string name="select_minutes" msgid="3974345615920336087">"Minutite valimine"</string>
    <string name="select_day" msgid="7774759604701773332">"Kuu ja päeva valimine"</string>
    <string name="select_year" msgid="7952052866994196170">"Aasta valimine"</string>
    <string name="deleted_key" msgid="7659477886625566590">"<xliff:g id="KEY">%1$s</xliff:g> on kustutatud"</string>
    <string name="managed_profile_label_badge" msgid="2355652472854327647">"Töö <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="lock_to_app_toast" msgid="7570091317001980053">"Ekraanikuva vabastamiseks puudutage pikalt samal ajal nuppe Tagasi ja Ülevaade."</string>
    <string name="lock_to_app_toast_accessible" msgid="8239120109365070664">"Ekraanikuva vabastamiseks puudutage pikalt nuppu Ülevaade."</string>
    <string name="lock_to_app_toast_locked" msgid="9125176335701699164">"Rakendus on kinnitatud: vabastamine pole selles seadmes lubatud."</string>
    <string name="lock_to_app_start" msgid="6643342070839862795">"Ekraan on kinnitatud"</string>
    <string name="lock_to_app_exit" msgid="8598219838213787430">"Ekraan on vabastatud"</string>
    <string name="lock_to_app_unlock_pin" msgid="2552556656504331634">"Enne vabastamist küsi PIN-koodi"</string>
    <string name="lock_to_app_unlock_pattern" msgid="4182192144797225137">"Enne vabastamist küsi avamismustrit"</string>
    <string name="lock_to_app_unlock_password" msgid="6380979775916974414">"Enne vabastamist küsi parooli"</string>
    <string name="package_installed_device_owner" msgid="8420696545959087545">"Installis teie administraator"</string>
    <string name="package_updated_device_owner" msgid="8856631322440187071">"Värskendas administraator"</string>
    <string name="package_deleted_device_owner" msgid="7650577387493101353">"Kustutas teie administraator"</string>
    <string name="battery_saver_description" msgid="1960431123816253034">"Aku kestuse parandamiseks vähendab akusäästja teie seadme toimivust ning piirab vibratsiooni, asukohateenuseid ja suuremat osa taustaandmetest. E-posti, sõnumsidet ja muid sünkroonimisele tuginevaid rakendusi võidakse värskendada ainult siis, kui te need avate.\n\nAkusäästja lülitatakse seadme laadimise ajal automaatselt välja."</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="4367877408072000848">
      <item quantity="other">%1$d minutiks (kuni <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Üheks minutiks (kuni <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="6830154222366042597">
      <item quantity="other">%1$d min (kuni <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">1 min (kuni <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="8152974162096743862">
      <item quantity="other">%1$d tunniks (kuni <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Üheks tunniks (kuni <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="4787552595253082371">
      <item quantity="other">%1$d h (kuni <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">1 h (kuni <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="5127407202506485571">
      <item quantity="other">%d minutiks</item>
      <item quantity="one">Üheks minutiks</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2199350154433426128">
      <item quantity="other">%d min</item>
      <item quantity="one">1 min</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="3938821308277433854">
      <item quantity="other">%d tunniks</item>
      <item quantity="one">Üheks tunniks</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="6748277774662434217">
      <item quantity="other">%d h</item>
      <item quantity="one">1 h</item>
    </plurals>
    <string name="zen_mode_until" msgid="7336308492289875088">"Kuni <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_forever" msgid="7420011936770086993">"Kuni lülitate selle välja"</string>
    <string name="zen_mode_forever_dnd" msgid="3792132696572189081">"Kuni lülitate välja valiku Mitte segada"</string>
    <string name="zen_mode_rule_name_combination" msgid="191109939968076477">"<xliff:g id="FIRST">%1$s</xliff:g>/<xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="2821479483960330739">"Ahendamine"</string>
    <string name="zen_mode_feature_name" msgid="5254089399895895004">"Mitte segada"</string>
    <string name="zen_mode_downtime_feature_name" msgid="2626974636779860146">"Puhkeaeg"</string>
    <string name="zen_mode_default_weeknights_name" msgid="3081318299464998143">"Argiõhtu"</string>
    <string name="zen_mode_default_weekends_name" msgid="2786495801019345244">"Nädalavahetus"</string>
    <string name="zen_mode_default_events_name" msgid="8158334939013085363">"Sündmus"</string>
    <string name="muted_by" msgid="6147073845094180001">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> vaigistas"</string>
    <string name="system_error_wipe_data" msgid="6608165524785354962">"Seadmes ilmnes sisemine probleem ja seade võib olla ebastabiilne seni, kuni lähtestate seadme tehase andmetele."</string>
    <string name="system_error_manufacturer" msgid="8086872414744210668">"Seadmes ilmnes sisemine probleem. Üksikasjaliku teabe saamiseks võtke ühendust tootjaga."</string>
    <string name="stk_cc_ussd_to_dial" msgid="5202342984749947872">"USSD-päring muudeti DIAL-päringuks."</string>
    <string name="stk_cc_ussd_to_ss" msgid="2345360594181405482">"USSD-päring muudeti SS-päringuks."</string>
    <string name="stk_cc_ussd_to_ussd" msgid="7466087659967191653">"USSD-päring muudeti uueks USSD-päringuks."</string>
    <string name="stk_cc_ss_to_dial" msgid="2151304435775557162">"SS-päring muudeti DIAL-päringuks."</string>
    <string name="stk_cc_ss_to_ussd" msgid="3951862188105305589">"SS-päring muudeti USSD-päringuks."</string>
    <string name="stk_cc_ss_to_ss" msgid="5470768854991452695">"SS-päring muudeti uueks SS-päringuks."</string>
    <string name="notification_work_profile_content_description" msgid="4600554564103770764">"Tööprofiil"</string>
    <string name="usb_midi_peripheral_name" msgid="7221113987741003817">"Androidi väline USB-port"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7176526170008970168">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="4971827859165280403">"Väline USB-port"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="4797287862999444631">"Rohkem valikuid"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="559796923090723804">"Ületäite sulgemine"</string>
    <plurals name="selected_count" formatted="false" msgid="7187339492915744615">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> on valitud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> on valitud</item>
    </plurals>
</resources>
