<?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;Bez nosaukuma&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Nav tālruņa numura)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Nezināms)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Balss pasts"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Savienojuma problēma vai nederīgs MMI kods."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Darbība ir atļauta tikai fiksēto numuru sastādīšanai."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Pakalpojums tika iespējots."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Pakalpojums tika iespējots šādai pakalpojumu klasei:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Pakalpojums ir atspējots."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Reģistrācija bija veiksmīga."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Dzēšana bija veiksmīga."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Nepareiza parole."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI ir pabeigts."</string>
    <string name="badPin" msgid="9015277645546710014">"Ievadītais iepriekšējais PIN nav pareizs."</string>
    <string name="badPuk" msgid="5487257647081132201">"Ievadītais PUK kods nav pareizs."</string>
    <string name="mismatchPin" msgid="609379054496863419">"Ievadītie PIN neatbilst."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Ierakstiet PIN, kas sastāv no 4 līdz 8 cipariem."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Ierakstiet PUK kodu, kas sastāv no 8 vai vairāk cipariem."</string>
    <string name="needPuk" msgid="919668385956251611">"SIM karte ir bloķēta ar PUK kodu. Ierakstiet PUK kodu, lai to atbloķētu."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Ierakstiet PUK2 kodu, lai atbloķētu SIM karti."</string>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Ienākošā zvana zvanītāja ID"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Izejošā zvana zvanītāja ID"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Zvanu pāradresācija"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Zvana gaidīšana"</string>
    <string name="BaMmi" msgid="455193067926770581">"Zvanu aizliegšana"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Paroles maiņa"</string>
    <string name="PinMmi" msgid="3113117780361190304">"PIN maiņa"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Tiek rādīts numurs, uz kuru tiek zvanīts"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Zvanīšana uz numuru ir ierobežota."</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Trīsvirzienu zvanīšana"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Nevēlamu traucējošu zvanu noraidīšana"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Zvanīšanas numuru piegāde"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Netraucēt"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Zvanītāja ID noklusējuma vērtība ir Ierobežots. Nākamais zvans: ierobežots."</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Zvanītāja ID noklusējumi ir iestatīti uz Ierobežots. Nākamais zvans: nav ierobežots"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Zvanītāja ID noklusējumi ir iestatīti uz Nav ierobežots. Nākamais zvans: ierobežots"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Zvanītāja ID noklusējumi ir iestatīti uz Nav ierobežots. Nākamais zvans: nav ierobežots"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Pakalpojums netiek nodrošināts."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Zvanītāja ID iestatījumu nevar mainīt."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Ierobežotā piekļuve ir mainīta"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Datu pakalpojums ir bloķēts."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Ārkārtas pakalpojums ir bloķēts."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Balss pakalpojums ir bloķēts."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Visi balss pakalpojumi ir bloķēti."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"Īsziņu pakalpojums ir bloķēts."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Balss/datu pakalpojumi ir bloķēti."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Balss/īsziņu pakalpojumi ir bloķēti."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Visi balss/datu/īsziņu pakalpojumi ir bloķēti."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Voice"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Dati"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAKSS"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"Īsziņa"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Asinhroni dati"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sinhronizācija"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Pakete"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Viesabonēšanas indikators ir ieslēgts."</string>
    <string name="roamingText1" msgid="5314861519752538922">"Viesabonēšanas indikators ir izslēgts."</string>
    <string name="roamingText2" msgid="8969929049081268115">"Viesabonēšanas indikators mirgo"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Ārpus apkaimes"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Ārpus ēkas"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Viesabonēšana — vēlamā sistēma"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Viesabonēšana — pieejamā sistēma"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Viesabonēšana — apvienības partneris"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Viesabonēšana — ekskluzīvs partneris"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Viesabonēšana — pakalpojuma pilnīga funkcionalitāte"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Viesabonēšana — pakalpojuma daļēja funkcionalitāte"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Viesabonēšanas reklāmkarogs ir ieslēgts."</string>
    <string name="roamingText12" msgid="1189071119992726320">"Viesabonēšanas reklāmkarogs ir izslēgts."</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Pakalpojuma meklēšana"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nav pāradresēts"</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> pēc <xliff:g id="TIME_DELAY">{2}</xliff:g> sekundes(-ēm)"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nav pāradresēts"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nav pāradresēts"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Funkcijas kods ir pabeigts."</string>
    <string name="fcError" msgid="3327560126588500777">"Savienojuma problēma vai nederīgs funkcijas kods."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"Labi"</string>
    <string name="httpError" msgid="7956392511146698522">"Radās tīkla kļūda."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Nevarēja atrast URL."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Vietnes autentifikācijas shēma netiek atbalstīta."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Nevarēja autentificēt."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Autentifikācija, izmantojot starpniekserveri, nebija veiksmīga."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Nevarēja izveidot savienojumu ar serveri."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Neizdevās sazināties ar serveri. Vēlāk mēģiniet vēlreiz."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Savienojumam ar serveri radās noildze."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Lapā ir pārāk daudz servera novirzīšanu."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokols netiek atbalstīts."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Nevarēja izveidot drošu savienojumu."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Nevarēja atvērt lapu, jo URL nav derīgs."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Nevarēja piekļūt failam."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Nevarēja atrast pieprasīto failu."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Tiek apstrādāts pārāk liels pieprasījumu skaits. Vēlāk mēģiniet vēlreiz."</string>
    <string name="notification_title" msgid="8967710025036163822">"Pierakstīšanās kļūda kontā <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sinhronizācija"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Sinhronizācija"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Pārāk daudz <xliff:g id="CONTENT_TYPE">%s</xliff:g> dzēsto vienumu."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Planšetdatora atmiņa ir pilna. Dzēsiet dažus failus, lai atbrīvotu vietu."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Tālruņa atmiņa ir pilna! Dzēsiet dažus failus, lai atbrīvotu vietu."</string>
    <string name="me" msgid="6545696007631404292">"Man"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Planšetdatora opcijas"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Tālruņa opcijas"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Klusuma režīms"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Ieslēgt bezvadu tīklu"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Izslēgt bezvadu tīklu"</string>
    <string name="screen_lock" msgid="799094655496098153">"Bloķēt ekrānu"</string>
    <string name="power_off" msgid="4266614107412865048">"Strāvas padeve ir izslēgta."</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Zvanītājs izslēgts"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Zvanītājs vibrācijas režīmā"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Zvanītājs ieslēgts"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Notiek izslēgšana..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Planšetdators tiks beidzēts."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Tālrunis tiks izslēgts."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Vai vēlaties izslēgt?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Atsāknēšana drošajā režīmā"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Vai vēlaties veikt atsāknēšanu drošajā režīmā? Tādējādi tiks atspējotas visas instalētās trešo pušu lietojumprogrammas. To darbība tiks atjaunota, kad vēlreiz veiksiet atsāknēšanu."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Nesens"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Nav nesen izmantotu lietotņu."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Planšetdatora opcijas"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Tālruņa opcijas"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Ekrāna bloķētājs"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Strāvas padeve ir izslēgta."</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Kļūdu ziņojums"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Kļūdu ziņojuma sagatavošana"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Veicot šo darbību, tiks apkopota informācija par jūsu ierīces pašreizējo stāvokli un nosūtīta e-pasta ziņojuma veidā. Kļūdu ziņojuma pabeigšanai un nosūtīšanai var būt nepieciešams laiks. Lūdzu, esiet pacietīgs."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Klusuma režīms"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Skaņa ir IZSLĒGTA."</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Skaņa ir IESLĒGTA."</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Lidojuma režīms"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Lidojuma režīms ir IESLĒGTS."</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Lidojuma režīms ir IZSLĒGTS."</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"Pārsniedz"</string>
    <string name="safeMode" msgid="2788228061547930246">"Drošais režīms"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Android sistēma"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Maksas pakalpojumi"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Veikt darbības, par kurām, iespējams, būs jāmaksā."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Jūsu ziņojumi"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Lasiet un rakstiet īsziņas, e-pasta un citus ziņojumus."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Personas informācija"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Tieša piekļuve jūsu vizītkartē saglabātajai informācijai par jums."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Jūsu sociālo tīklu informācija"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Tieša piekļuve informācijai par jūsu kontaktpersonām un sociālajiem savienojumiem."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Jūsu atrašanās vieta"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Pārrauga jūsu fizisko atrašanās vietu."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Tīkla sakari"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Piekļūst dažādām tīkla funkcijām."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Piekļūt ierīcēm vai tīkliem, izmantojot tehnoloģiju Bluetooth."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Audio iestatījumi"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Audio iestatījumu maiņa."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"Ietekme uz akumulatora darbību"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Tādu funkciju izmantošana, kas patērē daudz akumulatora enerģijas."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendārs"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Tieša piekļuve kalendāram un pasākumiem."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Lietotāja vārdnīcas lasīšana"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Lasīt vārdus lietotāja vārdnīcā."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Rakstīšana lietotāja vārdnīcā"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Pievienot vārdus lietotāja vārdnīcai."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Grāmatzīmes un vēsture"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Tieša piekļuve grāmatzīmēm un pārlūkprogrammas vēsturei."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Signāls"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"Modinātājpulksteņa iestatīšana."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Balss pasts"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Tieša piekļuve balss pastam."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofons"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Tieša piekļuve mikrofonam, lai ierakstītu audio."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Kamera"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Tieša piekļuve kamerai, lai uzņemtu attēlus vai videoklipus."</string>
    <string name="permgrouplab_screenlock" msgid="8275500173330718168">"Ekrāna bloķēšana"</string>
    <string name="permgroupdesc_screenlock" msgid="7067497128925499401">"Spēja ietekmēt bloķēšanas ekrāna darbību jūsu ierīcē."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Informācija par jūsu lietojumprogrammām"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Spēja ietekmēt citu ierīcē esošo lietojumprogrammu darbību."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Fona tapete"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"Ierīces fona tapetes iestatījumu maiņa."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Pulkstenis"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"Ierīces laika vai laika joslas maiņa."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Statusa josla"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"Ierīces statusa joslas iestatījumu maiņa."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Sinhronizācijas iestatījumi"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Pieeja sinhronizācijas iestatījumiem."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Jūsu konti"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Piekļūstiet pieejamajiem kontiem."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Aparatūras vadīklas"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Tieša piekļuve aparatūrai klausulē."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Tālruņa zvani"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Pārraugiet, ierakstiet un apstrādājiet tālruņa zvanus."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Sistēmas rīki"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Sistēmas apakšējā līmeņa piekļuve un vadība."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Izstrādes rīki"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Tikai lietotņu izstrādātājiem nepieciešamās funkcijas."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Citu lietojumprogrammu lietotāja saskarnes"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"Ietekme uz citu lietojumprogrammu lietotāja saskarni."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Krātuve"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Piekļūst USB krātuvei."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Piekļūstiet SD kartei."</string>
    <string name="permgrouplab_accessibilityFeatures" msgid="7919025602283593907">"Pieejamības funkcijas"</string>
    <string name="permgroupdesc_accessibilityFeatures" msgid="4205196881678144335">"Funkcijas, kuras palīgtehnoloģija var pieprasīt."</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Izgūt loga saturu."</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Skatīt tā loga saturu, ar kuru mijiedarbojaties."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Aktivizēt funkciju “Pārlūkot pieskaroties”."</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Tiks izrunāti to vienumu nosaukumi, kuriem pieskarsieties, un ekrānu varēsiet pārlūkot ar žestiem."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Ieslēgt uzlaboto tīmekļa pieejamību."</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Var tikt instalēti skripti, lai padarītu lietotņu saturu pieejamāku."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Skatīt ierakstīto tekstu."</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Ietver personas datus, piemēram, kredītkartes numurus un paroles."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"atspējot vai pārveidot statusa joslu"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Ļauj lietotnei atspējot statusa joslu vai pievienot un noņemt sistēmas ikonas."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"statusa josla"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Ļauj lietotnei būt par statusa joslu."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"izvērst/sakļaut statusa joslu"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Ļauj lietotnei izvērst vai sakļaut statusa joslu."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"pārmaršrutēt izejošos zvanus"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Ļauj lietotnei apstrādāt izejošos zvanus un mainīt numuru, uz kuru tiks zvanīts. Ar šo atļauju lietotne var pārraudzīt, novirzīt vai neatļaut izejošos zvanus."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"saņemt īsziņas (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Ļauj lietotnei saņemt un apstrādāt īsziņas. Tas nozīmē, ka lietotne var pārraudzīt vai dzēst uz jūsu ierīci nosūtītos ziņojumus, neparādot tos jums."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"saņemt ziņojumus (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Ļauj lietotnei saņemt un apstrādāt multiziņas. Tas nozīmē, ka lietotne var pārraudzīt vai dzēst uz jūsu ierīci nosūtītos ziņojumus, neparādot tos jums."</string>
    <string name="permlab_receiveEmergencyBroadcast" msgid="1803477660846288089">"Ārkārtas apraižu saņemšana"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Ļauj lietotnei saņemt un apstrādāt ārkārtas apraides ziņojumus. Šī atļauja attiecas tikai uz sistēmas lietotnēm."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"šūnu apraides ziņojumu lasīšana"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Ļauj lietotnei lasīt ierīcē saņemtos šūnu apraides ziņojumus. Šūnu apraides brīdinājumi tiek piegādāti dažās atrašanās vietās, lai brīdinātu jūs par ārkārtas situācijām. Ļaunprātīgas lietotnes var traucēt ierīces veiktspēju vai darbības, kad ir saņemts ārkārtas šūnas apraides ziņojums."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"sūtīt īsziņas"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Ļauj lietotnei sūtīt īsziņas. Tas var radīt neparedzētas izmaksas. Ļaunprātīgas lietotnes var radīt jums izmaksas, sūtot ziņojumus bez jūsu apstiprinājuma."</string>
    <string name="permlab_sendRespondViaMessageRequest" msgid="8713889105305943200">"nosūtīt “atbildēt ziņojumā” notikumus"</string>
    <string name="permdesc_sendRespondViaMessageRequest" msgid="7107648548468778734">"Ļauj lietotnei nosūtīt pieprasījumus citām ziņojumapmaiņas lietotnēm par “atbildēt ziņojumā” notikumu apstrādi ienākošajiem zvaniem."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"lasīt ziņojumus (SMS vai MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Ļauj lietotnei lasīt planšetdatorā vai SIM kartē saglabātās īsziņas. Tas ļauj lietotnei lasīt visas īsziņas, neraugoties uz to saturu vai konfidencialitāti."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Ļauj lietotnei lasīt tālrunī vai SIM kartē saglabātās īsziņas. Tas ļauj lietotnei lasīt visas īsziņas, neraugoties uz to saturu vai konfidencialitāti."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"rediģēt ziņojumus (SMS vai MMS)"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Ļauj lietotnei rakstīt īsziņās, kas ir saglabātas planšetdatorā vai SIM kartē. Ļaunprātīgas lietotnes var dzēst jūsu ziņojumus."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Ļauj lietotnei rakstīt īsziņās, kas ir saglabātas tālrunī vai SIM kartē. Ļaunprātīgas lietotnes var dzēst jūsu ziņojumus."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"saņemt īsziņas (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Ļauj lietotnei saņemt un apstrādāt WAP ziņojumus. Šī atļauja ietver iespēju pārraudzīt vai dzēst jums nosūtītos ziņojumus, neparādot tos jums."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"izgūt izmantotās lietotnes"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Ļauj lietotnei izgūt informāciju par pašreiz un nesen darbinātajiem uzdevumiem. Tādējādi lietotne var atklāt informāciju par ierīcē izmantotajām lietojumprogrammām."</string>
    <string name="permlab_interactAcrossUsers" msgid="7114255281944211682">"darboties visos lietotāju kontos"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Ļauj lietotnei veikt darbības vairāku ierīces lietotāju kontos. Ļaunprātīgas lietotnes var izmantot šo atļauju, lai apdraudētu lietotāju kontu drošību."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"pilna licence ar atļauju darboties visos lietotāju kontos"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Ļauj veikt jebkādas darbības visos lietotāju kontos."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"Lietotāju pārvaldība"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Ļauj lietotnēm pārvaldīt ierīces lietotājus, tostarp izveidot un dzēst lietotājus un veidot vaicājumus."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"Informācijas izguve par izmantotajām lietotnēm"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Ļauj lietotnei izgūt informāciju par šobrīd un nesen veiktajiem uzdevumiem. Ļaunprātīgas lietotnes var atklāt privātu informāciju par citām lietotnēm."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"pārkārtot izmantotās lietotnes"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Ļauj lietotnei pārvietot uzdevumus priekšplānā un fonā. Lietotne var to izdarīt bez jūsu apstiprinājuma."</string>
    <string name="permlab_removeTasks" msgid="6821513401870377403">"apturēt izmantoto lietotņu darbību"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Ļauj lietotnei noņemt uzdevumus un pārtraukt to lietotņu darbību. Ļaunprātīgas lietotnes var traucēt citu lietotņu darbību."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"jebkuras darbības sākšana"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Ļauj lietotnei sākt jebkuru darbību neatkarīgi no atļaujas aizsardzības vai eksportētā stāvokļa."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"Ekrāna saderības noteikšana"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Ļauj lietotnei kontrolēt citu lietotņu ekrāna saderības režīmu. Ļaunprātīgas lietojumprogrammas var mainīt citu lietojumprogrammu darbību."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"iespējot lietotnes atkļūdošanu"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Ļauj lietotnei ieslēgt citas lietotnes atkļūdošanu. Ļaunprātīgas lietotnes to var izmantot, lai pārtrauktu citu lietotņu darbību."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"mainīt sistēmas rādīšanas iestatījumus"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Ļauj lietotnei mainīt pašreizējo konfigurāciju, piemēram, lokalizāciju vai vispārējo fonta lielumu."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"iespējot automobiļa režīmu"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Ļauj lietotnei iespējot automašīnas režīmu."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"aizvērt citas lietotnes"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Ļauj lietotnei pabeigt citu lietotņu fonā darbinātos procesus. Rezultātā var tikt apturēta citu lietotņu darbība."</string>
    <string name="permlab_forceStopPackages" msgid="2329627428832067700">"veikt citu lietotņu darbības piespiedu pārtraukšanu"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Ļauj lietotnei veikt citu lietotņu darbības piespiedu pārtraukšanu."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"veikt lietotnes piespiedu aizvēršanu"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Ļauj lietotnei veikt jebkuras priekšplānā notiekošas darbības piespiedu pārtraukšanu un atgriezties. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"izgūt sistēmas iekšējo stāvokli"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Ļauj lietotnei izgūt sistēmas iekšējo statusu. Ļaunprātīgas lietotnes var izgūt dažādu privātu un drošu informāciju, kas parasti tām nav nepieciešama."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"Ekrāna satura iegūšana"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Ļauj lietotnei izgūt aktīva loga saturu. Ļaunprātīgas lietotnes var izgūt visu loga saturu un pārbaudīt visu tā tekstu, izņemot paroles."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"Īslaicīga pieejamības režīma iespējošana"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Ļauj lietojumprogrammai īslaicīgi ierīcē iespējot pieejamības režīmu. Ļaunprātīgas lietotnes var iespējot pieejamības režīmu bez lietotāja atļaujas."</string>
    <string name="permlab_retrieve_window_info" msgid="8532295199112519378">"Izgūt informāciju par logiem"</string>
    <string name="permdesc_retrieve_window_info" msgid="4998836370424186849">"Ļauj lietojumprogrammai no logu pārvaldnieka izgūt informāciju par logiem. Ļaunprātīgas lietotnes var izgūt informāciju, kas ir paredzēta iekšējai izmantošanai sistēmā."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"Filtrēt notikumus"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Ļauj lietojumprogrammai reģistrēt ieejas filtru, kas filtrē visu lietotāja notikumu straumi, pirms notikumi tiek nosūtīti. Ļaunprātīga lietotne var kontrolēt sistēmas lietotāja saskarni, nejautājot lietotājam."</string>
    <string name="permlab_magnify_display" msgid="5973626738170618775">"displeja palielināšana"</string>
    <string name="permdesc_magnify_display" msgid="7121235684515003792">"Ļauj lietojumprogrammai palielināt displeja saturu. Ļaunprātīgas lietotnes var pārveidot displeja saturu tā, ka ierīce kļūst nelietojama."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"daļēja izslēgšana"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Liek darbību pārvaldniekam pāriet izslēgšanas stāvoklī. Neveic pilnīgu izslēgšanu."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"novērst lietojumprogrammu pārslēgšanu"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Novērš lietotāja pārslēgšanos uz citu lietotni."</string>
    <string name="permlab_getTopActivityInfo" msgid="2537922311411546016">"pašreizējās lietotnes informācijas iegūšana"</string>
    <string name="permdesc_getTopActivityInfo" msgid="2512448855496067131">"Ļauj īpašniekam izgūt privātu informāciju par pašreizējo lietojumprogrammu ekrāna priekšplānā."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"pārraudzīt un kontrolēt visu lietotņu atvēršanu"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Ļauj lietotnei pārraudzīt un kontrolēt, kā sistēmā tiek palaistas darbības. Ļaunprātīgas lietotnes var pilnībā uzlauzt sistēmu. Šī atļauja ir nepieciešama tikai izstrādei, taču ne parastai lietošanai."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"sūtīt apraidi par pakotnes noņemšanu"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Ļauj lietotnei pārraidīt paziņojumu, ka lietotnes pakotne ir noņemta. Ļaunprātīgas lietotnes to var izmantot, lai pārtrauktu jebkuras citas izmantotās lietotnes darbību."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"sūtīt īsziņā saņemtu apraidi"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Ļauj lietotnei pārraidīt paziņojumu par saņemtu īsziņu. Ļaunprātīgas lietotnes to var izmantot, lai viltotu ienākošas īsziņas."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"sūtīt WAP-PUSH-saņemto apraidi"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Ļauj lietotnei pārraidīt paziņojumu par to, ka ir saņemts WAP PUSH ziņojums. Ļaunprātīgas lietotnes to var izmantot, lai viltotu multiziņas saņemšanu vai jebkuras tīmekļa lapas saturu nemanāmi nomainītu ar ļaunprātīgiem variantiem."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"ierobežot aktīvo procesu skaitu"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Ļauj lietotnei kontrolēt izpildāmo procesu maksimālo skaitu. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"veikt fonā darbojošos lietotņu piespiedu aizvēršanu"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Ļauj lietotnei kontrolēt, vai darbības vienmēr tiek pabeigtas, tiklīdz tās nonāk fonā. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"akumulatora statistikas lasīšana"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Ļauj lietojumprogrammai lasīt pašreizējos zema akumulatora enerģijas patēriņa datus. Var atļaut lietojumprogrammai iegūt detalizētu informāciju par to, kuras lietotnes izmantojat."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"akumulatora statistikas pārveidošana"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Ļauj lietotnei pārveidot apkopoto statistiku par akumulatoru. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_getAppOpsStats" msgid="1508779687436585744">"Izgūt lietotnes darbību statistiku"</string>
    <string name="permdesc_getAppOpsStats" msgid="6243887041577912877">"Ļauj lietotnei izgūt apkopoto statistiku par lietojumprogrammas darbību. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_updateAppOpsStats" msgid="8829097373851521505">"Pārveidot lietotnes darbības statistiku"</string>
    <string name="permdesc_updateAppOpsStats" msgid="50784596594403483">"Ļauj lietotnei pārveidot apkopoto statistiku par lietojumprogrammas darbību. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_backup" msgid="470013022865453920">"kontrolēt sistēmas dublējumu un atjaunošanu"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Ļauj lietotnei kontrolēt sistēmas dublēšanas un atjaunošanas mehānismu. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"Apstiprināt pilnu dublējumu vai atjaunot darbību"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Ļauj lietotnei palaist pilna dublējuma apstiprinājuma lietotāja saskarni. Neattiecas ne uz vienu lietotni."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"attēlot neautorizētus logus"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Ļauj lietotnei izveidot logus, kas paredzēti izmantošanai iekšējās sistēmas lietotāja saskarnē. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"zīmēt pāri citām lietotnēm"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Ļauj lietotni rādīt virs citām lietojumprogrammām vai lietotāja saskarnes daļām. Var traucēt saskarnes lietošanu jebkurā lietojumprogrammā vai mainīt citu lietojumprogrammu izskatu."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"pārveidot globālo animācijas ātrumu"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Ļauj lietotnei jebkurā laikā mainīt vispārējo animācijas ātrumu (lēnākām vai ātrākām animācijām)."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"pārvaldīt lietotnes pilnvaras"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Ļauj lietotnei veidot un pārvaldīt savas pilnvaras, apejot to parasto “Z kārtošanu”. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"attēla “iesaldēšana”"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"Ļauj lietojumprogrammai īslaicīgi “iesaldēt” attēlu, lai pārietu uz pilnekrāna režīmu."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"nospiest taustiņus un vadības pogas"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Ļauj lietotnei rādīt savas ievades notikumus (nospiestos taustiņus u.c.) citās lietotnēs. Ļaunprātīgas lietotnes to var izmantot, lai pārņemtu planšetdatora vadību."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Ļauj lietotnei rādīt savas ievades notikumus (nospiestos taustiņus u.c.) citās lietotnēs. Ļaunprātīgas lietotnes to var izmantot, lai pārņemtu tālruņa vadību."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"reģistrēt rakstīto un veiktās darbības"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Ļauj lietotnei skatīt taustiņus, ko nospiežat, pat ja darbojaties citā lietotnē (piemēram, ievadot paroli). Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"saistīt ar ievades metodi"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Ļauj īpašniekam izveidot saiti ar ievades metodes augstākā līmeņa saskarni. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"saistīt ar pieejamības pakalpojumu"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Ļauj īpašniekam izveidot saiti ar pieejamības pakalpojuma augšējā līmeņa saskarni. Parastajām lietotnēm šī atļauja nav nepieciešama."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"saistīt ar īsziņu pakalpojumu"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Ļauj īpašniekam veikt saistīšanu ar īsziņu pakalpojuma augstākā līmeņa saskarni (piem., SpellCheckerService). Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"saistīt ar VPN pakalpojumu"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Ļauj īpašniekam izveidot saiti ar VPN pakalpojuma augšējā līmeņa saskarni. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"saistīt ar tapeti"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Ļauj īpašniekam piesaistīt tapetes augstākā līmeņa lietotāja saskarni. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"saistīt ar logrīka pakalpojumu"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Ļauj īpašniekam izveidot saiti ar logrīka pakalpojuma augšējā līmeņa saskarni. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"mijiedarboties ar ierīces administratoru"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Ļauj īpašniekam nosūtīt informāciju par nodomiem ierīces administratoram. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"mainīt ekrāna orientāciju"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Ļauj lietotnei jebkurā laikā mainīt ekrāna pozīciju. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"Rādītāja ātruma mainīšana"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Ļauj lietotnei jebkurā laikā mainīt peles vai skārienpaliktņa rādītāja ātrumu. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"Tastatūras izkārtojuma maiņa"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Ļauj lietotnei mainīt tastatūras izkārtojumu. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"sūtīt Linux signālus lietotnēm"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Ļauj lietotnei pieprasīt, lai piegādātais signāls tiktu sūtīts visiem pastāvīgajiem procesiem."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"likt lietotnei vienmēr darboties"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Ļauj lietotnei nodrošināt atsevišķu tās daļu nepārtrauktu atrašanos atmiņā. Tas var ierobežot pieejamo atmiņas daudzumu citām lietotnēm, tādējādi palēninot planšetdatora darbību."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Ļauj lietotnei nodrošināt atsevišķu tās daļu nepārtrauktu atrašanos atmiņā. Tas var ierobežot pieejamo atmiņas daudzumu citām lietotnēm, tādējādi palēninot tālruņa darbību."</string>
    <string name="permlab_deletePackages" msgid="184385129537705938">"dzēst lietotnes"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Ļauj lietotnei dzēst Android pakotnes. Ļaunprātīgas lietotnes to var izmantot, lai dzēstu svarīgas lietotnes."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"dzēst citu lietotņu datus"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Ļauj lietotnei notīrīt lietotāja datus."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"dzēst citu lietotņu kešatmiņu"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Ļauj lietotnei dzēst kešatmiņas failus."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"noteikt vietas apjomu lietotnes atmiņā"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Ļauj lietotnei izgūt tās koda datus un kešatmiņas izmēru."</string>
    <string name="permlab_installPackages" msgid="2199128482820306924">"tieši instalēt lietotnes"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Ļauj lietotnei instalēt jaunas vai atjauninātas Android pakotnes. Ļaunprātīgas lietotnes to var izmantot, lai pievienotu jaunas lietotnes ar patvaļīgi derīgām atļaujām."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"dzēst visus lietotnes kešatmiņas datus"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Ļauj lietotnei atbrīvot vietu planšetdatorā, dzēšot failus citu lietojumprogrammu kešatmiņas direktorijos. Citu lietojumprogrammu palaišana var būt lēnāka, jo tajās ir atkārtoti jāizgūst dati."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Ļauj lietotnei atbrīvot vietu tālrunī, dzēšot failus citu lietojumprogrammu kešatmiņas direktorijos. Citu lietojumprogrammu palaišana var būt lēnāka, jo tajās ir atkārtoti jāizgūst dati."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"pārvietot lietotnes resursus"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Ļauj lietotnei pārvietot lietotnes resursus no iekšēja datu nesēja uz ārēju datu nesēju un otrādi."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"lasīt sensitīvus žurnāla datus"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Ļauj lietotnei lasīt informāciju no dažādiem sistēmas žurnālfailiem. Šādi lietotne var atrast vispārīgu informāciju par jūsu darbībām planšetdatorā, tostarp arī personas vai privātu informāciju."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Ļauj lietotnei lasīt informāciju no dažādiem sistēmas žurnālfailiem. Šādi lietotne var atrast vispārīgu informāciju par jūsu darbībām tālrunī, tostarp arī personas vai privātu informāciju."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"multivides failu atskaņošanai izmantot jebkuru dekodētāju"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Ļauj lietotnei izmantot jebkuru instalētu multivides failu dekodētāju, lai dekodētu failus atskaņošanai."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"lasīt grupas “diag” resursus un rakstīt tajos"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Ļauj lietotnei lasīt un rakstīt jebkurā resursā, kas pieder diagnostikas grupai, piemēram, failiem mapē /dev. Tas var ietekmēt sistēmas stabilitāti un drošību. Var izmantot ražotājs vai operators TIKAI konkrētas aparatūras diagnostikai."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"iespējot vai atspējot lietotnes komponentus"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Ļauj lietotnei mainīt to, vai tiek iespējots citas lietotnes komponents. Ļaunprātīgas lietotnes to var izmantot, lai atspējotu svarīgas planšetdatora iespējas. Izmantojiet šo atļauju uzmanīgi, jo pastāv iespēja, ka lietotnes komponenti var kļūt neizmantojami, neatbilstīgi vai nestabili."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Ļauj lietotnei mainīt to, vai tiek iespējots citas lietotnes komponents. Ļaunprātīgas lietotnes to var izmantot, lai atspējotu svarīgas tālruņa iespējas. Izmantojiet šo atļauju uzmanīgi, jo pastāv iespēja, ka lietotnes komponenti var kļūt neizmantojami, neatbilstīgi vai nestabili."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"atļauju piešķiršana vai atsaukšana"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Ļauj lietojumprogrammai piešķirt sev vai citām lietojumprogrammām noteiktas atļaujas un atsaukt tās. Ļaunprātīgas lietojumprogrammas var izmantot šo iespēju, lai piekļūtu funkcijām, kuras neesat atļāvis."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"iestatīt vēlamās lietotnes"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Ļauj lietotnei modificēt jūsu vēlamās lietotnes. Ļaunprātīgas lietotnes var nemanāmi mainīt izmantotās lietotnes, atveidojot esošās lietotnes, lai no jums iegūtu privātus datus."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"mainīt sistēmas iestatījumus"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Ļauj lietotnei modificēt sistēmas iestatījumu datus. Ļaunprātīgas lietotnes var uzlauzt sistēmas konfigurāciju."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"pārveidot drošos sistēmas iestatījumus"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Ļauj lietotnei modificēt sistēmas drošības iestatījumu datus. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"pārveidot Google pakalpojumu karti"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Ļauj lietotnei modificēt Google pakalpojumu karti. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"palaist līdz ar startēšanu"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Ļauj lietotnei tikt startētai, tiklīdz sistēma ir pabeigusi sāknēšanu. Šādi planšetdatora startēšana var notikt ilgāk un lietotne, ja tā darbojas nepārtraukti, var palēnināt planšetdatora vispārējo darbību."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Ļauj lietotnei tikt startētai, tiklīdz sistēma ir pabeigusi sāknēšanu. Šādi tālruņa startēšana var notikt ilgāk un lietotne, ja tā darbojas nepārtraukti, var palēnināt tālruņa vispārējo darbību."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"sūtīt piesaistošu apraidi"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Ļauj lietotnei sūtīt piesaistošas apraides, kas tiek saglabātas pēc apraides pabeigšanas. Pārmērīga izmantošana var palēnināt planšetdatora darbību vai padarīt tā darbību nestabilu, liekot izmantot pārāk daudz atmiņas."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Ļauj lietotnei sūtīt piesaistošas apraides, kas tiek saglabātas pēc apraides pabeigšanas. Pārmērīga izmantošana var palēnināt tālruņa darbību vai padarīt tā darbību nestabilu, liekot izmantot pārāk daudz atmiņas."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"lasīt kontaktpersonu informāciju"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Ļauj lietotnei lasīt datus par jūsu planšetdatorā saglabātajām kontaktpersonām, tostarp to, cik bieži esat zvanījis, sazinājies pa e-pastu vai citādi sazinājies ar konkrētām personām. Ar šo atļauju lietotnes var saglabāt jūsu kontaktpersonu datus, un ļaunprātīgas lietotnes var kopīgot kontaktpersonu datus bez jūsu atļaujas."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Ļauj lietotnei lasīt datus par jūsu tālrunī saglabātajām kontaktpersonām, tostarp to, cik bieži esat zvanījis, sazinājies pa e-pastu vai citādi sazinājies ar konkrētām personām. Ar šo atļauju lietotnes var saglabāt jūsu kontaktpersonu datus, un ļaunprātīgas lietotnes var kopīgot kontaktpersonu datus bez jūsu atļaujas."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"mainīt kontaktpersonu informāciju"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Ļauj lietotnei mainīt datus par planšetdatorā saglabātajām kontaktpersonām, tostarp par zvanu un e-pasta ziņojumu apjomu vai saziņu citos veidos, kas veikta ar konkrētām kontaktpersonām. Ar šo atļauju lietotne var dzēst kontaktpersonu datus."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Ļauj lietotnei mainīt datus par tālrunī saglabātajām kontaktpersonām, tostarp par zvanu un e-pasta ziņojumu apjomu vai saziņu citos veidos, kas veikta ar konkrētām kontaktpersonām. Ar šo atļauju lietotne var dzēst kontaktpersonu datus."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"nolasīt zvanu žurnālu"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Ļauj lietotnei lasīt planšetdatora zvanu žurnālu, tostarp datus par ienākošajiem un izejošajiem zvaniem. Ar šo atļauju lietotnes var saglabāt jūsu zvanu žurnāla datus, un ļaunprātīgas lietotnes var kopīgot zvanu žurnāla datus bez jūsu atļaujas."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Ļauj lietotnei lasīt tālruņa zvanu žurnālu, tostarp datus par ienākošajiem un izejošajiem zvaniem. Ar šo atļauju lietotnes var saglabāt jūsu zvanu žurnāla datus, un ļaunprātīgas lietotnes var kopīgot zvanu žurnāla datus bez jūsu atļaujas."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"rakstīt zvanu žurnālā"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Ļauj lietotnei pārveidot planšetdatora zvanu žurnālu, tostarp ienākošo un izejošo zvanu datus. Ļaunprātīgas lietotnes var to izmantot, lai dzēstu vai pārveidotu savu zvanu žurnālu."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Ļauj lietotnei pārveidot tālruņa zvanu žurnālu, tostarp ienākošo un izejošo zvanu datus. Ļaunprātīgas lietotnes var to izmantot, lai dzēstu vai pārveidotu savu zvanu žurnālu."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"lasīt manu vizītkarti"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Ļauj lietotnei lasīt ierīcē saglabāto personīgā profila informāciju, piemēram, jūsu vārdu un kontaktinformāciju. Tas nozīmē, ka lietotne var jūs identificēt un var nosūtīt jūsu profila informāciju citām personām."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"mainīt manu vizītkarti"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Ļauj lietotnei mainīt ierīcē saglabāto personīgā profila informāciju, piemēram, jūsu vārdu un kontaktinformāciju, vai pievienot tai citu informāciju. Tas nozīmē, ka lietotne var jūs identificēt un var nosūtīt jūsu profila informāciju citām personām."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"lasīt jūsu soc. tīklu straumi"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Ļauj lietotnei piekļūt sociālajiem atjauninājumiem no jums un jūsu draugiem un sinhronizēt tos. Esiet piesardzīgs, kad kopīgojat informāciju, — šādi lietotne var lasīt sociālajos tīklos ar draugiem veikto saziņu, neraugoties uz konfidencialitāti. Piezīme: šo atļauju nedrīkst piemērot visiem sociālajiem tīkliem."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"rakstīt sociālo tīklu straumē"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Ļauj lietotnei parādīt jūsu draugu atjauninājumus sociālajos tīklos. Esiet piesardzīgs, kad kopīgojat informāciju, — šādi lietotne var veidot ziņojumus, kas šķietami saņemti no drauga. Piezīme: šo atļauju nevar piemērot visiem sociālajiem tīkliem."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"lasīt kalendāra pasākumus un konfidenciālu informāciju"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Ļauj lietotnei lasīt visus planšetdatorā saglabātos kalendāra notikumus, tostarp draugu vai kolēģu notikumus. Tas var ļaut lietotnei kopīgot vai saglabāt jūsu kalendāra datus, neraugoties uz to konfidencialitāti vai sensitivitāti."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Ļauj lietotnei lasīt visus tālrunī saglabātos kalendāra notikumus, tostarp draugu vai kolēģu notikumus. Tas var ļaut lietotnei kopīgot vai saglabāt jūsu kalendāra datus, neraugoties uz to konfidencialitāti vai sensitivitāti."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"pievienot vai pārveidot kalendāra pasākumus un sūtīt e-pasta ziņojumus viesiem bez īpašnieku ziņas"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Ļauj lietotnei pievienot, noņemt, mainīt notikumus, kurus varat pārveidot planšetdatorā, tostarp draugu vai kolēģu notikumus. Tas var ļaut lietotnei sūtīt ziņojumus, norādot, ka tos sūta kalendāru īpašnieki, vai pārveidot notikumus bez īpašnieka atļaujas."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Ļauj lietotnei pievienot, noņemt, mainīt notikumus, kurus varat pārveidot tālrunī, tostarp draugu vai kolēģu notikumus. Tas var ļaut lietotnei sūtīt ziņojumus, norādot, ka tos sūta kalendāru īpašnieki, vai pārveidot notikumus bez īpašnieka atļaujas."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"imitēt atrašanās vietu avotus pārbaudes nolūkos"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Izveido neīstus atrašanās vietas noteikšanas avotus testēšanas nolūkiem vai instalē jaunu atrašanās vietas noteikšanas nodrošinātāju. Tas ļauj lietotnei ignorēt atrašanās vietu un/vai statusu, ko norādīja citi atrašanās vietas noteikšanas avoti, piemēram, GPS vai atrašanās vietas noteikšanas nodrošinātāji."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"piekļūt atrašanās vietas nodrošinātāja papildu komandām"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"Ļauj lietotnei piekļūt papildu atrašanās vietas noteikšanas nodrošinātāju komandām. Tas var ļaut lietotnei traucēt GPS vai citu atrašanās vietas noteikšanas avotu darbību."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"atļauja instalēt atrašanās vietas sniedzēju"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Izveido neīstus atrašanās vietas noteikšanas avotus testēšanas nolūkiem vai instalē jaunu atrašanās vietas noteikšanas nodrošinātāju. Tas ļauj lietotnei ignorēt atrašanās vietu un/vai statusu, ko norādīja citi atrašanās vietas noteikšanas avoti, piemēram, GPS vai atrašanās vietas noteikšanas nodrošinātāji."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"precīza atrašanās vieta (GPS un tīklā)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Ļauj lietotnei iegūt precīzu informāciju par jūsu atrašanās vietu, izmantojot globālo pozicionēšanas sistēmu (GPS) vai tīkla atrašanās vietas pakalpojumus, piemēram, mobilo sakaru torņus un Wi-Fi. Lai lietotne varētu izmantot šos atrašanās vietas pakalpojumus, ierīcē tiem ir jābūt ieslēgtiem un pieejamiem. Lietotnes var izmantot šo atļauju, lai noteiktu jūsu atrašanās vietu, un var patērēt papildu akumulatora enerģiju."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"aptuvena atrašanās vieta (tīklā)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Ļauj lietotnei iegūt informāciju par aptuvenu jūsu atrašanās vietu. Tā tiek noteikta atrašanās vietas pakalpojumos, izmantojot tīkla atrašanās vietas avotus, kā arī mobilo sakaru torņus un Wi-Fi. Lai lietotne varētu izmantot šos atrašanās vietas pakalpojumus, ierīcē tiem ir jābūt ieslēgtiem un pieejamiem. Lietotnes var izmantot šo atļauju, lai noteiktu aptuvenu jūsu atrašanās vietu."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"piekļūt SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Ļauj lietotnei lietot SurfaceFlinger zema līmeņa funkcijas."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"lasīt kadru buferi"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Ļauj lietotnei lasīt kadru bufera saturu."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"Wi-Fi displeju konfigurēšana"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"Ļauj lietotnei konfigurēt Wi-Fi displejus un veidot savienojumu ar tiem."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"Wi-Fi displeju vadība"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"Ļauj lietotnei kontrolēt zema līmeņa funkcijas Wi-Fi displejos."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"mainīt audio iestatījumus"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Ļauj lietotnei mainīt globālos audio iestatījumus, piemēram, skaļumu un izejai izmantoto skaļruni."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"ierakstīt audio"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Ļauj lietotnei ierakstīt audio, izmantojot mikrofonu. Šī atļauja ļauj lietotnei ierakstīt audio jebkurā brīdī bez jūsu apstiprinājuma."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"uzņemt attēlus un videoklipus"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Ļauj lietotnei uzņemt attēlus un videoklipus ar kameru. Ar šo atļauju lietotne var jebkurā brīdī izmantot kameru bez jūsu apstiprinājuma."</string>
    <string name="permlab_cameraDisableTransmitLed" msgid="2651072630501126222">"Atspējot pārraidīšanas LED indikatoru, kad kamera tiek izmantota"</string>
    <string name="permdesc_cameraDisableTransmitLed" msgid="4764585465480295341">"Ļauj iepriekš instalētai sistēmas lietojumprogrammai atspējot LED indikatoru, izmantojot kameru."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"neatgriezeniski atspējot planšetdatoru"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"neatgriezeniski atspējot tālruni"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Ļauj lietotnei neatgriezeniski atspējot visu planšetdatoru. Tas ir ļoti bīstami."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Ļauj lietotnei neatgriezeniski atspējot visu tālruni. Tas ir ļoti bīstami."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"forsēt planšetdatora atsāknēšanu"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"atsāknēt tālruni"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Ļauj lietotnei veikt planšetdatora piespiedu atsāknēšanu."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Ļauj lietotnei atsāknēt tālruni."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"piekļūt USB atm. failu sistēmai"</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"piekļūt SD kartes failu sistēmai"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Ļauj lietotnei pievienot un atvienot failu sistēmas noņemamai atmiņai."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"dzēst USB atmiņu"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"dzēst SD karti"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Ļauj lietotnei formatēt noņemamu atmiņu."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"iegūt informāciju par iekšējo krātuvi"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Ļauj lietotnei iegūt informāciju par iekšējo atmiņu."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"izveidot iekšēju krātuvi"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Ļauj lietotnei izveidot iekšējo atmiņu."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"likvidēt iekšējo krātuvi"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Ļauj lietotnei iznīcināt iekšējo atmiņu."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"pievienot/atvienot iekšējo atmiņu"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Ļauj lietotnei pievienot/atvienot iekšējo atmiņu."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"pārdēvēt iekšējo krātuvi"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Ļauj lietotnei pārdēvēt iekšējo atmiņu."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"kontrolēt vibrosignālu"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Ļauj lietotnei kontrolēt vibrosignālu."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"kontrolēt uzliesmojumu"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Ļauj lietotnei kontrolēt zibspuldzi."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"USB ierīču preferenču un atļauju pārvaldība"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Ļauj lietotnei pārvaldīt preferences un atļaujas saistībā ar USB ierīcēm."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"Ieviests MTP protokols"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Ļauj piekļūt kodola MTP dzinim, lai ieviestu MTP USB protokolu."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"pārbaudīt aparatūru"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Ļauj lietotnei kontrolēt dažādas perifērijas ierīces, lai pārbaudītu aparatūru."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"tieši zvanīt uz tālruņa numuriem"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Ļauj lietotnei zvanīt uz tālruņa numuriem bez jūsu iejaukšanās. Tas var radīt neparedzētas izmaksas vai zvanus. Ņemiet vērā, ka lietotnei nav atļauts zvanīt uz tālruņa numuriem ārkārtas situācijām. Ļaunprātīgas lietotnes var radīt jums izmaksas, veicot zvanus bez jūsu apstiprinājuma."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"tieši zvanīt uz jebkuriem tālruņa numuriem"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Ļauj lietotnei zvanīt uz jebkuru tālruņa numuru, tostarp uz ārkārtas numuriem, bez jūsu iejaukšanās. Ļaunprātīgas lietotnes var veikt nevajadzīgus un neatļautus zvanus uz avārijas dienestiem."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"tieši sākt CDMA planšetdatora iestatīšanu"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"tiešā veidā sākt CDMA tālruņa iestatīšanu"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Ļauj lietotnei sākt CDMA nodrošināšanu. Ļaunprātīgas lietotnes var sākt CDMA nodrošināšanu bez vajadzības."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"kontrolēt atrašanās vietas atjauninājumu paziņojumus"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Ļauj lietotnei iespējot/atspējot paziņojumus no radio saistībā ar atrašanās vietas atjauninājumiem. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"piekļūt reģistrēšanās rekvizītiem"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Piešķir lietotnei lasīšanas/rakstīšanas piekļuvi rekvizītiem, kas augšupielādēti reģistrācijas laikā. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"izvēlēties logrīkus"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Ļauj lietotnei norādīt sistēmai, kādus logrīkus un kurā lietotnē var izmantot. Lietotne, kurai ir šī atļauja, var piešķirt citām lietotnēm piekļuvi personas datiem. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"pārveidot tālruņa stāvokli"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Ļauj lietotnei kontrolēt ierīces tālruņa funkcijas. Lietotne, kurai ir šī atļauja, var pārslēgt tīklus, ieslēgt un izslēgt tālruņa radio un veikt tamlīdzīgas darbības, nebrīdinot jūs."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"lasīt tālruņa statusu un identitāti"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Ļauj lietotnei piekļūt ierīces tālruņa funkcijām. Ar šo atļauju lietotne var noteikt tālruņa numuru un ierīču ID, zvana statusu un attālo numuru, ar ko ir izveidots savienojums, veicot zvanu."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"novērst planšetdatora pāriešanu miega režīmā"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"novērst tālruņa pāriešanu miega režīmā"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Ļauj lietotnei novērst planšetdatora pāriešanu miega režīmā."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Ļauj lietotnei novērst tālruņa pāriešanu miega režīmā."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"ieslēgt vai izslēgt planšetdatoru"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"ieslēgt vai izslēgt tālruni"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Ļauj lietotnei ieslēgt vai izslēgt planšetdatoru."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Ļauj lietotnei ieslēgt vai izslēgt tālruni."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"darbināt rūpnīcas pārbaudes režīmā"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Darbina kā zema līmeņa ražotāja testu, atļaujot pilnīgu piekļuvi planšetdatora aparatūrai. Pieejama tikai tad, ja planšetdators darbojas ražotāja testa režīmā."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Darbiniet kā zema līmeņa ražotāja pārbaudi, atļaujot pilnīgu piekļuvi tālruņa aparatūrai. Pieejams tikai tad, ja tālrunis darbojas ražotāja pārbaudes režīmā."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"iestatīt tapeti"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Ļauj lietotnei iestatīt sistēmas tapeti."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"pielāgot fona tapetes lielumu"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Ļauj lietotnei iestatīt sistēmas tapetes izmēru norādes."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"atiestatīt sistēmu uz rūpnīcas noklusējuma iestatījumiem"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Ļauj lietotnei pilnībā atiestatīt sistēmas rūpnīcas iestatījumus, dzēšot visus datus, konfigurāciju un instalētās lietotnes."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"iestatīt laiku"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Ļauj lietotnei mainīt planšetdatora pulksteņa laiku."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Ļauj lietotnei mainīt tālruņa pulksteņa laiku."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"iestatīt laika joslu"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Ļauj lietotnei mainīt planšetdatora laika joslu."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Ļauj lietotnei mainīt tālruņa laika joslu."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"darboties kā AccountManagerService"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Ļauj lietotnei zvanīt uz AccountAuthenticators."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"atrast kontus ierīcē"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Ļauj lietotnei iegūt planšetdatoram zināmo kontu sarakstu. Tas var ietvert jebkādus kontus, ko izveidojušas instalētās lietojumprogrammas."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Ļauj lietotnei iegūt tālrunim zināmo kontu sarakstu. Tas var ietvert jebkādus kontus, ko izveidojušas instalētās lietojumprogrammas."</string>
    <string name="permlab_authenticateAccounts" msgid="5265908481172736933">"izveidot kontus un iestatīt paroles"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Ļauj lietotnei izmantot AccountManager konta autentificētāja iespējas, tostarp veidot kontus un iegūt un iestatīt to paroles."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"pievienot vai noņemt kontus"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Ļauj lietotnei veikt tādas darbības kā kontu pievienošana un noņemšana, kā arī paroles dzēšana."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"izmantot ierīcē esošos kontus"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Ļauj lietotnei pieprasīt autentifikācijas pilnvaras."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"skatīt tīkla savienojumus"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Ļauj lietotnei skatīt informāciju par tīkla savienojumiem, piemēram, par to, kādi tīkli pastāv un ar kuriem tīkliem ir izveidots savienojums."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"pilnīga piekļuve tīklam"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Ļauj lietotnei izveidot tīkla ligzdas un izmantot pielāgotus tīkla protokolus. Pārlūkprogramma un citas lietojumprogrammas nodrošina līdzekļus, kas nepieciešami, lai sūtītu datus internetā, tāpēc šī atļauja nav nepieciešama, lai sūtītu datus internetā."</string>
    <string name="permlab_writeApnSettings" msgid="505660159675751896">"tīkla iestatījumu un datplūsmas mainīšana/pārtveršana"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Ļauj lietotnei mainīt tīkla iestatījumus, kā arī pārķert un pārbaudīt visu tīkla datplūsmu, piemēram, mainīt starpniekserveri un jebkura APN portu. Ļaunprātīgas lietotnes var pārraudzīt, novirzīt vai modificēt tīkla paketes bez jūsu ziņas."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"mainīt tīkla savienojamību"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Ļauj lietotnei mainīt tīkla savienojamības statusu."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"mainīt piesaistes savienojamību"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Ļauj lietotnei mainīt piesaistes tīkla savienojamības statusu."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"mainīt fona datu lietojuma iestatījumu"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Ļauj lietotnei mainīt fona datu lietošanas iestatījumu."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"skatīt Wi-Fi savienojumus"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Ļauj lietotnei skatīt informāciju par Wi-Fi tīklošanu, piemēram, par to, vai Wi-Fi ir iespējots, kā arī pievienoto Wi-Fi ierīču nosaukumus."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"izveidot un pārtraukt Wi-Fi savienojumu"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Ļauj lietotnei izveidot savienojumu ar Wi-Fi piekļuves punktiem un pārtraukt savienojumus ar tiem, kā arī veikt izmaiņas ierīces Wi-Fi tīklu konfigurācijā."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"atļaut Wi-Fi multiraides uztveršanu"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Ļauj lietotnei saņemt sūtījumus, kas sūtīti uz visām ierīcēm Wi-Fi tīklā, izmantojot multiraides adreses, nevis tikai jūsu planšetdatoru. Tādējādi tiek patērēts vairāk enerģijas nekā režīmā, kas nav multiraide."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Ļauj lietotnei saņemt sūtījumus, kas sūtīti uz visām ierīcēm Wi-Fi tīklā, izmantojot multiraides adreses, nevis tikai jūsu tālruni. Tādējādi tiek patērēts vairāk enerģijas nekā režīmā, kas nav multiraide."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"piekļūt Bluetooth iestatījumiem"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Ļauj lietotnei konfigurēt vietējo Bluetooth planšetdatoru, kā arī atklāt attālas ierīces un savienot tās pārī."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Ļauj lietotnei konfigurēt vietējo Bluetooth tālruni, kā arī atklāt attālas ierīces un savienot tās pārī."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"WiMAX savienojuma izveide un pārtraukšana"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Ļauj lietotnei noteikt, vai WiMAX ir iespējots, un sniedz informāciju par visiem WiMAX tīkliem, ar kuriem ir izveidots savienojums."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"WiMAX statusa mainīšana"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Ļauj lietotnei izveidot un pārtraukt planšetdatora savienojumu ar WiMAX tīkliem."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Ļauj lietotnei izveidot un pārtraukt tālruņa savienojumu ar WiMAX tīkliem."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"savienot pārī ar Bluetooth ierīcēm"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Ļauj lietotnei skatīt Bluetooth konfigurāciju planšetdatorā, kā arī veidot un pieņemt savienojumus ar pārī savienotām ierīcēm."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Ļauj lietotnei skatīt Bluetooth konfigurāciju tālrunī, kā arī veidot un pieņemt savienojumus ar pārī savienotām ierīcēm."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"kontrolē tuvlauka saziņu"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Ļauj lietotnei sazināties ar tuva darbības lauka sakaru (Near Field Communication — NFC) atzīmēm, kartēm un lasītājiem."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"atspējot ekrāna bloķēšanu"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Ļauj lietotnei atspējot taustiņslēgu un visu saistīto paroļu drošību. Piemēram, tālrunis atspējo taustiņslēgu, saņemot ienākošu zvanu, un pēc zvana pabeigšanas atkārtoti iespējo taustiņslēgu."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"lasīt sinhronizācijas iestatījumus"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Ļauj lietotnei lasīt konta sinhronizācijas iestatījumus. Piemēram, šādi var noteikt, vai lietotne Personas ir sinhronizēta ar kontu."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"ieslēgt un izslēgt sinhronizāciju"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Ļauj lietotnei pārveidot konta sinhronizācijas iestatījumus. Piemēram, to var izmantot, lai iespējotu lietotnes Personas sinhronizēšanu ar kontu."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"lasīt sinhronizācijas statistiku"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Ļauj lietotnei lasīt konta sinhronizācijas statistiku, tostarp sinhronizācijas notikumu vēsturi un sinhronizēto datu apjomu."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"lasīt abonētās plūsmas"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Ļauj lietotnei iegūt informāciju par pašlaik sinhronizētajām plūsmām."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"rakstīt abonētās plūsmas"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Ļauj lietotnei modificēt pašreizējās sinhronizētās plūsmas. Ļaunprātīgas lietotnes var mainīt jūsu sinhronizētās plūsmas."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"lasīt vārdnīcai pievienotos vārdus"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Ļauj lietotnei lasīt visus vārdus, nosaukumus un frāzes, ko lietotājs ir saglabājis lietotāja vārdnīcā."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"vārdu pievienošana lietotāja noteiktai vārdnīcai"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Ļauj lietotnei rakstīt jaunus vārdus lietotāja vārdnīcā."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="8235341515605559677">"aizsargātai krātuvei pieejamas piekļuves pārbaude"</string>
    <string name="permlab_sdcardRead" product="default" msgid="8235341515605559677">"aizsargātai krātuvei pieejamas piekļuves pārbaude"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3642473292348132072">"Ļauj lietotnei pārbaudīt USB krātuves atļauju; krātuve būs pieejama turpmākajās ierīcēs."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="5914402684685848828">"Ļauj lietotnei pārbaudīt atļauju SD kartei, kas būs pieejama turpmākajās ierīcēs."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"mainīt vai dzēst USB atm. sat."</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"SD kartes satura pārveidošana vai dzēšana"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Ļauj lietotnei rakstīt USB atmiņā."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Ļauj lietotnei rakstīt SD kartē."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"pārv./dz.datu n.iekš.atm.sat."</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Ļauj lietotnei modificēt datu nesēja iekšējās atmiņas saturu."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"piekļ. visu liet. ārējai krāt."</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Ļauj lietotnei piekļūt visu lietotāju ārējai krātuvei."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"piekļūt kešatmiņas failu sistēmai"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Ļauj lietotnei lasīt un rakstīt kešatmiņas failu sistēmā."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"veikt/saņemt interneta zvanus"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Ļauj lietotnei izmantot SIP pakalpojumu, lai veiktu/saņemtu interneta zvanus."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"lasīt informāciju par iepriekšēju tīkla izmantošanu"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Ļauj lietotnei lasīt informāciju par iepriekšēju tīkla izmantošanu saistībā ar noteiktiem tīkliem un lietotnēm."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"pārvaldīt tīkla politiku"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Ļauj lietotnei pārvaldīt tīkla politikas un noteikt lietotnes kārtulas."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"Tīkla lietojuma uzskaites mainīšana"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Ļauj lietotnei mainīt to, kā tīkla lietojums tiek uzskaitīts saistībā ar lietotnēm. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"piekļuve paziņojumiem"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Ļauj lietotnei izgūt, pārbaudīt un dzēst paziņojumus, tostarp lietotņu publicētos paziņojumus."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"saites izveidošana ar paziņojumu uztvērēja pakalpojumu"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Ļauj īpašniekam izveidot saiti ar paziņojumu uztvērēja pakalpojuma augšējā līmeņa saskarni. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Paroles kārtulu iestatīšana"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Kontrolē ekrāna atbloķēšanas parolē atļautās rakstzīmes un garumu."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Ekrāna atbloķēšanas mēģinājumu pārraudzīšana"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Pārrauga nepareizi ievadīto paroļu skaitu, atbloķējot ekrānu, un bloķē planšetdatoru vai dzēš visus planšetdatora datus, ja tiek ievadīts pārāk daudz nepareizu paroļu."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Pārrauga nepareizi ievadīto paroļu skaitu, atbloķējot ekrānu, un bloķē tālruni vai dzēš visus tālruņa datus, ja tiek ievadīts pārāk daudz nepareizu paroļu."</string>
    <string name="policylab_resetPassword" msgid="2620077191242688955">"Ekrāna atbloķēšanas paroles maiņa"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Maina ekrāna atbloķēšanas paroli."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Ekrāna bloķēšana"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Kontrolē, kā un kad ekrāns tiek bloķēts."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Dzēst visus datus"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Dzēš planšetdatora datus bez brīdinājuma, veicot rūpnīcas datu atiestatīšanu."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Dzēš tālruņa datus bez brīdinājuma, veicot rūpnīcas datu atiestatīšanu."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Iestatīt ierīces globālo starpniekserveri"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Iestatiet izmantojamo ierīces globālo starpniekserveri, kad ir iespējota politika. Spēkā esošo globālo starpniekserveri iestata tikai pirmās ierīces administrators."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Ekr. bloķ. paroles term. iest."</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Kontrolē, cik bieži ir jāmaina ekrāna bloķēšanas parole."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Skatīt atmiņas šifrējumu"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Pieprasa, lai saglabātie lietotnes dati tiktu šifrēti."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Atspējot kameras"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Neļauj izmantot nevienu ierīces kameru."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="266329104542638802">"Bloķēšanas f-jas atspējošana"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Atspējot noteiktas funkcijas taustiņslēgā."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Mājas"</item>
    <item msgid="869923650527136615">"Mobilais"</item>
    <item msgid="7897544654242874543">"Darbā"</item>
    <item msgid="1103601433382158155">"Faksa numurs darbā"</item>
    <item msgid="1735177144948329370">"Faksa numurs mājās"</item>
    <item msgid="603878674477207394">"Peidžers"</item>
    <item msgid="1650824275177931637">"Cits"</item>
    <item msgid="9192514806975898961">"Pielāgots"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Privāta"</item>
    <item msgid="7084237356602625604">"Darbā"</item>
    <item msgid="1112044410659011023">"Cits"</item>
    <item msgid="2374913952870110618">"Pielāgots"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Mājas"</item>
    <item msgid="5629153956045109251">"Darbā"</item>
    <item msgid="4966604264500343469">"Cits"</item>
    <item msgid="4932682847595299369">"Pielāgots"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Mājas"</item>
    <item msgid="1359644565647383708">"Darbā"</item>
    <item msgid="7868549401053615677">"Cits"</item>
    <item msgid="3145118944639869809">"Pielāgots"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Darbā"</item>
    <item msgid="4378074129049520373">"Cits"</item>
    <item msgid="3455047468583965104">"Pielāgots"</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">"Pielāgots"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Mājas"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobilais"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Darbā"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Faksa numurs darbā"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Faksa numurs mājās"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Peidžers"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Cits"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Atzvanīšana"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Automobiļa"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Uzņēmuma galvenais tālruņa numurs"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Galvenais"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Cits faksa numurs"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radio"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Telekss"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"Teletaips/surdotālrunis"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Mobilā tālruņa numurs darbā"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Peidžera numurs darbā"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Palīgs"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"Multiziņa"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Pielāgoti"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Dzimšanas diena"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Jubileja"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Citi"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Pielāgots"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Mājas"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Darbā"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Cits"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobilais"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Pielāgots"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Mājas"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Darbā"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Cits"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Pielāgots"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Mājas"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Darbā"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Cits"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Pielāgots"</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>
    <!-- no translation found for imProtocolGoogleTalk (493902321140277304) -->
    <skip />
    <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">"Darbā"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Cits"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Pielāgots"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Pielāgotas"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Palīgs"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brālis"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Bērns"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Vietējais partneris"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Tēvs"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Draugs"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Pārvaldnieks"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Māte"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Vecāki"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partneris"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Norādīja:"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Radinieks"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Māsa"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Laul. draugs/draudz."</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Pielāgotas"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Mājās"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Darbs"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Cits"</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Ievadiet PIN kodu."</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Ievadiet PUK kodu un jaunu PIN kodu."</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK kods"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Jauns PIN kods"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Pieskarieties, lai ievadītu paroli"</font>"."</string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Ievadiet paroli, lai atbloķētu."</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Lai atbloķētu, ievadiet PIN."</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"PIN kods nav pareizs."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Lai atbloķētu, nospiediet Izvēlne, pēc tam 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Ārkārtas numurs"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Nav pakalpojuma."</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Ekrāns ir bloķēts."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Nospiediet Izvēlne, lai atbloķētu, vai veiciet ārkārtas zvanu."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Lai atbloķētu, nospiediet vienumu Izvēlne."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Zīmējiet kombināciju, lai atbloķētu."</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Ārkārtas zvans"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Atpakaļ pie zvana"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Pareizi!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Mēģināt vēlreiz"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Mēģināt vēlreiz"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Ir pārsniegts maksimālais Autorizācijas pēc sejas mēģinājumu skaits."</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Notiek uzlāde (<xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>)"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Uzlādēts"</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">"Pievienojiet uzlādes ierīci."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Nav SIM kartes"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Planšetdatorā nav SIM kartes."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Tālrunī nav SIM kartes."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Ievietojiet SIM karti."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"Nav SIM kartes, vai arī to nevar nolasīt. Ievietojiet SIM karti."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Nelietojama SIM karte."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Jūsu SIM karte ir neatgriezeniski atspējota."\n"Sazinieties ar savu bezvadu pakalpojumu sniedzēju, lai iegūtu citu SIM karti."</string>
    <string name="lockscreen_transport_prev_description" msgid="201594905152746886">"Iepriekšējā ieraksta poga"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Nākamā ieraksta poga"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Pārtraukšanas poga"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Atskaņošanas poga"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Apturēšanas poga"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Tikai ārkārtas zvani"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Tīkls ir bloķēts."</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM karte ir bloķēta ar PUK kodu."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Skatiet lietotāja rokasgrāmatu vai sazinieties ar klientu apkalpošanas dienestu."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM karte ir bloķēta."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Notiek SIM kartes atbloķēšana..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"Atbloķēšanas kombinācija tika nepareizi uzzīmēta <xliff:g id="NUMBER_0">%d</xliff:g> reizes."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_1">%d</xliff:g> sekundēm."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Jūs esat ievadījis nepareizu paroli <xliff:g id="NUMBER_0">%d</xliff:g> reizes."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_1">%d</xliff:g> sekundēm."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"Jūs esat ievadījis nepareizu PIN <xliff:g id="NUMBER_0">%d</xliff:g> reizes."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_1">%d</xliff:g> sekundēm."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Atbloķēšanas kombinācija tika nepareizi uzzīmēta <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīgiem mēģinājumiem planšetdators būs jāatbloķē, izmantojot pierakstīšanos Google kontā."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_2">%d</xliff:g> sekundēm."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Atbloķēšanas kombinācija tika nepareizi uzzīmēta <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīgiem mēģinājumiem tālrunis būs jāatbloķē, izmantojot pierakstīšanos Google kontā."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_2">%d</xliff:g> sekundēm."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Jūs nepareizi veicāt planšetdatora atbloķēšanu <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīga(-iem) mēģinājuma(-iem) planšetdatorā tiks atiestatīti rūpnīcas noklusējuma iestatījumi, un lietotāja dati tiks zaudēti."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Jūs nepareizi veicāt tālruņa atbloķēšanu <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīga(-iem) mēģinājuma(-iem) tālrunī tiks atiestatīti rūpnīcas noklusējuma iestatījumi, un lietotāja dati tiks zaudēti."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Jūs nepareizi veicāt planšetdatora atbloķēšanu <xliff:g id="NUMBER">%d</xliff:g> reizes. Planšetdatorā tiks atiestatīti rūpnīcas noklusējuma iestatījumi."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Jūs nepareizi veicāt tālruņa atbloķēšanu <xliff:g id="NUMBER">%d</xliff:g> reizes. Tālrunī tiks atiestatīti rūpnīcas noklusējuma iestatījumi."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER">%d</xliff:g> sekundes(-ēm)."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Vai aizmirsāt kombināciju?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Konta atbloķēšana"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Veikts pārāk daudz kombinācijas mēģinājumu!"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Lai atbloķētu, pierakstieties Google kontā."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Lietotājvārds (e-pasts)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Parole"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Pierakstīties"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Lietotājvārds vai parole nav derīga."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Vai aizmirsāt lietotājvārdu vai paroli?"\n"Apmeklējiet vietni "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Notiek pārbaude..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Atbloķēt"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Skaņa ir ieslēgta"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Skaņa ir izslēgta."</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Kombinācija uzsākta"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Kombinācija notīrīta"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Šūna pievienota"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Kombinācija pabeigta"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. %2$d. logrīks no %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Pievienot logrīku."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Tukšs"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Atbloķēšanas apgabals ir izvērsts."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Atbloķēšanas apgabals ir sakļauts."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Logrīks <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Lietotāju atlasītājs"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Statuss"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Kamera"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Multivides vadīklas"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Logrīku pārkārtošana ir sākta."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Logrīku pārkārtošana ir pabeigta."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Logrīks <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> ir izdzēsts."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Izvērst atbloķēšanas apgabalu."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Autorizācija, velkot ar pirkstu."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Autorizācija ar kombināciju."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Autorizācija pēc sejas."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Autorizācija ar PIN kodu."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Autorizācija ar paroli."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Kombinācijas ievades apgabals."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Apgabals, kur vilkt ar pirkstu."</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">"rakstzīme"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"vārds"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"saite"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"rindiņa"</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">"Rūpnīcas pārbaude neizdevās"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Darbība FACTORY_TEST tiek atbalstīta tikai pakotnēm, kas ir instalētas šeit: /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Netika atrasts neviena pakotne, kas nodrošina darbību FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Atsāknēt"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Lapā <xliff:g id="TITLE">%s</xliff:g> ir teikts:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Navigācijas apstiprināšana"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Pamest šo lapu"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Palikt šajā lapā"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>"\n\n"Vai tiešām vēlaties pamest šo lapu?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Apstiprināt"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Padoms. Divreiz pieskarieties, lai tuvinātu un tālinātu."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Automātiskā aizpilde"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Iest. aut. aizp."</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">"Province"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Pasta indekss"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Štats"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Pasta indekss"</string>
    <string name="autofill_county" msgid="237073771020362891">"Apgabals"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Sala"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Rajons"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Departaments"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektūra"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Pagasts"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Reģions"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirāts"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"lasīt tīmekļa grāmatzīmes un vēsturi"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Ļauj lietotnei lasīt visu pārlūkprogrammā apmeklēto URL vēsturi un visas pārlūkprogrammas grāmatzīmes. Piezīme: šo atļauju nevar piemērot trešās puses pārlūkprogrammas vai citas lietojumprogrammas ar tīmekļa pārlūkošanas iespējām."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"rakstīt tīmekļa grāmatzīmes un vēsturi"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Ļauj lietotnei mainīt planšetdatorā saglabāto pārlūkprogrammas vēsturi vai grāmatzīmes. Tas var ļaut lietotnei dzēst vai pārveidot pārlūkprogrammas datus. Piezīme: šo atļauju nevar piemērot trešo pušu pārlūkprogrammas vai citas lietojumprogrammas ar tīmekļa pārlūkošanas iespējām."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Ļauj lietotnei mainīt tālrunī saglabāto pārlūkprogrammas vēsturi vai grāmatzīmes. Tas var ļaut lietotnei dzēst vai pārveidot pārlūkprogrammas datus. Piezīme: šo atļauju nevar piemērot trešo pušu pārlūkprogrammas vai citas lietojumprogrammas ar tīmekļa pārlūkošanas iespējām."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"iestatīt modinātāju"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Ļauj lietotnei iestatīt signālu instalētajā modinātājpulksteņa lietotnē. Dažās modinātājpulksteņu lietotnēs šo funkciju, iespējams, nevar ieviest."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"pievienot balss pastu"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Ļauj lietotnei pievienot ziņojumus jūsu balss pasta iesūtnei."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"pārveidot pārlūkprogrammas ģeogrāfiskās atrašanās vietas atļaujas"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Ļauj lietotnei modificēt pārlūkprogrammas ģeogrāfiskās atrašanās vietas atļaujas. Ļaunprātīgas lietotnes to var izmantot, lai atļautu atrašanās vietas informācijas sūtīšanu uz citām vietnēm."</string>
    <string name="permlab_packageVerificationAgent" msgid="5568139100645829117">"pakotņu verificēšana"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Ļauj lietotnei verificēt, vai pakotne ir instalējama."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"saistīšana ar pakotnes verificētāju"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Ļauj īpašniekam sūtīt pakotņu verificētāju pieprasījumus. Parastajām lietotnēm tas nekad nav nepieciešams."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"piekļuve seriālajiem portiem"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Ļauj īpašniekam piekļūt seriālajiem portiem, izmantojot SerialManager API."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"ārēji piekļūt satura nodrošinātājiem"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Ļauj īpašniekam no čaulas piekļūt satura nodrošinātājiem. Nekad nav nepieciešama parastām lietotnēm."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"neatļaut automāt. ierīces atjauninājumus"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Ļauj īpašniekam piedāvāt sistēmai vēlamo laiku, kad veikt neinteraktīvu atsāknēšanu, lai jauninātu ierīci."</string>
    <string name="save_password_message" msgid="767344687139195790">"Vai vēlaties, lai pārlūkprogrammā tiktu saglabāta šī parole?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Ne tagad"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Atcerēties"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nekad"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Jums nav atļaujas atvērt šo lapu."</string>
    <string name="text_copied" msgid="4985729524670131385">"Teksts ir kopēts uz starpliktuvi."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Vairāk"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Izvēlne+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"atstarpe"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"ievade"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"dzēst"</string>
    <string name="search_go" msgid="8298016669822141719">"Meklēt"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Meklēt"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Meklēšanas vaicājums"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Notīrīt vaicājumu"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Iesniedziet vaicājumu."</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Meklēšana ar balsi"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Vai iesp. “Pārlūkot pieskaroties”?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> vēlas iespējot funkciju “Atklāt pieskaroties”. Kad ir ieslēgta funkcija “Atklāt pieskaroties”, var dzirdēt vai redzēt tā vienuma aprakstu, virs kura atrodas pirksts, vai veikt žestus, lai mijiedarbotos ar planšetdatoru."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> vēlas iespējot funkciju “Atklāt pieskaroties”. Kad ir ieslēgta funkcija “Atklāt pieskaroties”, var dzirdēt vai redzēt tā vienuma aprakstu, virs kura atrodas pirksts, vai veikt žestus, lai mijiedarbotos ar tālruni."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"Pirms 1 mēneša"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Vairāk nekā pirms 1 mēneša"</string>
  <plurals name="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"Pirms 1 sekundes"</item>
    <item quantity="other" msgid="3903706804349556379">"Pirms <xliff:g id="COUNT">%d</xliff:g> sekundes(-ēm)"</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"Pirms 1 minūtes"</item>
    <item quantity="other" msgid="2176942008915455116">"Pirms <xliff:g id="COUNT">%d</xliff:g> minūtes(-ēm)"</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"Pirms 1 stundas"</item>
    <item quantity="other" msgid="2467273239587587569">"Pirms <xliff:g id="COUNT">%d</xliff:g> stundas(-ām)"</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Pēdējās <xliff:g id="COUNT">%d</xliff:g> dienās"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Iepriekšējā mēnesī"</string>
    <string name="older" msgid="5211975022815554840">"Vecāks"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"vakar"</item>
    <item quantity="other" msgid="2479586466153314633">"Pirms <xliff:g id="COUNT">%d</xliff:g> dienas(-ām)"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"pēc 1 sekundes"</item>
    <item quantity="other" msgid="1241926116443974687">"pēc <xliff:g id="COUNT">%d</xliff:g> sekundes(-ēm)"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"pēc 1 minūtes"</item>
    <item quantity="other" msgid="3330713936399448749">"pēc <xliff:g id="COUNT">%d</xliff:g> minūtes(-ēm)"</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"pēc 1 stundas"</item>
    <item quantity="other" msgid="547290677353727389">"pēc <xliff:g id="COUNT">%d</xliff:g> stundas(-ām)"</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"rītdien"</item>
    <item quantity="other" msgid="5109449375100953247">"pēc <xliff:g id="COUNT">%d</xliff:g> dienas(-ām)"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"Pirms 1 sekundes"</item>
    <item quantity="other" msgid="3699169366650930415">"Pirms <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"Pirms 1 min"</item>
    <item quantity="other" msgid="851164968597150710">"Pirms <xliff:g id="COUNT">%d</xliff:g> min"</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"Pirms 1 stundas"</item>
    <item quantity="other" msgid="6889970745748538901">"Pirms <xliff:g id="COUNT">%d</xliff:g> stundas(-ām)"</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"vakar"</item>
    <item quantity="other" msgid="3453342639616481191">"Pirms <xliff:g id="COUNT">%d</xliff:g> dienas(-ām)"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"pēc 1 s"</item>
    <item quantity="other" msgid="5495880108825805108">"pēc <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"pēc 1 min"</item>
    <item quantity="other" msgid="4216113292706568726">"pēc <xliff:g id="COUNT">%d</xliff:g> minūtes(-ēm)"</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"pēc 1 stundas"</item>
    <item quantity="other" msgid="3705373766798013406">"pēc <xliff:g id="COUNT">%d</xliff:g> stundas(-ām)"</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"rītdien"</item>
    <item quantity="other" msgid="2973062968038355991">"pēc <xliff:g id="COUNT">%d</xliff:g> dienas(-ām)"</item>
  </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"šādā datumā: <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"plkst. <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"šādā gadā: <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8144195776058119424">"diena"</string>
    <string name="days" msgid="4774547661021344602">"dienas"</string>
    <string name="hour" msgid="2126771916426189481">"stunda"</string>
    <string name="hours" msgid="894424005266852993">"stundas"</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">"nedēļa"</string>
    <string name="weeks" msgid="6509623834583944518">"nedēļas"</string>
    <string name="year" msgid="4001118221013892076">"gads"</string>
    <string name="years" msgid="6881577717993213522">"gadi"</string>
  <plurals name="duration_seconds">
    <item quantity="one" msgid="6962015528372969481">"1 s"</item>
    <item quantity="other" msgid="1886107766577166786">"<xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="duration_minutes">
    <item quantity="one" msgid="4915414002546085617">"1 min"</item>
    <item quantity="other" msgid="3165187169224908775">"<xliff:g id="COUNT">%d</xliff:g> min"</item>
  </plurals>
  <plurals name="duration_hours">
    <item quantity="one" msgid="8917467491248809972">"1 h"</item>
    <item quantity="other" msgid="3863962854246773930">"<xliff:g id="COUNT">%d</xliff:g> h"</item>
  </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Video problēma"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Šis video nav derīgs straumēšanai uz šo ierīci."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Nevar atskaņot šo video."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"Labi"</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">"pusdienlaiks"</string>
    <string name="Noon" msgid="3342127745230013127">"Pusdienlaiks"</string>
    <string name="midnight" msgid="7166259508850457595">"pusnakts"</string>
    <string name="Midnight" msgid="5630806906897892201">"Pusnakts"</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">"Atlasīt visu"</string>
    <string name="cut" msgid="3092569408438626261">"Izgriezt"</string>
    <string name="copy" msgid="2681946229533511987">"Kopēt"</string>
    <string name="paste" msgid="5629880836805036433">"Ielīmēt"</string>
    <string name="replace" msgid="5781686059063148930">"Aizstāt"</string>
    <string name="delete" msgid="6098684844021697789">"Dzēst"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopēt URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Atlasīt tekstu"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Teksta atlase"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Pievienot vārdnīcai"</string>
    <string name="deleteText" msgid="6979668428458199034">"Dzēst"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Ievades metode"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Teksta darbības"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Paliek maz brīvas vietas"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Dažas sistēmas funkcijas var nedarboties."</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"<xliff:g id="APP_NAME">%1$s</xliff:g> darbojas"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Pieskarieties, lai iegūtu plašāku informāciju vai apturētu lietotnes darbību."</string>
    <string name="ok" msgid="5970060430562524910">"Labi"</string>
    <string name="cancel" msgid="6442560571259935130">"Atcelt"</string>
    <string name="yes" msgid="5362982303337969312">"Labi"</string>
    <string name="no" msgid="5141531044935541497">"Atcelt"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Uzmanību!"</string>
    <string name="loading" msgid="7933681260296021180">"Notiek ielāde..."</string>
    <string name="capital_on" msgid="1544682755514494298">"IESLĒGT"</string>
    <string name="capital_off" msgid="6815870386972805832">"IZSLĒGT"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Pabeigt darbību, izmantojot"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Pēc noklusējuma izmantot šai darbībai."</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Notīriet noklusējuma iestatījumus šeit: Sistēmas iestatījumi &gt; Lietotnes &gt; Lejupielādētās."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Darbības izvēle"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Lietotnes izvēlēšanās USB ierīcei"</string>
    <string name="noApplications" msgid="2991814273936504689">"Šo darbību nevar veikt neviena lietotne."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Diemžēl lietojumprogrammas <xliff:g id="APPLICATION">%1$s</xliff:g> darbība ir apturēta."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Diemžēl process <xliff:g id="PROCESS">%1$s</xliff:g> ir apturēts."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"Lietojumprogramma <xliff:g id="APPLICATION">%2$s</xliff:g> nereaģē."\n\n"Vai vēlaties to aizvērt?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Darbība <xliff:g id="ACTIVITY">%1$s</xliff:g> nereaģē."\n\n"Vai vēlaties to aizvērt?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"Lietojumprogramma <xliff:g id="APPLICATION">%1$s</xliff:g> nereaģē. Vai vēlaties to aizvērt?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Process <xliff:g id="PROCESS">%1$s</xliff:g> nereaģē."\n\n"Vai vēlaties to aizvērt?"</string>
    <string name="force_close" msgid="8346072094521265605">"Labi"</string>
    <string name="report" msgid="4060218260984795706">"Pārskats"</string>
    <string name="wait" msgid="7147118217226317732">"Gaidīt"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"No lapas netiek saņemta atbilde."\n\n"Vai vēlaties to aizvērt?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Lietotne ir novirzīta"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"<xliff:g id="APP_NAME">%1$s</xliff:g> tagad darbojas."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"Sākotnēji tika palaista lietojumprogramma <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Mērogs"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Rādīt vienmēr"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Atkārtoti iespējojiet šeit: Sistēmas iestatījumi &gt; Lietotnes &gt; Lejupielādētās."</string>
    <string name="smv_application" msgid="3307209192155442829">"Lietotne <xliff:g id="APPLICATION">%1$s</xliff:g> (process <xliff:g id="PROCESS">%2$s</xliff:g>) ir pārkāpusi savu pašieviesto StrictMode politiku."</string>
    <string name="smv_process" msgid="5120397012047462446">"Process <xliff:g id="PROCESS">%1$s</xliff:g> ir pārkāpis savu pašieviesto StrictMode politiku."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Notiek Android jaunināšana..."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Tiek optimizēta <xliff:g id="NUMBER_0">%1$d</xliff:g>. lietotne no <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Notiek lietotņu palaišana."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Tiek pabeigta sāknēšana."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"<xliff:g id="APP">%1$s</xliff:g> darbojas"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Pieskarieties, lai pārslēgtos uz lietotni"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Vai pārslēgt lietotnes?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Jau darbojas cita lietotne. Tās darbība ir jāaptur, lai varētu startēt jaunu lietotni."</string>
    <string name="old_app_action" msgid="493129172238566282">"Atgriezties: <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Nestartējiet jauno lietotni."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Startēt: <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Aptur vecās lietotnes darbību, neko nesaglabājot."</string>
    <string name="sendText" msgid="5209874571959469142">"Izvēlieties darbību tekstam"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Zvanītāja skaļums"</string>
    <string name="volume_music" msgid="5421651157138628171">"Multivides skaļums"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Atskaņošana, izmantojot Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Klusais zvana signāls ir iestatīts."</string>
    <string name="volume_call" msgid="3941680041282788711">"Zvana skaļums"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Bluetooth sarunas skaļums"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Signāla skaļums"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Paziņojumu skaļums"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Skaļums"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Bluetooth apjoms"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Zvana signāla skaļums"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Zvana skaļums"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Multivides skaļums"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Paziņojumu skaļums"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Noklusējuma zvana signāls"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Noklusējuma zvana signāls (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Nav"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Zvana signāli"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Nezināms zvana signāls"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"Wi-Fi tīkls ir pieejams."</item>
    <item quantity="other" msgid="4192424489168397386">"Wi-Fi tīkli ir pieejami"</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"Ir pieejams atvērts Wi-Fi tīkls"</item>
    <item quantity="other" msgid="7915895323644292768">"Ir pieejami atvērti Wi-Fi tīkli."</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Pierakstieties Wi-Fi tīklā."</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Pierakstīšanās tīklā"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Nevarēja izveidot savienojumu ar Wi-Fi."</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" ir slikts interneta savienojums."</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Palaist programmu Wi-Fi Direct. Tādējādi tiks izslēgta Wi-Fi klienta/tīklāja darbība."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Nevarēja palaist programmu Wi-Fi Direct."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Wi-Fi Direct ir ieslēgts"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Pieskarieties, lai piekļūtu iestatījumiem."</string>
    <string name="accept" msgid="1645267259272829559">"Piekrist"</string>
    <string name="decline" msgid="2112225451706137894">"Noraidīt"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Ielūgums ir nosūtīts."</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Ielūgums izveidot savienojumu"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"No:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Kam:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Ierakstiet pieprasīto PIN:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"Planšetdators tiks īslaicīgi atvienots no Wi-Fi tīkla, kamēr būs izveidots savienojums ar ierīci <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"Tālrunis tiks īslaicīgi atvienots no Wi-Fi tīkla, kamēr būs izveidots savienojums ar ierīci <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="select_character" msgid="3365550120617701745">"Ievietojiet rakstzīmi"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Īsziņu sūtīšana"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"Lietotne &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; sūta daudz īsziņu. Vai vēlaties, lai šī lietotne turpinātu sūtīt ziņojumus?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Atļaut"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Aizliegt"</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; vēlas sūtīt īsziņu adresātam &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="3492025719868078457">"No jūsu mobilās ierīces konta "<font fgcolor="#ffffb060">"var tikt iekasēta maksa"</font>"."</string>
    <string name="sms_premium_short_code_details" msgid="5523826349105123687"><font fgcolor="#ffffb060">"No jūsu mobilās ierīces konta tiks iekasēta maksa."</font></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Sūtīt"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Atcelt"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Atcerēties manu izvēli"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Lai mainītu: Iestatījumi &gt; Lietotnes"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Vienmēr atļaut"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Neatļaut nekad"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM karte ir izņemta."</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Mobilais tīkls nebūs pieejams līdz brīdim, kad restartēsiet ierīci ar ievietotu derīgu SIM karti."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Gatavs"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"SIM karte ir pievienota."</string>
    <string name="sim_added_message" msgid="6599945301141050216">"Ierīces restartēšana, lai piekļūtu mobilo sakaru tīklam."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Restartēt"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Laika iestatīšana"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Datuma iestatīšana"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Iestatīt"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Gatavs"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"JAUNA: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Nodrošina <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Atļaujas nav nepieciešamas."</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"par to no jums var tikt iekasēta maksa"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"USB lielapjoma atmiņa"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB ir pievienots."</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Ir izveidots savienojums ar datoru, izmantojot USB. Pieskarieties tālāk esošajai pogai, ja vēlaties kopēt failus no datora Android USB atmiņā vai otrādi."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Ir izveidots savienojums ar datoru, izmantojot USB. Pieskarieties tālāk esošajai pogai, ja vēlaties kopēt failus no datora Android SD kartē vai otrādi."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Ieslēgt USB krātuvi"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Izmantojot USB atmiņu lielapjoma uzglabāšanai USB atmiņā, radās problēma."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Izmantojot SD karti lielapjoma uzglabāšanai USB atmiņā, radās problēma."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB ir pievienots."</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Pieskarieties, lai kopētu failus datorā/no datora."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"USB krātuves izslēgšana"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Pieskarieties, lai izslēgtu USB atmiņu."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"USB krātuve tiek izmantota"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Pirms USB atmiņas izslēgšanas atvienojiet Android USB atmiņu no datora (tai jābūt “izstumtai”)."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Pirms USB atmiņas izslēgšanas atvienojiet Android SD karti no datora (tai jābūt “izstumtai”)."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Izslēgt USB krātuvi"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Izslēdzot USB atmiņu, radās problēma. Pārliecinieties, ka USB saimniekdators ir noņemts, un pēc tam mēģiniet vēlreiz."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Ieslēgt USB krātuvi"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Ja ieslēgsiet USB atmiņu, dažu izmantoto lietotņu darbība tiks apturēta un tās var nebūt pieejamas līdz brīdim, kad USB atmiņa tiks izslēgta."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"USB atmiņas darbība neizdevās."</string>
    <string name="dlg_ok" msgid="7376953167039865701">"Labi"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Pievienots kā multivides ierīce"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Pievienots kā kamera"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Pievienots kā instalēšanas programma"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Ir izveidots savienojums ar USB piederumu."</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Pieskarieties, lai skatītu citas USB opcijas."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Vai formatēt USB atmiņu?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Vai formatēt SD karti?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Visi USB atmiņā saglabātie faili tiks dzēsti. Šo darbību nevar atsaukt."</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Visi jūsu kartes dati tiks zaudēti."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Formatēt"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"USB atkļūdošana ir pievienota."</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Pieskarieties, lai atspējotu USB atkļūdošanu."</string>
    <string name="select_input_method" msgid="4653387336791222978">"Ievades metodes izvēle"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Iestatīt ievades metodes"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Fiziskā tastatūra"</string>
    <string name="hardware" msgid="7517821086888990278">"Aparatūra"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Atlasiet tastatūras izkārtojumu"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Pieskarieties, lai atlasītu tastatūras izkārtojumu."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" AĀBCČDEĒFGĢHIĪJKĶLĻMNŅOPRSŠTUŪVZŽ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789AĀBCČDEĒFGĢHIĪJKĶLĻMNŅOPRSŠTUŪVZŽ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"kandidāti"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"Notiek USB kr. sagatavošana"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"SD kartes sagatavošana"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Notiek kļūdu meklēšana."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Tukša USB krātuve"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Tukša SD karte"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"USB atmiņa ir tukša, vai arī tajā ir neatbalstīta failu sistēma."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"SD karte ir tukša, vai arī tajā ir neatbalstīta failu sistēma."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Bojāta USB krātuve"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Bojāta SD karte"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"USB atmiņa ir bojāta. Mēģiniet to atkārtoti formatēt."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"SD karte ir bojāta. Mēģiniet to atkārtoti formatēt."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"USB kr. tika negaidīti noņemta"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"SD karte tika negaidīti izņemta."</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Pirms noņemšanas atvienojiet USB krātuvi, lai nezaudētu datus."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Demontēt SD karti pirms tās izņemšanas, lai netiktu zaudēti dati."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"USB krātuvi var droši noņemt"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"SD karti var droši noņemt."</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"Varat droši noņemt USB krātuvi."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"Varat droši noņemt SD karti."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"Noņemta USB krātuve"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Izņemta SD karte"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"USB krātuve ir noņemta. Ievietojiet jaunu datu nesēju."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"SD karte ir izņemta. Ievietojiet citu karti."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nav atrasta neviena atbilstoša darbība."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"atjaunināt komponenta lietojuma statistiku"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Ļauj lietotnei modificēt apkopoto statistiku par komponenta lietojumu. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"kopēt saturu"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Ļauj lietotnei izsaukt noklusējuma konteinera pakalpojumu, lai kopētu saturu. Atļauja neattiecas uz parastām lietotnēm."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Multivides datu izejas maršrutēšana"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Ļauj lietojumprogrammai maršrutēt multivides datu izeju uz citām ārējām ierīcēm."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Pieskarieties divreiz, lai kontrolētu tālummaiņu."</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Nevarēja pievienot logrīku."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Doties uz"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Meklēt"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Sūtīt"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Tālāk"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Gatavs"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Iepr."</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Izpildīt"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Sastādiet numuru"\n"izmantojot <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Izveidot kontaktpersonu"\n"izmantojot šo numuru: <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Viena vai vairākas no tālāk minētajām lietotnēm pieprasa atļauju piekļūt jūsu kontam tagad un arī turpmāk."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Vai vēlaties atļaut šo pieprasījumu?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Piekļuves pieprasījums"</string>
    <string name="allow" msgid="7225948811296386551">"Atļaut"</string>
    <string name="deny" msgid="2081879885755434506">"Noraidīt"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Atļauja ir pieprasīta."</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Atļauja kontam <xliff:g id="ACCOUNT">%s</xliff:g>"\n"ir pieprasīta."</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Ievades metode"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sinhronizācija"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Pieejamība"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Fona tapete"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Tapetes maiņa"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Paziņojumu uztvērējs"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN ir aktivizēts."</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"Lietojumprogramma <xliff:g id="APP">%s</xliff:g> aktivizēja VPN."</string>
    <string name="vpn_text" msgid="3011306607126450322">"Pieskarieties, lai pārvaldītu tīklu."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Ir izveidots savienojums ar <xliff:g id="SESSION">%s</xliff:g>. Pieskarieties, lai pārvaldītu tīklu."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Notiek savienojuma izveide ar vienmēr ieslēgtu VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Izveidots savienojums ar vienmēr ieslēgtu VPN."</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Kļūda saistībā ar vienmēr ieslēgtu VPN"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Pieskarieties, lai konfigurētu."</string>
    <string name="upload_file" msgid="2897957172366730416">"Izvēlēties failu"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Neviens fails nav izvēlēts"</string>
    <string name="reset" msgid="2448168080964209908">"Atiestatīt"</string>
    <string name="submit" msgid="1602335572089911941">"Iesniegt"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Automobiļa režīms ir iespējots."</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Pieskarieties, lai izietu no automašīnas režīma."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Piesaiste vai tīklājs ir aktīvs."</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Pieskarieties, lai iestatītu."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Atpakaļ"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Tālāk"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Izlaist"</string>
    <string name="throttle_warning_notification_title" msgid="4890894267454867276">"Augsts mobilo datu lietojums"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Pieskarieties, lai uzzinātu vairāk par mobilo datu izmantošanu."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Ir pārsniegts mobilo datu ierobežojums."</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Pieskarieties, lai uzzinātu vairāk par mobilo datu izmantošanu."</string>
    <string name="no_matches" msgid="8129421908915840737">"Nav atbilstību"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Atrast lapā"</string>
  <plurals name="matches_found">
    <item quantity="one" msgid="8167147081136579439">"1 atbilstība"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g> no <xliff:g id="TOTAL">%d</xliff:g>"</item>
  </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Gatavs"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Notiek USB atmiņas atvienošana..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Notiek SD kartes atvienošana..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Notiek USB atmiņas dzēšana..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Notiek SD kartes dzēšana..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Nevarēja dzēst USB atmiņu."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Nevarēja dzēst SD karti."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"SD karte pirms atvienošanas tika noņemta."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"USB atmiņa pašlaik tiek pārbaudīta."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"SD karte pašlaik tiek pārbaudīta."</string>
    <string name="media_removed" msgid="7001526905057952097">"SD karte ir noņemta."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"USB krātuve pašlaik tiek izmantota datorā."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"SD karte pašlaik tiek izmantota datorā."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Ārējais datu nesējs ir nezināmā stāvoklī."</string>
    <string name="share" msgid="1778686618230011964">"Kopīgot"</string>
    <string name="find" msgid="4808270900322985960">"Atrast"</string>
    <string name="websearch" msgid="4337157977400211589">"Meklēt tīmeklī"</string>
    <string name="find_next" msgid="5742124618942193978">"Atrast nākamo"</string>
    <string name="find_previous" msgid="2196723669388360506">"Atrast iepriekšējo"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Atrašanās vietas pieprasījums no: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Atrašanās vietas pieprasījums"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Pieprasīja: <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Jā"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Nē"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Pārsniegts dzēšanas ierobežojums"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"<xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g>, konts <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>: izdzēsti <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> vienumi. Kādas darbības vēlaties veikt?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Dzēsiet šos vienumus."</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Atsaukt dzēšanu."</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Pagaidām neveiciet nekādas darbības."</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Izvēlēties kontu"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Pievienot kontu"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Pievienot kontu"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Palielināt"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Samazināt"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g>: pieskarieties un turiet nospiestu."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Velciet uz augšu, lai palielinātu vērtību, un uz leju, lai to samazinātu."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Norādīt vēlākas minūtes"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Norādīt agrākas minūtes"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Norādīt vēlāku stundu"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Norādīt agrāku stundu"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Iestatīt pēcpusdienas laiku"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Iestatīt priekšpusdienas laiku"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Norādīt vēlāku mēnesi"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Norādīt agrāku mēnesi"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Norādīt vēlāku dienu"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Norādīt agrāku dienu"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Norādīt vēlāku gadu"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Norādīt agrāku gadu"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alternēšanas taustiņš"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Atcelt"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Dzēšanas taustiņš"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Gatavs"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Režīma maiņa"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Pārslēgšanas taustiņš"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Ievadīšanas taustiņš"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Izvēlieties lietotni"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Kopīgot ar:"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Kopīgot ar lietojumprogrammu <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Bīdāms turis. Pieskarieties tam un turiet to nospiestu."</string>
    <string name="description_direction_up" msgid="7169032478259485180">"Velciet uz augšu, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Velciet uz leju, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Velciet pa kreisi, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Velciet pa labi, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Atbloķēt"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Kamera"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Klusums"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Skaņa ieslēgta"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Meklēt"</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Velciet ar pirkstu, lai atbloķētu."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Pievienojiet austiņas, lai dzirdētu paroles taustiņu nosaukumus."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Punkts."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Pārvietoties uz sākuma ekrānu"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Pārvietoties augšup"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Vairāk opciju"</string>
    <string name="action_bar_home_description_format" msgid="7965984360903693903">"%1$s: %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="6985546530471780727">"%1$s, %2$s: %3$s"</string>
    <string name="storage_internal" msgid="4891916833657929263">"Iekšējā atmiņa"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD karte"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB atmiņa"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Rediģēt"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Datu izmantošanas brīdinājums"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Piesk., lai sk. lietoš. un iest."</string>
    <string name="data_usage_3g_limit_title" msgid="7093334419518706686">"2G–3G dati ir atspējoti"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"4G dati ir atspējoti"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Mobilie dati ir atspējoti"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"Wi-Fi dati atspējoti"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Pieskarieties, lai iespējotu."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"2G-3G datu ierobež. pārsniegts"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"4G datu limits pārsniegts"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Pārsniegts mobilo datu ierobežoj."</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Wi-Fi datu ierobež. pārsniegts"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> virs norādītā ierobežojuma."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Fona dati ir ierobežoti."</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Pieskar., lai noņemtu ierobež."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Drošības sertifikāts"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Sertifikāts ir derīgs."</string>
    <string name="issued_to" msgid="454239480274921032">"Izdots:"</string>
    <string name="common_name" msgid="2233209299434172646">"Kopējais nosaukums:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizācija:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organizatoriskā vienība:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Izsniedzējs:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Derīgums:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Izsniegšanas datums:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Derīguma termiņš:"</string>
    <string name="serial_number" msgid="758814067660862493">"Sērijas numurs:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Identifikatori"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"SHA-256 identifikators"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"SHA-1 identifikators:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Skatīt visu"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Darbības izvēle"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Kopīgošana ar:"</string>
    <string name="status_bar_device_locked" msgid="3092703448690669768">"Ierīce ir bloķēta."</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Notiek sūtīšana…"</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Vai palaist pārlūkprogrammu?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Vai atbildēt uz zvanu?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Vienmēr"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Tikai vienreiz"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Planšetdators"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Tālrunis"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Austiņas"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Doka skaļruņi"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Sistēma"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth audio"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Bezvadu attēlošana"</string>
    <string name="media_route_chooser_grouping_done" msgid="7966438307723317169">"Gatavs"</string>
    <string name="media_route_button_content_description" msgid="5758553567065145276">"Multivides izeja"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Notiek meklēšana..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Notiek savienojuma izveide..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Pieejams"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Nav pieejams"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Iebūvēts ekrāns"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI ekrāns"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Pārklājums 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">"Bezvadu attēlošanas savienojums ir izveidots."</string>
    <string name="wifi_display_notification_message" msgid="4498802012464170685">"Šis ekrāns tiek rādīts citā ierīcē."</string>
    <string name="wifi_display_notification_disconnect" msgid="6183754463561153372">"Pārtraukt savienojumu"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Ārkārtas izsaukums"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Aizmirsu kombināciju"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Nepareiza kombinācija"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Nepareiza parole"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Nepareizs PIN"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER">%d</xliff:g> sekundēm."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Norādiet savu kombināciju"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Ievadiet SIM kartes PIN"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Ievadiet PIN"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Ievadiet paroli"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"SIM karte ir atspējota. Lai turpinātu, ievadiet PUK kodu. Lai iegūtu detalizētu informāciju, sazinieties ar mobilo sakaru operatoru."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Ievadiet vēlamo PIN kodu."</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Apstipriniet vēlamo PIN."</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Notiek SIM kartes atbloķēšana..."</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"PIN kods nav pareizs."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Ievadiet PIN, kas sastāv no 4 līdz 8 cipariem."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="7553388325654369575">"PUK kodam ir jābūt vismaz 8 ciparus garam."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Atkārtoti ievadiet pareizo PUK kodu. Ja vairākas reizes ievadīsiet to nepareizi, SIM karte tiks neatgriezeniski atspējota."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"PIN kodi neatbilst."</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Pārāk daudz kombinācijas mēģinājumu"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Lai atbloķētu, pierakstieties, izmantojot savu Google kontu."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Lietotājvārds (e-pasts)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Parole"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Pierakstīties"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Nederīgs lietotājvārds vai parole."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Vai aizmirsāt lietotājvārdu vai paroli?"\n"Apmeklējiet vietni "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Notiek konta pārbaude…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"Jūs nepareizi ievadījāt PIN <xliff:g id="NUMBER_0">%d</xliff:g> reizes."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_1">%d</xliff:g> sekundēm."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"Jūs nepareizi ievadījāt paroli <xliff:g id="NUMBER_0">%d</xliff:g> reizes."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_1">%d</xliff:g> sekundēm."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"Jūs nepareizi norādījāt atbloķēšanas kombināciju <xliff:g id="NUMBER_0">%d</xliff:g> reizes."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_1">%d</xliff:g> sekundēm."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"Jūs nepareizi veicāt planšetdatora atbloķēšanu <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīgiem mēģinājumiem planšetdatorā tiks atiestatīti rūpnīcas noklusējuma iestatījumi un lietotāja dati tiks zaudēti."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"Jūs nepareizi veicāt tālruņa atbloķēšanu <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīgiem mēģinājumiem tālrunī tiks atiestatīti rūpnīcas noklusējuma iestatījumi un lietotāja dati tiks zaudēti."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"Jūs nepareizi veicāt planšetdatora atbloķēšanu <xliff:g id="NUMBER">%d</xliff:g> reizes. Planšetdatorā tiks atiestatīti rūpnīcas noklusējuma iestatījumi."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"Jūs nepareizi veicāt tālruņa atbloķēšanu <xliff:g id="NUMBER">%d</xliff:g> reizes. Tālrunī tiks atiestatīti rūpnīcas noklusējuma iestatījumi."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"Jūs nepareizi norādījāt atbloķēšanas kombināciju <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīgiem mēģinājumiem planšetdators būs jāatbloķē, izmantojot e-pasta kontu."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_2">%d</xliff:g> sekundēm."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"Jūs nepareizi norādījāt atbloķēšanas kombināciju <xliff:g id="NUMBER_0">%d</xliff:g> reizes. Pēc vēl <xliff:g id="NUMBER_1">%d</xliff:g> neveiksmīgiem mēģinājumiem tālrunis būs jāatbloķē, izmantojot e-pasta kontu."\n\n"Mēģiniet vēlreiz pēc <xliff:g id="NUMBER_2">%d</xliff:g> sekundēm."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">"  — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Noņemt"</string>
    <string name="safe_media_volume_warning" product="default" msgid="7324161939475478066">"Vai palielināt skaļumu virs ieteicamā līmeņa?"\n"Ilgstoši klausoties skaņu lielā skaļumā, var tikt bojāta dzirde."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Lai iespējotu pieejamību, turiet nospiestus divus pirkstus."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Pieejamības režīms ir iespējots."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Pieejamība ir atcelta."</string>
    <string name="user_switched" msgid="3768006783166984410">"Pašreizējais lietotājs: <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="owner_name" msgid="2716755460376028154">"Īpašnieks"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Kļūda"</string>
    <string name="app_no_restricted_accounts" msgid="4011285085817350390">"Šajā lietojumprogrammā netiek atbalstīti ierobežotu profilu konti."</string>
    <string name="app_not_found" msgid="3429141853498927379">"Netika atrasta neviena lietojumprogramma, kas var veikt šo darbību."</string>
    <string name="revoke" msgid="5404479185228271586">"Atsaukt"</string>
</resources>
