<?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="9164292791500531949">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Pealkirjata&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥."</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Telefoninumbrit pole)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Tundmatu)"</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="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="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="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="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="default" msgid="3475999286680000541">"Telefonimälu on täis. Ruumi vabastamiseks kustutage mõned failid."</string>
    <string name="me" msgid="6545696007631404292">"Mina"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Tahvelarvuti 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="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="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="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="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="permgrouplab_costMoney" msgid="5429808217861460401">"Tasulised teenused"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Tasuliste toimingute tegemine."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Teie sõnumid"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Teie SMS-, meili- ja muude sõnumite lugemine ja kirjutamine."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Teie isiklikud andmed"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Otsene juurdepääs teie kohta käivale teabele, mis on salvestatud teie kontaktikaardile."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Teie sotsiaalne teave"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Otsene juurdepääs teie kontaktide teabele ja sotsiaalsetele sidemetele."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Teie asukoht"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Jälgige oma füüsilist asukohta."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Võrgusuhtlus"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Juurdepääs erinevatele võrgufunktsioonidele."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Juurdepääs seadmetele ja võrkudele Bluetoothi kaudu."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Heliseaded"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Heliseadete muutmine."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"Aku mõjutamine"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Funktsioonide, mis võivad aku kiiresti tühjendada, kasutamine."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalender"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Otsene juurdepääs kalendrile ja sündmustele."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Kasutaja sõnaraamatu lugemine"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Kasutaja sõnaraamatu sõnade lugemine."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Kasutaja sõnaraamatusse kirjutamine"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Kasutaja sõnaraamatusse sõnade lisamine."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Järjehoidjad ja ajalugu"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Otsene juurdepääs järjehoidjatele ja brauseri ajaloole."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Alarm"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"Äratuskella seadmine."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Kõnepost"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Otsene juurdepääs kõnepostile."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Otsene juurdepääs mikrofonile heli salvestamiseks."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Kaamera"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Otsene juurdepääs kaamerale fotode või videote jäädvustamiseks."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Teie rakenduste teave"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Võime mõjutada teiste seadmes olevate rakenduste käitumist."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Taustapilt"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"Seadme taustapildi seadete muutmine."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Kell"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"Seadme aja või ajavööndi muutmine."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Olekuriba"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"Seadme olekuriba seadete muutmine."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Sünkroonimisseaded"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Juurdepääs sünkroonimisseadetele."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Teie kontod"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Juurdepääs saadaolevatele kontodele."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Riistvara juhtelemendid"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Otsene juurdepääs mobiiltelefoni riistvarale."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Telefonikõned"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Telefonikõnede jälgimine, salvestamine ja töötlemine."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Süsteemitööriistad"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Süsteemi madalama taseme juurdepääs ja juhtimine."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Arendustööriistad"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Funktsioonid on vajalikud ainult rakenduste arendajatele."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Muu rakenduse kasutajaliides"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"Teiste rakenduste kasutajaliidese mõjutamine."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Mäluruum"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Juurdepääs USB-mäluseadmele."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Juurdepääs SD-kaardile."</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_processOutgoingCalls" msgid="3906007831192990946">"marsruutige väljuvad kõned uuesti"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Võimaldab rakendusel töödelda väljuvaid kõnesid ja muuta valitavat numbrit. Luba võimaldab rakendusel jälgida, ümber suunata või takistada väljuvaid kõnesid."</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_receiveEmergencyBroadcast" msgid="1803477660846288089">"hädaabiteadete vastuvõtmine"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Võimaldab rakendusel vastu võtta ja töödelda hädaabisõnumeid. See õigus on saadaval ainult süsteemirakendustele."</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_sendSms" msgid="5600830612147671529">"saada 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_sendSmsNoConfirmation" msgid="4781483105951730228">"lühisõnumite saatmine ilma kinnituseta"</string>
    <string name="permdesc_sendSmsNoConfirmation" msgid="402569800862935907">"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="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_writeSms" msgid="3216950472636214774">"muutke oma tekstisõnumeid (SMS või MMS)"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Võimaldab rakendusel kirjutada teie tahvelarvutisse või SIM-kaardile salvestatud SMS-sõnumitesse. Pahatahtlikud rakendused võivad teie sõnumid kustutada."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Võimaldab rakendusel kirjutada teie telefoni või SIM-kaardile salvestatud SMS-sõnumitesse. Pahatahtlikud rakendused võivad teie sõnumid kustutada."</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_interactAcrossUsers" msgid="7114255281944211682">"toimingud erinevatel kasutajakontodel"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Lubab rakendusel teha toiminguid seadme erinevatel kasutajakontodel. Pahatahtlikud rakendused võivad kasutada seda kasutajatevahelise kaitse rikkumiseks."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"täielik litsents teha toiminguid erinevatel kasutajakontodel"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Lubab kõiki võimalikke toiminguid erinevatel kasutajakontodel."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"kasutajate haldamine"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Võimaldab rakendustel hallata seadme kasutajaid, sealhulgas päringuid, loomist ja kustutamist."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"töötavate rakenduste üksikasjade toomine"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Võimaldab rakendusel tuua üksikasjalikku teavet praegu töötavate ja hiljuti käitatud ülesannete kohta. Pahatahtlikud rakendused võivad tuvastada privaatset teavet muude rakenduste kohta."</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_removeTasks" msgid="6821513401870377403">"käitatud rakenduste peatamine"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Võimaldab rakendusel eemaldada ülesanded ja peatada nende rakendused. Pahatahtlikud rakendused võivad häirida teiste rakenduste käitumist."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"mis tahes toimingu alustamine"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Võimaldab rakendusel käivitada mis tahes toimingu loa kaitsest või eksporditud olekust sõltumata."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"kuva ühilduvuse seadmine"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Võimaldab rakendusel juhtida teiste rakenduste kuva ühilduvuse režiimi. Pahatahtlikud rakendused võivad teisi rakendusi häirida."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"Rakenduse silumise lubamine"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Võimaldab rakendusel lülitada sisse teise rakenduse silumise. Pahatahtlikud rakendused võivad seda kasutada teiste rakenduste peatamiseks."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"muutke süsteemi kuvaseadeid"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Võimaldab rakendusel muuta praegust konfiguratsiooni, näiteks lokaati või üldist kirjasuurust."</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_forceStopPackages" msgid="2329627428832067700">"Teiste rakenduste jõuga peatamine"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Lubab rakendusel sunniviisiliselt teisi rakendusi peatada."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"Rakenduse sulguma sundimine"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Võimaldab rakendusel sundida iga esiplaanil oleva rakenduse sulgema ja tagasi minema. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"võta vastu süsteemi siseolek"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Võimaldab rakendusel teada saada süsteemi sisemist olekut. Pahatahtlikud rakendused võivad hankida mitmesugust privaatset ja turvateavet, mida neil tavaliselt kunagi vaja ei lähe."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"ekraanisisu taastamine"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Võimaldab rakendusel kätte saada aktiivse akna sisu. Pahatahtlikud rakendused võivad hankida kogu akna sisu ja uurida kogu selle teksti, välja arvatud paroole."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"ajutine hõlbustuse lubamine"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Lubab rakendusel ajutiselt lubada seadmes hõlbustuse. Pahatahtlikud rakendused võivad lubada hõlbustuse kasutaja nõusolekuta."</string>
    <string name="permlab_retrieve_window_info" msgid="8532295199112519378">"hangi akna teave"</string>
    <string name="permdesc_retrieve_window_info" msgid="4998836370424186849">"Võimaldab rakendusel hankida teavet aknahalduri akende kohta. Pahatahtlikud rakendused võivad hankida teavet, mis on mõeldud süsteemisiseseks kasutamiseks."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"filtreeri sündmused"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Võimaldab rakendusel registreerida sisestusfiltri, mis filtreerib kõigi kasutaja sündmuste voo, enne kui need ära saadetakse. Pahatahtlik rakendus võib süsteemi kasutajaliidest juhtida ilma kasutaja sekkumiseta."</string>
    <string name="permlab_magnify_display" msgid="5973626738170618775">"kuva suurendamine"</string>
    <string name="permdesc_magnify_display" msgid="7121235684515003792">"Lubab rakendusel ekraani sisu suurendada. Pahatahtlikud rakendused võivad muundada kuva sisu nii, et seade muutub ebastabiilseks."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"osaline väljalülitamine"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Lülitab tegevushalduri väljalülitusolekusse. Ei lülita lõplikult välja."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"väldi rakenduste ümberlülitamist"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Takistab kasutaja lülitumist teisele rakendusele."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"Kõigi rakenduste käivitumise jälgimine ja juhtimine"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Võimaldab rakendusel jälgida ja juhtida, kuidas süsteem tegevusi käivitab. Pahatahtlikud rakendused võivad süsteemi täielikult rikkuda. Seda õigust on vaja ainult arenduseks, mitte tavakasutuse korral."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"saada paketist eemaldatud saade"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Võimaldab rakendusel edastada teatise rakenduse paketi eemaldamise kohta. Pahatahtlikud rakendused võivad seda kasutada teiste käitatud rakenduste peatamiseks."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"saada SMS-i teel vastuvõetud saade"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Võimaldab rakendusel edastada teatise SMS-sõnumi vastuvõtmise kohta. Pahatahtlikud rakendused võivad seda kasutada sissetulevate SMS-sõnumite võltsimiseks."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"saada WAP-PUSH-vastuvõetud saateid"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Võimaldab rakendusel edastada teatise WAP PUSH-sõnumi vastuvõtmise kohta. Pahatahtlikud rakendused võivad seda kasutada MMS-sõnumite vastuvõtmise võltsimiseks või mis tahes veebilehe sisu salaja asendamiseks pahatahtlikuga."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"piira töötavate protsesside arvu"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Võimaldab rakendusel juhtida töötavate protsesside maksimaalset arvu. Tavarakenduste puhul pole seda vaja."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"sundige taustarakendused sulguma"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Võimaldab rakendusel määrata, kas tegevused lõpetatakse kohe, kui need liiguvad taustale. Tavarakenduste puhul pole seda vaja."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"aku statistika lugemine"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Lubab rakendusel lugeda madala akutaseme kasutusandmeid. Võib lubada rakendusel hankida üksikasjalikku teavet selle kohta, mis rakendusi te kasutate."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"aku statistika muutmine"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Võimaldab rakendusel muuta aku kohta kogutud statistikat. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_backup" msgid="470013022865453920">"juhi süsteemi varundust ja taastet"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Võimaldab rakendusel juhtida süsteemi varundus- ja taastemehhanismi. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"täieliku varukoopia kinnitamine või toimingu taastamine"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Võimaldab rakendusel käivitada täieliku varukoopia kinnitusliidese. Mitte kasutada üheski rakenduses."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"kuva volituseta aknad"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Võimaldab rakendusel luua aknaid, mis on mõeldud kasutamiseks süsteemisisesele kasutajaliidesele. Mitte kasutada tavarakenduste puhul."</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_setAnimationScale" msgid="2805103241153907174">"muuda üldist animatsioonikiirust"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Võimaldab rakendusel muuta animatsiooni üldist kiirust (animatsioone kiirendada või aeglustada) ükskõik millal."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"Rakenduse lubade haldamine"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Võimaldab rakendusel luua ja hallata tema enda lube, möödudes tavapärasest Z-järjekorrast. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"ekraanikuva peatamine"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"Lubab rakendusel ajutiselt peatada ekraani kuva täisekraanile üleminekuks."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"vajuta klahve ja juhtnuppe"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Võimaldab rakendusel saata oma sisendtoiminguid (klahvivajutusi jms) teistele rakendustele. Pahatahtlikud rakendused võivad seda kasutada tahvelarvuti ülevõtmiseks."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Võimaldab rakendusel saata oma sisendtoiminguid (klahvivajutusi jms) teistele rakendustele. Pahatahtlikud rakendused võivad seda kasutada telefoni ülevõtmiseks."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"salvesta sisestatav tekst ja tehtavad toimingud"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Võimaldab rakendusel vaadata vajutatavaid klahve, isegi kui suhtlete teise rakendusega (näiteks parooli sisestamisel). Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"seo sisestusmeetodiga"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Lubab omanikul siduda sisestusmeetodi ülataseme liidesega. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"sidumine juurdepääsuteenusega"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Lubab omanikul luua sideme juurdepääsuteenuse ülataseme liidesega. Tavarakenduste puhul ei tohiks seda kunagi vaja minna."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"tekstiteenusega sidumine"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Võimaldab omanikul siduda tekstiteenuse (nt SpellCheckerService) ülataseme liidesega. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"seo VPN-teenusega"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Võimaldab omanikul siduda VPN-teenuse ülataseme liidesega. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"taustapildiga sidumine"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Lubab omanikul siduda taustapildi ülataseme liidesega. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"vidinateenusega sidumine"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Lubab omanikul siduda vidina teenuse ülataseme liidesega. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"seadme administraatoriga suhtlemine"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Võimaldab omanikul saata kavatsusi seadme administraatorile. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"muuda ekraani paigutust"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Võimaldab rakendusel muuta ekraani pööramist mis tahes ajal. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"kursorikiiruse muutmine"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Võimaldab rakendusel muuta igal ajal hiire- või puutepadjakursori kiirust. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"klaviatuuri paigutuse muutmine"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Lubab rakendusel muuta klaviatuuri paigutust. Tavarakenduste puhul ei peaks kunagi vaja olema."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"Linuxi signaalide saatmine rakendustele"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Võimaldab rakendusel taotleda edastatud signaali saatmist kõigile püsiprotsessidele."</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="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_deletePackages" msgid="184385129537705938">"Rakenduste kustutamine"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Võimaldab rakendusel kustutada Android-pakette. Pahatahtlikud rakendused võivad seda kasutada oluliste rakenduste kustutamiseks."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"Teiste rakenduste andmete kustutamine"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Võimaldab rakendusel kustutada kasutaja andmed."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"Teiste rakenduste vahemälu kustutamine"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Võimaldab rakendusel kustutada vahemälu failid."</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_installPackages" msgid="2199128482820306924">"Rakenduste otse installimine"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Võimaldab rakendusel installida uusi või värskendatud Android-pakette. Pahatahtlikud rakendused võivad selle abil lisada uusi meelevaldse tegevuse lubadega rakendusi."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"Kõigi rakenduse vahemäluandmete kustutamine"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Lubab rakendusel vabastada tahvelarvuti mäluruumi, kustutades faile teiste rakenduste vahemälu kataloogides. Selle tagajärjel võivad teised rakendused käivituda aeglasemalt, sest need peavad oma andmed uuesti tooma."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Lubab rakendusel vabastada telefoni mäluruumi, kustutades faile teiste rakenduste vahemälu kataloogides. Selle tagajärjel võivad teised rakendused käivituda aeglasemalt, sest need peavad oma andmed uuesti tooma."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"Rakenduse ressursside teisaldamine"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Võimaldab rakendusel teisalda rakenduseressursid sisemiselt kandjalt välisele ja vastupidi."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"tundlike logiandmete lugemine"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Võimaldab rakendusel lugeda süsteemi erinevaid logifaile. Nii on võimalik avastada üldist teavet selle kohta, mida te tahvelarvutiga teete, sh isiklikku või privaatset teavet."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Võimaldab rakendusel lugeda süsteemi erinevaid logifaile. Nii on võimalik avastada üldist teavet selle kohta, mida te telefoniga teete, mis võib kaasata ka isiklikku või privaatset teavet."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"Mis tahes meediumidekooderi kasutamine taasesituseks"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Võimaldab rakendusel taasesituseks kasutada mis tahes installitud meediumidekooderit."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"loe/kirjuta valija allikaid"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Võimaldab rakendusel lugeda valimisrühma mis tahes ressurssi ja sellesse kirjutada (näiteks kaustas /dev olevad failid). See võib mõjutada süsteemi stabiilsust ja turvet. Seda tohiks kasutada tootja või operaator AINULT riistvaraspetsiifiliseks diagnostikaks."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"Rakenduse komponentide lubamine või keelamine"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Võimaldab rakendusel määrata, kas teise rakenduse komponent on lubatud või mitte. Pahatahtlikud rakendused võivad kasutada seda oluliste tahvelarvutirakenduste keelamiseks. Nende õiguste puhul peab olema ettevaatlik, kuna need võimaldavad muuta rakenduse komponente kasutuks, ebaühtlaseks või ebastabiilseks."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Võimaldab rakendusel määrata, kas teise rakenduse komponent on lubatud või mitte. Pahatahtlikud rakendused võivad kasutada seda oluliste telefonirakenduste keelamiseks. Nende õiguste puhul peab olema ettevaatlik, kuna need võimaldavad muuta rakenduse komponente kasutuks, ebaühtlaseks või ebastabiilseks."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"lubade andmine või tühistamine"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Võimaldab rakendusel anda või tühistada teatud lubasid endale või teistele rakendustele. Pahatahtlikud rakendused võivad kasutada seda juurdepääsu hankimiseks sellistele funktsioonidele, mille jaoks te pole luba andnud."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"Eelistatud rakenduste määramine"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Võimaldab rakendusel muuta teie eelistatud rakendusi. Pahatahtlikud rakendused võivad salaja muuta töötavaid rakendusi, pettes teie olemasolevad rakendused koguma teilt privaatseid andmeid."</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_writeSecureSettings" msgid="204676251876718288">"muuda turvalisi süsteemiseadeid"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Võimaldab rakendusel muuta süsteemi turvaseadete andmeid. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"muuda Google\'i teenustekaarti"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Võimaldab rakendusel muuta Google\'i teenustekaarti. Mitte kasutada tavarakenduste puhul."</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="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="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="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="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="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="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_readProfile" msgid="4701889852612716678">"lugege oma kontaktikaarti"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Võimaldab rakendusel lugeda seadmesse salvestatud isiklikku profiiliteavet, näiteks teie nime ja kontaktteavet. See tähendab, et rakendus saab teid tuvastada ja saata teie profiiliteavet teistele."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"muutke oma kontaktikaarti"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Võimaldab rakendusel muuta või lisada seadmesse salvestatud isiklikku profiiliteavet, näiteks teie nime ja kontaktteavet. See tähendab, et rakendus saab teid tuvastada ja saata teie profiiliteavet teistele."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"Sotsiaalvoo lugemine"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Annab rakendusele juurdepääsu ja võimaldab sünkroonida teie ja teie sõprade sotsiaalseid värskendusi. Olge teabe jagamisel ettevaatlik – see võimaldab rakendusel lugeda teie suhtlusi sõpradega suhtlusvõrgustikes konfidentsiaalsusest hoolimata. Märkus: see luba ei pruugi jõustuda kõigis suhtlusvõrgustikes."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"Sotsiaalvoogu kirjutamine"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Võimaldab rakendusel kuvada sõprade sotsiaalseid värskendusi. Olge teabe jagamisel ettevaatlik – see võimaldab rakendusel luua sõnumeid, mis võivad näida tulevat sõpradelt. Märkus: see luba ei pruugi jõustuda kõikides suhtlusvõrgustikes."</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="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="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_accessMockLocation" msgid="8688334974036823330">"võltsasukohad testimiseks"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Looge võltsasukoha allikaid, et katsetada või installida uut asukohapakkujat. See lubab rakendusel tühistada teiste asukohaallikate, näiteks GPS-i või asukohapakkujate tagastatud asukoha ja/või oleku."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"juurdepääs asukohapakkuja lisakäskudele"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"Võimaldab rakendusel pääseda juurde asukohapakkuja erikäskudele. See võib lubada rakendusel segada GPS-i või muude asukohaallikate tööd."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"luba asukohapakkuja installimiseks"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Looge võltsasukoha allikaid, et katsetada või installida uut asukohapakkujat. See lubab rakendusel tühistada teiste asukohaallikate, näiteks GPS-i või asukohapakkujate tagastatud asukoha ja/või oleku."</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_accessSurfaceFlinger" msgid="2363969641792388947">"juurdepääs SurfaceFlingerile"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Võimaldab rakendusel kasutada SurfaceFlingeri madalatasemelisi funktsioone."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"loe kaadripuhvrit"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Võimaldab rakendusel kaadripuhvri sisu lugeda."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"WiFi-ekraanide seadistamine"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"Lubab rakendusel seadistada WiFi-ekraane ja nendega ühendus luua."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"WiFi-ekraanide juhtimine"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"Lubab rakendusel juhtida WiFi-ekraanide madala taseme funktsioone."</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_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_brick" product="tablet" msgid="2961292205764488304">"blokeeri tahvelarvuti jäädavalt"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"blokeeri telefon jäädavalt"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Võimaldab rakendusel kogu tahvelarvuti jäädavalt keelata. See on väga ohtlik."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Võimaldab rakendusel kogu telefoni jäädavalt keelata. See on väga ohtlik."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"sunni tahvelarvuti taaskäivituma"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"sunni telefoni taaskäivitus"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Võimaldab rakendusel sundida tahvelarvutit taaskäivituma."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Võimaldab rakendusel sundida telefoni taaskäivituma."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"juurdep. USB-ruumi failisüst."</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"juurdepääs SD-kaardi failisüsteemile"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Võimaldab rakendusel failisüsteeme irdmällu paigaldada ja sealt lahutada."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"tühjendage USB-salvestusruum"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"tühjendage SD-kaart"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Võimaldab rakendusel vormindada irdmälu."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"hangi teavet sisemälu kohta"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Võimaldab rakendusel hankida sisemälu teavet."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"sisemälu loomine"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Lubab rakendusel luua sisemälu."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"hävita sisemälu"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Lubab rakendusel sisemälu hävitada."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"Sisemälu paigaldamine/eemaldamine"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Võimaldab rakendusel sisemäluseadme paigaldada/eraldada."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"sisemälu ümbernimetamine"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Võimaldab rakendusel sisemälu ümber nimetada."</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_manageUsb" msgid="1113453430645402723">"USB-seadmete eelistuste ja lubade haldamine"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Võimaldab rakendusel hallata USB-seadmete eelistusi ja lube."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"MTP-protokolli rakendamine"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Lubab juurdepääsu tuuma MTP-draiverile MTP USB-protokolli rakendamiseks."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"testi riistvara"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Võimaldab rakendusel juhtida erinevaid välisseadmeid riistvara testimise eesmärgil."</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>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"helista otse mis tahes telefoninumbritele"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Võimaldab rakendusel helistada mis tahes telefoninumbrile, sh hädaabinumbritele ilma teie sekkumiseta. Pahatahtlikud rakendused võivad teha hädaabiteenustele mittevajalikke ja ebaseaduslikke kõnesid."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"käivita otse CDMA-tahvelarvuti seadistamine"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"CDMA-telefoniseadistuse otse käivitamine"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Võimaldab rakendusel käivitada CDMA ettevalmistamise. Pahatahtlikud rakendused võivad CDMA ettevalmistamise asjatult käivitada."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"kontrolli asukoha värskendamise teatisi"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Võimaldab rakendusel lubada/keelata asukoha värskendamise teatised raadiost. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"juurdepääs registreerimisatribuutidele"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Annab rakendusele lugemis-/kirjutusõiguse registreerimisteenusega üles laaditud atribuutidele. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"vali vidinaid"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Võimaldab rakendusel öelda süsteemile, milline rakendus saab kasutada milliseid vidinaid. Selle õigusega rakendus võib anda teistele rakendustele juurdepääsu isiklikele andmetele. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"muuda telefoni olekut"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Võimaldab rakendusel juhtida seadme telefonifunktsioone. Selle loaga rakendus saab vahetada võrke, lülitada telefoniraadiot sisse ja välja ning teha muudki ilma teid teavitamata."</string>
    <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="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="default" msgid="8559100677372928754">"Võimaldab rakendusel vältida telefoni uinumist."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"lülita tahvelarvuti sisse või välja"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"lülita telefon sisse või välja"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Võimaldab rakendusel tahvelarvutit sisse või välja lülitada."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Võimaldab rakendusel telefoni sisse või välja lülitada."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"käivita tehase testrežiimis"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Käitage madalatasemelise tootjatestina, mis annab täieliku juurdepääsu tahvelarvuti riistvarale. Saadaval ainult siis, kui tahvelarvuti töötab tootjatesti režiimis."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Käivitage madalatasemelise tootjatestina, mis võimaldab täielikku juurdepääsu telefoni riistvarale. Kasutatav ainult juhul, kui telefon töötab tootja testrežiimis."</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_masterClear" msgid="2315750423139697397">"lähtesta süsteem tehase vaikeseadetele"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Võimaldab rakendusel süsteemi tehaseseaded täielikult lähtestada, kustutades kõik andmed, konfiguratsiooni ja installitud rakendused."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"kellaaja määramine"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Võimaldab rakendusel muuta tahvelarvuti kellaaega."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Võimaldab rakendusel muuta telefoni kellaaega."</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="default" msgid="4499943488436633398">"Võimaldab rakendusel muuta telefoni ajavööndit."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"AccountManagerService\'ina tegutsemine"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Võimaldab rakendusel helistada konto autentijatele."</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="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_authenticateAccounts" msgid="5265908481172736933">"looge kontod ja määrake paroolid"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Võimaldab rakendusel kasutada kontohalduri konto autentija võimalusi, sh luua kontosid ning hankida ja määrata paroole."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"lisage või eemaldage kontosid"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Võimaldab rakendusel teha toiminguid, nagu kontode lisamine ja eemaldamine ning nende paroolide kustutamine."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"kasutage seadmes olevaid kontosid"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Võimaldab rakendusel taotleda autentimise lubasid."</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_writeApnSettings" msgid="505660159675751896">"võrguseadete ja -liikluse muutmine/hõivamine"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Võimaldab rakendusel muuta võrguseadeid ning peatada ja kontrollida kogu võrguliiklust, näiteks muuta mis tahes APN-i puhverserverit ja porti. Pahatahtlikud rakendused võivad võrgupakette jälgida, ümber suunata või muuta teie teadmata."</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_changeBackgroundDataSetting" msgid="1400666012671648741">"muuda taustaandmete kasutusseadeid"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Võimaldab rakendusel muuta taustaandmete kasutuse seadeid."</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="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="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="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="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_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_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_subscribedFeedsWrite" msgid="9015246325408209296">"kirjuta tellitud kanaleid"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Võimaldab rakendusel muuta teie praegu sünkroonitud vooge. Pahatahtlikud rakendused võivad muuta teie sünkroonitud vooge."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"lugege termineid, mis te sõnastikku lisasite"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Võimaldab rakendusel lugeda kõiki sõnu, nimesid ja fraase, mille kasutaja on kasutaja sõnaraamatusse salvestanud."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"sõnade lisamine kasutaja määratletud sõnastikku"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Võimaldab rakendusel kirjutada kasutajasõnastikku uusi sõnu."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="8235341515605559677">"kaitstud salvestusruumi juurdepääsu katsetamine"</string>
    <string name="permlab_sdcardRead" product="default" msgid="8235341515605559677">"kaitstud salvestusruumi juurdepääsu katsetamine"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3642473292348132072">"Võimaldab rakendusel testida luba USB-salvestuseks, mis on saadaval tulevastes seadmetes."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="5914402684685848828">"Võimaldab rakendusel katsetada SD-kaardi luba, mis on saadaval tulevastel seadmetel."</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_mediaStorageWrite" product="default" msgid="6859839199706879015">"sisemälu sisu muutm./kustut."</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Võimaldab rakendusel muuta sisemise andmekandja sisu."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"juurdepääs välismäluseadmele (kõikidele kasutajatele)"</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Võimaldab rakenduse kõikidel kasutajatel pöörduda välismäluseadme poole."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"juurdepääs vahemälu failisüsteemile"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Võimaldab rakendusel vahemälu failisüsteemi lugeda ja kirjutada."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"Interneti-kõnede tegemine/vastuvõtmine"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Võimaldab rakendusel kasutada SIP-teenust Interneti-kõnede valimiseks/vastuvõtmiseks."</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="policylab_limitPassword" msgid="4497420728857585791">"Parooli reeglite määramine"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Kontrollige ekraaniluku avamise paroolide pikkust ja tähemärke."</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="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="policylab_resetPassword" msgid="2620077191242688955">"Ekraaniluku parooli muutmine"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Ekraaniluku parooli muutmine."</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="default" msgid="5096895604574188391">"Kustuta telefoniandmed hoiatuseta, lähtestades telefoni tehaseandmetele."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Määra seadme globaalne puhverserver"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Eeskirjade lubamise ajal kasutatava seadme globaalse puhverserveri määramine. Ainult esimese seadme administraator määrab tõhusa globaalse puhverserveri."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Ekraaniluku parooli aegumise määramine"</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Määrake ekraaniluku parooli muutmissagedus."</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="266329104542638802">"Klahviluku funkts. keelamine"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Takistage klahviluku 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="3808393979157698766">"Google Talk"</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="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="5347633784401285225">"Hädaabikõne"</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_plugged_in" msgid="8057762828355572315">"Laadimine, <xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Laetud"</string>
    <string name="lockscreen_battery_short" msgid="4477264849386850266">"<xliff:g id="NUMBER">%d</xliff:g> <xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_low_battery" msgid="1482873981919249740">"Ühendage laadija."</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="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="201594905152746886">"Eelmise loo nupp"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Nupp Järgmine rada"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Nupp Peata"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Nupp Esita"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Nupp Peata"</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\n"Proovige <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\n"Proovige <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\n"Proovige <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="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="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="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?"\n"Kü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_detected" msgid="4988730895554057058">"Muster on valmis"</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" msgid="730366588032430474">"Kas soovite sellelt lehelt lahkuda?"\n\n"<xliff:g id="MESSAGE">%s</xliff:g>"\n\n"Jätkamiseks puudutage valikut OK, praegusele lehele jäämiseks valikut Tühista."</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="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="permlab_packageVerificationAgent" msgid="5568139100645829117">"pakettide kinnitamine"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Võimaldab rakendusel kinnitada, et paketti saab installida."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"sidumine paketi kinnitajaga"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Lubab omanikul teha taotlusi paketi kinnitajate kohta. Tavarakenduste puhul ei peaks seda kunagi vaja minema."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"juurdepääs jadaportidele"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Võimaldab omanikul SerialManageri API-liidese abil jadaportidele juurde pääseda."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"väline juurdepääs sisupakkujatele"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Võimaldab valdajal hankida juurdepääsu sisupakkujatele kesta kaudu. Pole kunagi vajalik tavaliste rakenduste puhul."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"seadme autom. värskendamiste takistamine"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Võimaldab valdajal pakkuda süsteemile teavet selle kohta, kas on sobiv aeg mitteinteraktiivseks taaskäivitamiseks, et viia seade üle uuele versioonile."</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="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="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"1 sekund tagasi"</item>
    <item quantity="other" msgid="3903706804349556379">"<xliff:g id="COUNT">%d</xliff:g> sekundit tagasi"</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"1 minut tagasi"</item>
    <item quantity="other" msgid="2176942008915455116">"<xliff:g id="COUNT">%d</xliff:g> minutit tagasi"</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"1 tund tagasi"</item>
    <item quantity="other" msgid="2467273239587587569">"<xliff:g id="COUNT">%d</xliff:g> tundi tagasi"</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Viimased <xliff:g id="COUNT">%d</xliff:g> päeva"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Eelmisel kuul"</string>
    <string name="older" msgid="5211975022815554840">"Vanem"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"eile"</item>
    <item quantity="other" msgid="2479586466153314633">"<xliff:g id="COUNT">%d</xliff:g> päeva tagasi"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"1 sekundi pärast"</item>
    <item quantity="other" msgid="1241926116443974687">"<xliff:g id="COUNT">%d</xliff:g> sekundi pärast"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"1 minuti pärast"</item>
    <item quantity="other" msgid="3330713936399448749">"<xliff:g id="COUNT">%d</xliff:g> minuti pärast"</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"1 tunni pärast"</item>
    <item quantity="other" msgid="547290677353727389">"<xliff:g id="COUNT">%d</xliff:g> tunni pärast"</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"homme"</item>
    <item quantity="other" msgid="5109449375100953247">"<xliff:g id="COUNT">%d</xliff:g> päeva pärast"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"1 s tagasi"</item>
    <item quantity="other" msgid="3699169366650930415">"<xliff:g id="COUNT">%d</xliff:g> sekundit tagasi"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"1 minut tagasi"</item>
    <item quantity="other" msgid="851164968597150710">"<xliff:g id="COUNT">%d</xliff:g> minutit tagasi"</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"1 tund tagasi"</item>
    <item quantity="other" msgid="6889970745748538901">"<xliff:g id="COUNT">%d</xliff:g> tundi tagasi"</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"eile"</item>
    <item quantity="other" msgid="3453342639616481191">"<xliff:g id="COUNT">%d</xliff:g> päeva tagasi"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"1 sekundi pärast"</item>
    <item quantity="other" msgid="5495880108825805108">"<xliff:g id="COUNT">%d</xliff:g> sekundi pärast"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"1 minuti pärast"</item>
    <item quantity="other" msgid="4216113292706568726">"<xliff:g id="COUNT">%d</xliff:g> minuti pärast"</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"1 tunni pärast"</item>
    <item quantity="other" msgid="3705373766798013406">"<xliff:g id="COUNT">%d</xliff:g> tunni pärast"</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"homme"</item>
    <item quantity="other" msgid="2973062968038355991">"<xliff:g id="COUNT">%d</xliff:g> päeva pärast"</item>
  </plurals>
    <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">
    <item quantity="one" msgid="6962015528372969481">"1 sekund"</item>
    <item quantity="other" msgid="1886107766577166786">"<xliff:g id="COUNT">%d</xliff:g> sekundit"</item>
  </plurals>
  <plurals name="duration_minutes">
    <item quantity="one" msgid="4915414002546085617">"1 minut"</item>
    <item quantity="other" msgid="3165187169224908775">"<xliff:g id="COUNT">%d</xliff:g> minutit"</item>
  </plurals>
  <plurals name="duration_hours">
    <item quantity="one" msgid="8917467491248809972">"1 tund"</item>
    <item quantity="other" msgid="3863962854246773930">"<xliff:g id="COUNT">%d</xliff:g> tundi"</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="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="alwaysUse" msgid="4583018368000610438">"Kasuta vaikimisi selleks toiminguks."</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\n"Kas soovite selle sulgeda?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Tegevus <xliff:g id="ACTIVITY">%1$s</xliff:g> ei vasta."\n\n"Kas 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\n"Kas 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\n"Kas 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_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_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="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">
    <item quantity="one" msgid="6654123987418168693">"WiFi-võrk on saadaval"</item>
    <item quantity="other" msgid="4192424489168397386">"WiFi-võrgud saadaval"</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"Avatud WiFi võrk on saadaval"</item>
    <item quantity="other" msgid="7915895323644292768">"Avatud WiFi-võrgud on saadaval"</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Logige sisse WiFi-võrku"</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Logige võrku"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <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_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" 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="3492025719868078457">"See "<font fgcolor="#ffffb060">"võib põhjustada kulusid"</font>" teie mobiilikontole."</string>
    <string name="sms_premium_short_code_details" msgid="5523826349105123687"><font fgcolor="#ffffb060">"See lisab kulusid teie mobiilikontole."</font></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="2333164559970958645">"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="6599945301141050216">"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_mtp_notification_title" msgid="3699913097391550394">"Ühendatud meediumiseadmena"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Ühendatud kaamerana"</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="2290859399983720271">"Puudutage teisi USB valikuid."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Vormind. USB-seade?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Kas vormindada SD-kaart?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Kõik USB-mäluseadmele salvestatud failid kustutatakse. Seda toimingut ei saa tagasi võtta."</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Kõik kaardil olevad andmed lähevad kaduma."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Vorminda"</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="4653387336791222978">"Valige sisestusmeetod"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Seadista sisestusmeetodid"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Füüsiline klaviatuur"</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" product="nosdcard" msgid="3449816005351468560">"USB-mäluseadme ettevalm. ..."</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"SD-kaardi ettevalmistamine"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Vigade kontrollimine."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Tühi USB-mäluseade"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Tühi SD-kaart"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"USB-salvestusruum on tühi või ei toeta failisüsteemi."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"SD-kaart on tühi või ei toetata selle failisüsteemi."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Kahjustatud USB-mäluseade"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Kahjustatud SD-kaart"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"USB-salvestusruum on kahjustatud. Proovige uuesti vormindada."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"SD-kaart on kahjustatud. Proovige uuesti vormindada."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"USB-seade eemaldati ootamatult"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"SD-kaart on ootamatult eemaldatud"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Andmekao vältimiseks lahutage USB-mäluseade enne eemaldamist."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Andmekao vältimiseks lahutage SD-kaart enne eemaldamist."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"USB-seadme eemaldamine ohutu"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"SD-kaardi eemaldamine on ohutu"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"Saate USB-mäluseadme ohutult eemaldada."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"SD-kaardi saate ohutult eemaldada."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"USB-mäluseade eemaldatud"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Eemaldatud SD-kaart"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"USB-mäluseade eemaldatud. Sisestage uus meedium."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"SD-kaart on eemaldatud. Sisestage uus."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Sobivat tegevust ei leitud"</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"värskenda komponentide kasutusstatistikat"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Võimaldab rakendusel muuta komponendi kohta kogutud kasutusstatistikat. Mitte kasutada tavarakenduste puhul."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"Sisu kopeerimine"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Võimaldab rakendusel võtta sisu kopeerimiseks appi vaikekonteinerteenuse. Mitte kasutada tavarakenduste puhul."</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="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"\n"numbriga <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"\n"kontole <xliff:g id="ACCOUNT">%s</xliff:g>."</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="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_reset" msgid="5365010427963548932">"Ühenduse lähtestamiseks puudutage"</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="throttle_warning_notification_title" msgid="4890894267454867276">"Kõrge mobiilse andmeside kasutus"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Mobiilse andmeside kasutamise kohta lisateabe saamiseks puudutage."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Mobiili andmemahupiirang ületatud"</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Mobiilse andmeside kasutamise kohta lisateabe saamiseks puudutage."</string>
    <string name="no_matches" msgid="8129421908915840737">"Vasted puuduvad"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Otsige lehelt"</string>
  <plurals name="matches_found">
    <item quantity="one" msgid="8167147081136579439">"1 vaste"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g>/<xliff:g id="TOTAL">%d</xliff:g>"</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="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="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_direction_up" msgid="7169032478259485180">"Lohistage üles: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Lohistage alla: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Lohistage vasakule: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Lohistage paremale: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Luku avamine"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Kaamera"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Hääletu"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Heli on sees"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Otsing"</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="storage_internal" msgid="4891916833657929263">"Sisemine salvestusruum"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD-kaart"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB-mäluseade"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Muuda"</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="7093334419518706686">"2G–3G-andmeside on keelatud"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"4G-andmeside on keelatud"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Mobiilne andmeside on keelatud"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"WiFi-andmed on keelatud"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Lubamiseks puudutage."</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="279240572165412168">"Mobiilne andmemahupiirang ü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="status_bar_device_locked" msgid="3092703448690669768">"Seade lukustatud."</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="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tahvelarvuti"</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="media_route_chooser_grouping_done" msgid="7966438307723317169">"Valmis"</string>
    <string name="media_route_button_content_description" msgid="5758553567065145276">"Meediaväljund"</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="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="wifi_display_notification_title" msgid="2223050649240326557">"Juhtmeta ekraaniühendus on loodud"</string>
    <string name="wifi_display_notification_message" msgid="4498802012464170685">"Ekraan on näha teises seadmes"</string>
    <string name="wifi_display_notification_disconnect" msgid="6183754463561153372">"Katkesta ühendus"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Hädaabikõne"</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">%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="7553388325654369575">"PUK-koodi pikkus peab olema vähemalt 8 numbrit."</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?"\n"Kü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\n"Proovige <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\n"Proovige 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\n"Proovige <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="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="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="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="7382971871993371648">"Kas suurendada helitugevust üle ohutu piiri?"\n"Pikaajaline suure helitugevusega muusika kuulamine võib kahjustada kuulmist."</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="owner_name" msgid="2716755460376028154">"Omanik"</string>
</resources>
