<?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;Be pavadinimo&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Nėra telefono numerio)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Nežinomas)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Balso paštas"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Ryšio problema arba neteisingas MMI kodas."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operacija ribojama tik naudojant fiksuoto rinkimo numerius."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Paslauga įgalinta."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Paslauga buvo įgalinta:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Paslauga išjungta."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registracija sėkminga."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Ištrynimas sėkmingas."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Neteisingas slaptažodis."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI baigtas."</string>
    <string name="badPin" msgid="9015277645546710014">"Įvestas senasis PIN kodas neteisingas."</string>
    <string name="badPuk" msgid="5487257647081132201">"Įvestas PUK kodas neteisingas."</string>
    <string name="mismatchPin" msgid="609379054496863419">"Įvesti PIN kodai neatitinka."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Įveskite PIN kodą, sudarytą iš 4–8 skaičių."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Įveskite 8 skaitmenų ar ilgesnį PUK kodą."</string>
    <string name="needPuk" msgid="919668385956251611">"Jūsų SIM kortelė yra užrakinta PUK kodu. Jei norite ją atrakinti, įveskite PUK kodą."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Įveskite PUK2 kodą, kad panaikintumėte SIM kortelės blokavimą."</string>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Įeinančio skambintojo ID"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Išeinančio skambintojo ID"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Skambučio peradresavimas"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Laukiantis skambutis"</string>
    <string name="BaMmi" msgid="455193067926770581">"Skambučio paleidimas"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Slaptažodžio keitimas"</string>
    <string name="PinMmi" msgid="3113117780361190304">"PIN pakeitimas"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Skambinimo numeris yra"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Skambinimo numeris apribotas"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Skambinimas trimis būdais"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Nepageidaujamų įkyrių skambučių atmetimas"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Skambinimo numerio pristatymas"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Netrukdyti"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Skambintojo ID numatytieji nustatymai apriboti. Kitas skambutis: apribotas"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Skambintojo ID pagal numatytuosius nustatymus yra apribotas. Kitas skambutis: neapribotas"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Skambintojo ID pagal numatytuosius nustatymus nustatomas į neapribotą. Kitas skambutis: apribotas"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Skambintojo ID pagal numatytuosius nustatymus yra neapribotas. Kitas skambutis: neapribotas"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Paslauga neteikiama."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Negalima pakeisti skambinančiojo ID nustatymo."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Apribota prieiga pakeista"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Duomenų paslauga užblokuota."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Pagalbos paslauga užblokuota."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Balso paslauga užblokuota."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Blokuojamos visos balso paslaugos."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"SMS paslauga užblokuota."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Balso / duomenų paslaugos užblokuotos."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Balso / SMS paslaugos blokuojamos."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Blokuojamos visos balso / duomenų / SMS paslaugos."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"„Voice“"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Duomenys"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAKSAS"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Asinchroniški duomenys"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sinchronizuoti"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Paketas"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Tarptinklinio ryšio rodiklis įjungtas"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Tarptinklinio ryšio rodiklis išjungtas"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Tarptinklinio ryšio rodiklis blyksi"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Ne kaimynystėje"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Ne pastate"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Tarptinklinis ryšys – pageidaujama sistema"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Tarptinklinis ryšys – galima sistema"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Tarptinklinis ryšys – sąjungos partneris"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Tarptinklinis ryšys – svarbiausias partneris"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Tarptinklinis ryšys – visos paslaugos funkcijos"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Tarptinklinis ryšys – dalinis paslaugos veikimas"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Tarptinklinio ryšio reklamjuostė įjungta"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Tarptinklinio ryšio reklamjuostė išjungta"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Ieškoma paslaugos"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: neperadresuota"</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> po <xliff:g id="TIME_DELAY">{2}</xliff:g> sek."</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: neperadresuota"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: neperadresuota"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Funkcijos kodas baigtas."</string>
    <string name="fcError" msgid="3327560126588500777">"Ryšio problema arba neteisingas funkcijos kodas."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"Gerai"</string>
    <string name="httpError" msgid="7956392511146698522">"Įvyko tinklo klaida."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Nepavyko rasti URL."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Svetainės tapatybės nustatymo schema nepalaikoma."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Nepavyko nustatyti tapatybės."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Tapatybės nustatymas naudojant tarpinį serverį buvo nesėkmingas."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Nepavyko prisijungti prie serverio."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Nepavyko susisiekti su serveriu. Vėliau bandykite dar kartą."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Baigėsi ryšio su serveriu laikas."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Šiame puslapyje yra per daug serverio peradresavimų."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokolas nepalaikomas."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Nepavyko užmegzti saugaus ryšio."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Nepavyko atidaryti puslapio, nes URL netinkamas."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Nepavyko pasiekti failo."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Nepavyko rasti pageidaujamo failo."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Apdorojama per daug užklausų. Vėliau bandykite dar kartą."</string>
    <string name="notification_title" msgid="8967710025036163822">"<xliff:g id="ACCOUNT">%1$s</xliff:g> prisijungimo klaida"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sinchronizuoti"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Sinchronizuoti"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Per daug <xliff:g id="CONTENT_TYPE">%s</xliff:g> trynimo."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Planšetinio kompiuterio atmintis pilna. Kad atlaisvintumėte vietos, ištrinkite kelis failus."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Telefono atmintis pilna. Ištrinkite kai kuriuos failus, kad atlaisvintumėte vietos."</string>
    <string name="ssl_ca_cert_warning" msgid="5848402127455021714">"Tinklas gali būti stebimas"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Nežinoma trečioji šalis"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="me" msgid="6545696007631404292">"Aš"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Planšetinio kompiuterio parinktys"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Telefono parinktys"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Tylus režimas"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Įjungti bevielį"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Išjungti bevielį"</string>
    <string name="screen_lock" msgid="799094655496098153">"Ekrano užraktas"</string>
    <string name="power_off" msgid="4266614107412865048">"Išjungiamas maitinimas"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Skambutis išjungtas"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Vibracija skambinant"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Skambutis įjungtas"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Išsijungia..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Planšetinio kompiuterio veikimas bus sustabdytas."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Telefonas bus išjungtas."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Ar norite išjungti?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Iš naujo įkelti operacinę sistemą saugos režimu"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Ar norite iš naujo įkelti operacinę sistemą saugos režimu? Dėl to bus neleidžiamos visos įdiegtos trečiųjų šalių programos. Jos bus atkurtos dar kartą iš naujo įkėlus operacinę sistemą."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Naujos"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Nėra naujausių programų."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Planšetinio kompiuterio parinktys"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Telefono parinktys"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Ekrano užraktas"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Išjungiamas maitinimas"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Pranešimas apie triktį"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Pranešti apie triktį"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Bus surinkta informacija apie dabartinę įrenginio būseną ir išsiųsta el. pašto pranešimu. Šiek tiek užtruks, kol pranešimas apie triktį bus paruoštas siųsti; būkite kantrūs."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Tylus režimas"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Garsas IŠJUNGTAS"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Garsas ĮJUNGTAS"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Lėktuvo režimas"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"ĮJUNGTAS lėktuvo režimas"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"lėktuvo režimas IŠJUNGTAS"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="safeMode" msgid="2788228061547930246">"Saugos režimas"</string>
    <string name="android_system_label" msgid="6577375335728551336">"„Android“ sistema"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Paslaugos, už kurias mokėjote"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Atlikite mokamus veiksmus."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Jūsų pranešimai"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Skaitykite ir rašykite SMS, el. laiškus ir kitus pranešimus."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Asmeninė informacija"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Tiesioginė prieiga prie informacijos, saugomos kontaktinėje kortelėje."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Socialinė informacija"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Tiesioginė prieiga prie kontaktų ir socialinių ryšių informacijos."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Jūsų vieta"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Stebėti fizinę vietą."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Tinklo ryšys"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Pasiekti įvairias tinklo funkcijas."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Pasiekti įrenginius ir tinklus naudojant „Bluetooth“."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Garso nustatymai"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Keisti garso nustatymus."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"Paveikia akumuliatorių"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Naudoti funkcijas, galinčias greitai iškrauti akumuliatorių."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendorius"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Tiesioginė prieiga prie kalendoriaus ir įvykių."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Skaityti naudotojo žodyną"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Skaityti žodžius naudotojo žodyne."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Rašyti į naudotojo žodyną"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Pridėti žodžius į naudotojo žodyną."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Žymės ir istorija"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Tiesioginė prieiga prie žymių ir naršyklės istorijos."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Signalas"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"Nustatyti žadintuvo signalą."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Balso paštas"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Tiesioginė prieiga prie balso pašto."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofonas"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Tiesioginė prieiga prie mikrofono, kad būtų galima įrašyti garsą."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Fotoaparatas"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Tiesioginė prieiga prie fotoaparato, kad būtų galima fotografuoti vaizdus arba įrašyti vaizdo įrašus."</string>
    <string name="permgrouplab_screenlock" msgid="8275500173330718168">"Užrakinti ekraną"</string>
    <string name="permgroupdesc_screenlock" msgid="7067497128925499401">"Galimybė paveikti užrakinimo ekrano veikimą įrenginyje."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Programų informacija"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Galimybė paveikti kitų įrenginio programų veikimą."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Ekrano fonas"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"Keisti įrenginio ekrano fono nustatymus."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Laikrodis"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"Keisti įrenginio laiką arba laiko juostą."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Būsenos juosta"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"Keisti įrenginio būsenos juostos nustatymus."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Sinchronizavimo nustatymai"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Prieiga prie sinchronizavimo nustatymų."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Jūsų paskyros"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Pasiekite galimas paskyras."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Aparatinės įrangos valdikliai"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Tiesioginė prieiga prie aparatinės įrangos telefono ragelyje."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Telefono skambučiai"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Stebėti, įrašyti ir apdoroti telefono skambučius."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Sistemos įrankiai"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Žemesnio lygio prieiga prie sistemos ir jos valdymas."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Kūrėjo įrankiai"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Funkcijos reikalingos tik programos kūrėjams."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Kitų programų naudotojo sąsaja"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"Paveikti kitų programų naudotojo sąsają."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Saugykla"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Pasiekti USB atmintinę."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Pasiekite SD kortelę."</string>
    <string name="permgrouplab_accessibilityFeatures" msgid="7919025602283593907">"Pritaikymo neįgaliesiems funkcijos"</string>
    <string name="permgroupdesc_accessibilityFeatures" msgid="4205196881678144335">"Funkcijos, kurių užklausas gali teikti pagalbinė technologija."</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Gauti lango turinį"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Tikrinti lango, su kuriuo sąveikaujate, turinį."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Įjungti „Naršyti paliečiant“"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Paliesti elementai bus ištariami garsiai. Be to, ekrane gali būti naršoma naudojant gestus."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Įjungti patobulintą žiniatinklio pasiekiamumą"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Gali būti įdiegti scenarijai, kad būtų lengviau pasiekti programų turinį."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Stebėti jūsų įvedamą tekstą"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Įtraukiami asmeniniai duomenys, pavyzdžiui, kredito kortelių numeriai ir slaptažodžiai."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"išjungti ar keisti būsenos juostą"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Leidžiama programai neleisti būsenos juostos arba pridėti ir pašalinti sistemos piktogramas."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"būsenos juosta"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Leidžiama programai būti būsenos juosta."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"išskleisti / sutraukti būsenos juostą"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Leidžiama programai išskleisti arba sutraukti būsenos juostą."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"įdiegti sparčiuosius klavišus"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Programai leidžiama pridėti sparčiuosius klavišus prie pagrindinio ekrano be naudotojo įsikišimo."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"pašalinti sparčiuosius klavišus"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Programai leidžiama pašalinti sparčiuosius klavišus iš pagrindinio ekrano be naudotojo įsikišimo."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"peradresuoti išsiunčiamuosius skambučius"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Leidžiama programai atlikti išsiunčiamuosius skambučius ir keisti renkamą numerį. Šis leidimas suteikia teisę programai stebėti, peradresuoti ar neleisti išsiunčiamųjų skambučių."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"gauti teksto pranešimus (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Leidžiama programai gauti ir apdoroti SMS pranešimus. Tai reiškia, kad programa gali stebėti ir ištrinti į jūsų įrenginį siunčiamus pranešimus jums jų neparodžiusi."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"gauti teksto pranešimus (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Leidžiama programai gauti ir apdoroti MMS pranešimus. Tai reiškia, kad programa gali stebėti ir ištrinti į jūsų įrenginį siunčiamus pranešimus jums jų neparodžiusi."</string>
    <string name="permlab_receiveEmergencyBroadcast" msgid="1803477660846288089">"gauti kritinės padėties transliacijas"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Leidžiama programai gauti ir apdoroti skubiai pateikiamus pranešimus. Šis leidimas galimas tik sistemos programoms."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"skaityti mobiliuoju transliuojamus pranešimus"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Programai leidžiama skaityti mobiliuoju transliuojamus pranešimus, gaunamus jūsų įrenginyje. Mobiliuoju transliuojami įspėjimai pristatomi kai kuriose vietose, kad įspėtų apie kritines situacijas. Kai gaunamas  mobiliuoju transliuojamas pranešimas apie kritinę situaciją, kenkėjiškos programos gali trukdyti įrenginiui veikti ar jį naudoti."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"siųsti SMS pranešimus"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Leidžiama programai siųsti SMS pranešimus. Dėl to gali atsirasti nenumatytų apmokestinimų. Kenkėjiškos programos gali siųsti mokamus pranešimus be jūsų patvirtinimo."</string>
    <string name="permlab_sendRespondViaMessageRequest" msgid="8713889105305943200">"siųsti atsakymų pranešimu įvykius"</string>
    <string name="permdesc_sendRespondViaMessageRequest" msgid="7107648548468778734">"Programai leidžiama siųsti užklausas į kitas susirašinėjimo pranešimais programas, kad būtų galima apdoroti atsakymų pranešimu įvykius, susijusius su gaunamaisiais skambučiais."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"skaityti teksto pranešimus (SMS arba MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Leidžiama programai skaityti planšetiniame kompiuteryje ar SIM kortelėje saugomus SMS pranešimus. Taip programai leidžiama skaityti visus SMS pranešimus, neatsižvelgiant į turinį ar konfidencialumą."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Leidžiama programai skaityti telefone ar SIM kortelėje saugomus SMS pranešimus. Taip programai leidžiama skaityti visus SMS pranešimus, neatsižvelgiant į turinį ar konfidencialumą."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"redaguoti teksto pranešimus (SMS arba MMS)"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Leidžiama programai rašyti SMS pranešimus, išsaugotus jūsų planšetiniame kompiuteryje ar SIM kortelėje. Kenkėjiškos programos gali ištrinti jūsų pranešimus."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Leidžiama programai rašyti SMS pranešimus, išsaugotus jūsų telefone ar SIM kortelėje. Kenkėjiškos programos gali ištrinti jūsų pranešimus."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"gauti teksto pranešimus (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Leidžiama programai gauti ir apdoroti WAP pranešimus. Šis leidimas apima galimybę stebėti ar ištrinti jums siunčiamus pranešimus jums jų neparodžius."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"nuskaityti vykdomas programas"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Leidžiama programai nuskaityti informaciją apie šiuo ir pastaruoju metu vykdomas užduotis. Taip programa gali atrasti informacijos, kokios programos naudojamos įrenginyje."</string>
    <string name="permlab_interactAcrossUsers" msgid="7114255281944211682">"sąveikauti su naudotojais"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Leidžiama programai atlikti veiksmus skirtingų įrenginio naudotojų profiliuose. Kenkėjiškos programos gali pasinaudoti šiuo leidimu, kad pažeistų naudotojų saugumą."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"visa licencija, leidžianti sąveikauti su naudotojais"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Leidžiama bet kokia sąveika tarp naudotojų."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"tvarkyti naudotojus"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Leidžia programoms tvarkyti įrenginio naudotojų duomenis, įskaitant užklausų teikimą, duomenų kūrimą ir ištrynimą."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"nuskaityti veikiančių programų išsamią informaciją"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Leidžiama programai nuskaityti išsamią informaciją apie šiuo ir pastaruoju metu vykdomas užduotis. Kenkėjiškos programos gali surasti privačios informacijos apie kitas programas."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"pertvarkyti vykdomas programas"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Leidžiama programai perkelti užduotis į priekinį planą ir foną. Programa gali tai daryti be jūsų įsikišimo."</string>
    <string name="permlab_removeTasks" msgid="6821513401870377403">"sustabdyti vykdomas programas"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Leidžiama programai pašalinti užduotis ir panaikinti jų programas. Kenkėjiškos programos gali trikdyti kitų programų veikimą."</string>
    <string name="permlab_manageActivityStacks" msgid="7391191384027303065">"tvarkyti veiklos krūvas"</string>
    <string name="permdesc_manageActivityStacks" msgid="1615881933034084440">"Programai leidžiama pridėti, pašalinti ir modifikuoti veiklos krūvas, kuriose paleistos kitos programos. Kenkėjiškos programos gali trikdyti kitų programų elgseną."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"pradėti bet kokią veiklą"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Programai leidžiama pradėti bet kokią veiklą, nepaisant leidimo apsaugos ar eksportuotos būsenos."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"nustatyti ekrano suderinamumo režimą"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Programai leidžiama valdyti kitų programų ekrano suderinamumo režimą. Kenkėjiškos programos gali kliudyti veikti kitoms programoms."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"įgalinti programos derinimą"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Leidžiama programai įjungti kitos programos derinimą. Kenkėjiškos programos gali tai naudoti, kad išjungtų kitas programas."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"keisti sistemos rodymo nustatymus"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Leidžiama programai keisti dabartinę konfigūraciją, pvz., lokalę ar viso šrifto dydį."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"įgalinti automobilio režimą"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Leidžiama programai įgalinti automobilio režimą."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"uždaryti kitas programas"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Leidžiama programai baigti kitų programų fone vykdomus procesus. Dėl to gali būti sustabdytos kitos programos."</string>
    <string name="permlab_forceStopPackages" msgid="2329627428832067700">"priverstinai stabdyti kitas programas"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Leidžiama programai priverstinai stabdyti kitas programas."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"priverstinai uždaryti programą"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Leidžiama programai priverstinai uždaryti priekiniame plane esančią programą ir grįžti atgal. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"nuskaityti sistemos vidinę būseną"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Leidžiama programai nuskaityti vidinę sistemos būseną. Kenkėjiškos programos gali nuskaityti daug įvairios privačios ir saugios informacijos, kurios paprastai joms niekada neturėtų reikėti."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"nuskaityti ekrano turinį"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Leidžiama programai nuskaityti aktyvaus lango turinį. Kenkėjiškos programos gali bandyti išgauti viso lango turinį ir tirti visą jo tekstą, išskyrus slaptažodžius."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"laikinai įgalinti pritaikymą neįgaliesiems"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Leidžiama programai laikinai įgalinti pritaikymą neįgaliesiems įrenginyje. Kenkėjiškos programos pritaikymą neįgaliesiems gali įgalinti be naudotojo sutikimo."</string>
    <string name="permlab_retrieve_window_info" msgid="8532295199112519378">"gauti lango informaciją"</string>
    <string name="permdesc_retrieve_window_info" msgid="4998836370424186849">"Leidžiama programai iš langų tvarkytuvės gauti informaciją apie langus. Kenkėjiškos programos gali gauti informaciją, kuri skirta naudoti sistemos viduje."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"filtrų įvykiai"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Leidžiama programai registruoti įvesties filtrą, kuriuo filtruojamas visų naudotojo įvykių srautas prieš juos išsiunčiant. Kenkėjiška programa gali kontroliuoti sistemos naudotojo sąsają be naudotojo įsikišimo."</string>
    <string name="permlab_magnify_display" msgid="5973626738170618775">"didinti pateiktį"</string>
    <string name="permdesc_magnify_display" msgid="7121235684515003792">"Leidžiama programai didinti pateikties turinį. Kenkėjiškos programos gali pakeisti pateikties turinį taip, kad nebūtų galima naudoti įrenginio."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"dalinis išjungimas"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Veiklos tvarkyklę perjungia į išsijungimo būseną. Neišjungia visiškai."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"neleisti perjungti programų"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Neleidžiama naudotojui perjungti į kitą programą."</string>
    <string name="permlab_getTopActivityInfo" msgid="2537922311411546016">"gauti esamos programos informaciją"</string>
    <string name="permdesc_getTopActivityInfo" msgid="2512448855496067131">"Savininkui leidžiama gauti privačią esamos pirmaeilės ekrano programos informaciją."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"stebėti ir valdyti visų programų paleidimą"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Leidžiama programai stebėti ir valdyti, kaip sistema paleidžia veiklą. Kenkėjiškos programos gali visiškai pažeisti sistemą. Šis leidimas reikalingas tik kuriant ir jo niekada nereikia naudojant įprastai."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"siųsti pašalinto paketo perdavimą"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Leidžiama programai pateikti pranešimą, kad buvo pašalintas programos paketas. Kenkėjiškos programos gali tai naudoti, kad nutrauktų bet kurią kitą vykdomą programą."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"siųsti SMS gautą perdavimą"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Leidžiama programai pateikti pranešimą, kad buvo gautas SMS pranešimas. Kenkėjiškos programos gali tai naudoti, kad klastotų gaunamuosius SMS pranešimus."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"siųsti „WAP-PUSH-received“ perdavimą"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Leidžiama programai pateikti pranešimą, kai gaunamas WAP PUSH pranešimas. Kenkėjiškos programos gali tai naudoti, kad klastotų MMS pranešimo gavimą ar kad nepastebimai pakeistų bet kurio tinklalapio turinį kenkėjiškais variantais."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"riboti vykdomų procesų skaičių"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Leidžiama programai valdyti didžiausią vykdomų procesų skaičių. Nereikalinga įprastoms programoms."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"priverstinai uždaryti fonines programas"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Leidžiama programai valdyti, ar veiksmai visada užbaigiami, kai jie perkeliami į foną. Nereikalinga įprastoms programoms."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"skaityti akumuliatoriaus statistiką"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Leidžiama programai skaityti dabartinius išsikraunančio akumuliatoriaus naudojimo duomenis. Gali būti leidžiama programai sužinoti išsamią informaciją apie jūsų naudojamas programas."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"keisti akumuliatoriaus statistiką"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Leidžiama programai keisti surinktą akumuliatoriaus statistiką. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_getAppOpsStats" msgid="1508779687436585744">"nuskaityti programos naudojimo statistiką"</string>
    <string name="permdesc_getAppOpsStats" msgid="6243887041577912877">"Programai leidžiama nuskaityti surinktą programos naudojimo statistiką. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_updateAppOpsStats" msgid="8829097373851521505">"keisti programos naudojimo statistiką"</string>
    <string name="permdesc_updateAppOpsStats" msgid="50784596594403483">"Programai leidžiama keisti surinktą programos naudojimo statistiką. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_backup" msgid="470013022865453920">"valdyti sistemos atsarginę kopiją ir atkūrimą"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Leidžiama programai valdyti sistemos atsarginės kopijos ir atkūrimo mechanizmą. Neskirta naudoti įprastose programose."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"patvirtinkite visos atsarginės kopijos kūrimą arba atkurkite operaciją"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Leidžiama programai paleisti visą atsarginę patvirtinimo NS. Neskirta naudoti bet kokiai programai."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"pateikti neteisėtus langus"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Leidžiama programai kurti langus, kuriuos turėtų naudoti vidinės sistemos naudotojo sąsaja. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"perrašyti kitas programas"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Leidžiama programai pasinaudoti kitomis programomis ar naudotojo sąsajos dalimis. Jos gali trukdyti jums naudoti sąsają bet kokioje programoje arba pakeisti tai, ką, jūsų manymu, matote kitose programose."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"keisti visos animacijos greitį"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Leidžiama programai bet kuriuo metu keisti visą animacijos greitį (greitesnių ar lėtesnių animacijų)."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"valdyti programos prieigos raktus"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Leidžiama programai kurti ir valdyti prieigos raktus, apeinant įprastą Z tvarką. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"užfiksuoti ekraną"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"Leidžiama programai laikinai užfiksuoti ekraną, kad būtų galima perkelti visą ekraną."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"paspauskite klavišus ir valdymo mygtukus"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Leidžiama programai kitoms programoms pateikti savo įvesties įvykius (klavišų paspaudimus ir kt.). Kenkėjiškos programos gali tai naudoti, kad užvaldytų planšetinį kompiuterį."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Leidžiama programai kitoms programoms pateikti savo įvesties įvykius (klavišų paspaudimus ir kt.). Kenkėjiškos programos gali tai naudoti, kad užvaldytų telefoną."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"įrašas, kurį įvedate ir veiksmai, kuriuos atliekate"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Leidžiama programai stebėti paspaudžiamus klavišus, net kai sąveikaujama su kita programa (pvz., įvedant slaptažodį). Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"susaistyti įvesties būdą"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Leidžiama savininką susaistyti su įvesties metodo aukščiausio lygio sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"susisaistyti su pasiekiamumo paslauga"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Savininkui leidžiama susisaistyti su aukščiausio lygio pasiekiamumo paslaugos sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindPrintService" msgid="8462815179572748761">"susisaistyti su spausdinimo paslauga"</string>
    <string name="permdesc_bindPrintService" msgid="7960067623209111135">"Turėtojui leidžiama susisaistyti su spausdinimo paslaugos aukščiausio lygio sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindPrintSpoolerService" msgid="6807762783744125954">"susaistyti su spausdinimo kaupimo paslauga"</string>
    <string name="permdesc_bindPrintSpoolerService" msgid="3680552285933318372">"Turėtojui leidžiama susaistyti programą su spausdinimo kaupimo paslaugos aukščiausio lygio sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindNfcService" msgid="2752731300419410724">"susaistyti su ALR paslauga"</string>
    <string name="permdesc_bindNfcService" msgid="6120647629174066862">"Savininkui leidžiama susaistyti programas, kurios kopijuoja ALR korteles. Neturėtų prireikti įprastoms programoms."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"priskirti teksto paslaugą"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Leidžiama savininkui priskirti aukščiausio lygio teksto paslaugos (pvz., „SpellCheckerService“) sąsają. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"susaistyti su VPN paslauga"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Leidžiama savininkui susisaistyti su aukščiausio lygio VPN paslaugos sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"susaistyti su darbalaukio fonu"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Leidžiama savininką susaistyti su aukščiausio lygio darbalaukio fono sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"susaistyti su valdiklio paslauga"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Leidžiama savininkui susisaistyti su aukščiausio lygio valdiklio paslaugos sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"sąveikauti su įrenginio administratoriumi"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Leidžiama savininkui siųsti tikslus įrenginio administratoriui. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_manageDeviceAdmins" msgid="4248828900045808722">"pridėti arba pašalinti įrenginio administratorių"</string>
    <string name="permdesc_manageDeviceAdmins" msgid="5025608167709942485">"Savininkui leidžiama pridėti aktyvių įrenginio administratorių arba juos pašalinti. Neturėtų reikėti įprastoms programoms."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"keisti ekrano padėtį"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Leidžiama programai bet kada kaitalioti ekraną. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"keisti žymiklio greitį"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Leidžiama programai keisti pelės ar sensorinio pulto žymiklio greitį. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"keisti klaviatūros išdėstymą"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Leidžiama programai pakeisti klaviatūros išdėstymą. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"siųsti „Linux“ signalus programoms"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Leidžiama programai pateikti užklausą, kad teikiamas signalas būtų siunčiamas visiems nuolatiniams procesams."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"nustatyti, kad programa būtų visada vykdoma"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Leidžiama programai savo dalis įrašyti į atmintį. Dėl to gali būti apribota kitomis programomis pasiekiama atmintis ir sulėtėti planšetinio kompiuterio veikimas."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Leidžiama programai savo dalis įrašyti į atmintį. Dėl to gali būti apribota kitomis programomis pasiekiama atmintis ir sulėtėti telefono veikimas."</string>
    <string name="permlab_deletePackages" msgid="184385129537705938">"ištrinti programas"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Leidžiama programai ištrinti „Android“ paketus. Kenkėjiškos programos gali tai naudoti, kad ištrintų svarbias programas."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"ištrinti kitų programų duomenis"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Leidžiama programai išvalyti naudotojo duomenis."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"ištrinti kitų programų talpyklas"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Leidžiama programai ištrinti talpyklos failus."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"matuoti programos atmintinės vietą"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Leidžiama programai nuskaityti kodą, duomenis ir talpykloje saugoti dydžius"</string>
    <string name="permlab_installPackages" msgid="2199128482820306924">"tiesiogiai įdiegti programas"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Leidžiama programai įdiegti naujus ar atnaujintus „Android“ paketus. Kenkėjiškos programos gali tai naudoti, kad pridėtų naujų programų su nepagrįstai galingais leidimais."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"ištrinti visus programos talpyklos duomenis"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Leidžiama programai atlaisvinti planšetinio kompiuterio atmintinę ištrinant failus kitų programų talpykloje esančiuose kataloguose. Dėl ko kitos programos gali būti lėčiau paleidžiamos, nes joms reikia iš naujo gauti duomenis."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Leidžiama programai atlaisvinti telefono atmintinę ištrinant failus kitų programų talpykloje esančiuose kataloguose. Dėl to kitos programos gali būti lėčiau paleidžiamos, nes joms reikia iš naujo gauti duomenis."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"perkelti programos išteklius"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Leidžiama programai perkelti programos išteklius iš vidinės medijos į išorinę ir atvirkščiai."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"skaityti slaptus žurnalo duomenis"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Leidžiama programai skaityti iš įvairių sistemos žurnalų failų. Taip galima atrasti bendrą informaciją apie tai, ką darote naudodami planšetinį kompiuterį, potencialiai įtraukiant asmeninę ar privačią informaciją."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Leidžiama programai skaityti iš įvairių sistemos žurnalų failų. Taip galima atrasti bendrą informaciją apie tai, ką darote telefonu, potencialiai įtraukiant asmeninę ar privačią informaciją."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"atkuriant naudoti bet kurį medijos dekoderį"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Leidžiama programai naudoti bet kurį įdiegtą medijos dekoderį norint iššifruoti atkūrimą."</string>
    <string name="permlab_manageCaCertificates" msgid="1678391896786882014">"tvarkyti patikimus prisijungimo duomenis"</string>
    <string name="permdesc_manageCaCertificates" msgid="4015644047196937014">"Programoje galima įdiegti ir iš jos pašalinti CA sertifikatus kaip patikimus prisijungimo duomenis."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"skaityti / rašyti ištekliuose, priklausančiuose diagnostikai"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Leidžiama programai skaityti ir rašyti visuose diagnostikos grupei priklausančiuose ištekliuose, pvz., failuose, esančiuose /dev. Tai gali paveikti sistemos stabilumą ir saugą. Tai turėtų būti naudojama TIK gamintojui ar operatoriui atliekant aparatinės įrangos diagnostiką."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"įgalinti programos komponentus arba jų neleisti"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Leidžiama programai pakeisti, ar įgalintas kitos programos komponentas, ar ne. Kenkėjiškos programos gali tai naudoti, kad neleistų svarbių planšetinio kompiuterio funkcijų. Šį leidimą reikia naudoti atsargiai, nes programos komponentai gali tapti nenaudojami, nenuoseklūs ar nestabilūs."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Leidžiama programai pakeisti nustatymą, ar įgalintas kitos programos komponentas, ar ne. Kenkėjiškos programos gali tai naudoti, kad neleistų svarbių telefono funkcijų. Šį leidimą reikia naudoti atsargiai, nes programos komponentai gali tapti nenaudojami, nenuoseklūs ar nestabilūs."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"suteikti arba panaikinti leidimus"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Programai leidžiama suteikti arba panaikinti konkrečius savo arba kitų programų leidimus. Tuo pasinaudoję kenkėjiškos programos gali pasiekti funkcijas, kurių pasiekti joms neleidote."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"nustatyti pageidaujamas programas"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Leidžiama programai keisti jūsų pageidaujamas programas. Kenkėjiškos programos gali nepastebimai pakeisti vykdomas programas, klastodama esamas programas, kad rinktų jūsų privačius duomenis."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"keisti sistemos nustatymus"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Leidžiama programai keisti sistemos nustatymų duomenis. Kenkėjiškos programos gali sugadinti jūsų sistemos konfigūraciją."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"keisti saugios sistemos nustatymus"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Leidžiama programai keisti sistemos saugių nustatymų duomenis. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"keisti „Google“ paslaugų žemėlapį"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Leidžiama programai keisti „Google“ paslaugų žemėlapį. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"paleisti paleidžiant"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Leidžiama programai pasileisti, kai baigsis sistemos įkėlimas iš naujo. Dėl to planšetinio kompiuterio paleidimas gali trukti ilgiau ir programa gali sulėtinti planšetinį kompiuterį, nes ji veiks visada."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Leidžiama programai pasileisti, kai baigsis sistemos įkėlimas iš naujo. Dėl to telefono paleidimas gali trukti ilgiau ir programa gali sulėtinti telefoną, nes ji veiks visada."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"siųsti pritraukiantį perdavimą"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Leidžiama programai siųsti užsifiksuojančias transliacijas, kurios išlieka pasibaigus transliacijai. Per dažnas jų naudojimas gali sulėtinti planšetinio kompiuterio veikimą ar padaryti jį nestabilų verčiant naudoti per daug atminties."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Leidžiama programai siųsti užsifiksuojančias transliacijas, kurios išlieka pasibaigus transliacijai. Per dažnas jų naudojimas gali sulėtinti telefono veikimą ar padaryti jį nestabilų verčiant naudoti per daug atminties."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"skaityti kontaktus"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Leidžiama programai skaityti duomenis apie planšetiniame kompiuteryje saugomus kontaktus, įskaitant dažnį, kuriuo konkretiems asmenims skambinote, siuntėte el. laiškus ar bendravote kitais būdais. Šis leidimas suteikia teisę programoms saugoti kontaktinius duomenis, o kenkėjiškos programos gali bendrinti kontaktinius duomenis be jūsų žinios."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Leidžiama programai skaityti duomenis apie telefone saugomus kontaktus, įskaitant dažnį, kuriuo konkretiems asmenims skambinote, siuntėte el. laiškus ar bendravote kitais būdais. Šis leidimas suteikia teisę programoms saugoti kontaktinius duomenis, o kenkėjiškos programos gali bendrinti kontaktinius duomenis be jūsų žinios."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"keisti kontaktus"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Leidžiama programai keisti duomenis apie planšetiniame kompiuteryje saugomus kontaktus, įskaitant dažnį, kuriuo konkretiems asmenims skambinote, siuntėte el. laiškus ar bendravote kitais būdais. Šis leidimas suteikia teisę programoms ištrinti kontaktinius duomenis."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Leidžiama programai keisti duomenis apie telefone saugomus kontaktus, įskaitant dažnį, kuriuo konkretiems asmenims skambinote, siuntėte el. laiškus ar bendravote kitais būdais. Šis leidimas suteikia teisę programoms ištrinti kontaktinius duomenis."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"skaityti skambučių žurnalą"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Leidžiama programai skaityti planšetinio kompiuterio skambučių žurnalą, įskaitant duomenis apie gaunamuosius ir išsiunčiamuosius skambučius. Šis leidimas suteikia teisę programai išsaugoti skambučių žurnalo duomenis, o kenkėjiškos programos gali bendrinti skambučių žurnalą be jūsų žinios."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Leidžiama programai skaityti telefono skambučių žurnalą, įskaitant duomenis apie gaunamuosius ir išsiunčiamuosius skambučius. Šis leidimas suteikia teisę programai išsaugoti skambučių žurnalo duomenis, o kenkėjiškos programos gali bendrinti skambučių žurnalą be jūsų žinios."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"rašyti skambučių žurnalą"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Programai leidžiama skaityti planšetinio kompiuterio skambučių žurnalą, įskaitant duomenis apie gaunamus ir siunčiamus skambučius. Kenkėjiškos programos tai gali naudoti, kad ištrintų ar keistų jūsų skambučių žurnalą."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Programai leidžiama skaityti telefono skambučių žurnalą, įskaitant duomenis apie gaunamus ir siunčiamus skambučius. Kenkėjiškos programos tai gali naudoti, kad ištrintų ar keistų jūsų skambučių žurnalą."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"skaityti jūsų kontakt. kortelę"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Programai leidžiama skaityti įrenginyje saugomą asmeninę profilio informaciją, pvz., vardą, pavardę ir kontaktinę informaciją. Tai reiškia, kad programa gali nustatyti tapatybę ir siųsti profilio informaciją kitiems."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"keisti jūsų kontaktinę kortelę"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Leidžiama programai keisti įrenginyje saugomą asmeninę profilio informaciją, pvz., vardą, pavardę ir kontaktinę informaciją, arba jos pridėti. Tai reiškia, kad programa gali nustatyti tapatybę ir siųsti profilio informaciją kitiems."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"skaityti socialinį srautą"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Leidžiama programai pasiekti ir sinchronizuoti viešas naujienas iš jūsų ir jūsų draugų. Būkite atidūs bendrindami informaciją – programai leidžiama skaityti korespondenciją tarp jūsų ir draugų viešuosiuose tinkluose, neatsižvelgiant į konfidencialumą. Pastaba: šis leidimas negali būti taikomas visuose viešuosiuose tinkluose."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"rašyti į socialinį srautą"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Leidžiama programai rodyti viešas naujienas iš jūsų draugų. Būkite atidūs bendrindami informaciją – programai leidžiama kurti pranešimus, kurie atrodo lyg būtų siunčiami draugo. Pastaba: šis leidimas negali būti taikomas visuose viešuosiuose tinkluose."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"nuskaito kalendoriaus įvykius ir konfidencialią informaciją"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Leidžiama programai skaityti visus planšetiniame kompiuteryje išsaugotus kalendoriaus įvykius, įskaitant draugų ar bendradarbių įvykius. Dėl to programai gali būti leidžiama bendrinti ar saugoti kalendoriaus duomenis, neatsižvelgiant į konfidencialumą ar privatumą."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Leidžiama programai skaityti visus telefone išsaugotus kalendoriaus įvykius, įskaitant draugų ar bendradarbių įvykius. Dėl to programai gali būti leidžiama bendrinti ar saugoti kalendoriaus duomenis, neatsižvelgiant į konfidencialumą ar privatumą."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"prideda arba keičia kalendoriaus įvykius ir siunčia el. laiškus svečiams be savininko žinios"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Leidžiama programai pridėti, pašalinti ir keisti įvykius, kuriuos galite keisti planšetiniame kompiuteryje, įskaitant draugų ir bendradarbių įvykius. Dėl to programa gali siųsti pranešimus, kurie atrodo lyg būtų siunčiami kalendorių savininkų, arba keisti įvykius be savininko žinios."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Leidžiama programai pridėti, pašalinti ir keisti įvykius, kuriuos galite keisti telefone, įskaitant draugų ir bendradarbių įvykius. Dėl to programa gali siųsti pranešimus, kurie atrodo lyg būtų siunčiami kalendorių savininkų, arba keisti įvykius be savininko žinios."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"imituoti vietos šaltinius bandymui"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Kurti bandomuosius imituojančius vietos nustatymo šaltinius arba įdiegti naują vietos nustatymo paslaugų teikėją. Programai leidžiama nepaisyti vietos ir (arba) būsenos, kurią pateikia kiti vietos nustatymo šaltiniai, pvz., GPS arba vietos nustatymo paslaugų teikėjai."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"pasiekti papildomas vietos teikimo įrankio komandas"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"Leidžiama programai pasiekti papildomas vietos nustatymo paslaugų teikėjų komandas. Dėl to programa gali trukdyti veikti GPS ar kitiems vietos nustatymo šaltiniams."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"leidimas įdiegti vietos teikimo įrankį"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Kurti bandomuosius imituojančius vietos nustatymo šaltinius arba įdiegti naują vietos nustatymo paslaugų teikėją. Programai leidžiama nepaisyti vietos ir (arba) būsenos, kurią pateikia kiti vietos nustatymo šaltiniai, pvz., GPS arba vietos nustatymo paslaugų teikėjai."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"tiksli vieta (pagrįsta pagal GPS ir tinklą)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Leidžiama programai gauti jūsų tikslią vietą naudojant visuotinę vietos nustatymo sistemą (angl. „Global Positioning System“, GPS) arba tinklo vietos šaltinius, pvz., mobiliojo ryšio bokštus ir „Wi-Fi“. Šios vietos paslaugos turi būti įjungtos ir pasiekiamos įrenginyje, kad programa galėtų jas naudoti. Programos gali tai naudoti jūsų vietai nustatyti bei eikvoti papildomą akumuliatoriaus energiją."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"apytikslė vieta (pagrįsta pagal tinklą)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Leidžiama programai gauti jūsų apytikslę vietą. Ši vieta gaunama vietos paslaugų naudojant tinklo vietos šaltinius, pvz., mobiliojo ryšio bokštus ir „Wi-Fi“. Šios vietos paslaugos turi būti įjungtos ir pasiekiamos įrenginyje, kad programa galėtų jas naudoti. Programos gali tai naudoti jūsų apytikslei vietai nustatyti."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"pasiekti „SurfaceFlinger“"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Leidžiama programai naudoti „SurfaceFlinger“ žemo lygio funkcijas."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"skaityti kadrų buferį"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Leidžiama programai skaityti rėmelio buferio turinį."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"konfigūruoti „Wi-Fi“ pateiktis"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"Leidžiama programai konfigūruoti ir prisijungti prie „Wi-Fi“ pateikčių."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"valdyti „Wi-Fi“ pateiktis"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"Leidžiama programai valdyti „Wi-Fi“ pateikčių žemo lygio funkcijas."</string>
    <string name="permlab_captureAudioOutput" msgid="6857134498402346708">"fiksuoti garso išvestį"</string>
    <string name="permdesc_captureAudioOutput" msgid="6210597754212208853">"Programai leidžiama fiksuoti ir peradresuoti garso išvestį."</string>
    <string name="permlab_captureAudioHotword" msgid="1890553935650349808">"Aktyvinamųjų žodžių aptikimas"</string>
    <string name="permdesc_captureAudioHotword" msgid="9151807958153056810">"Programai leidžiama įrašyti garsą, kad būtų galima aptikti aktyvinamuosius žodžius. Įrašymas gali būti vykdomas fone, bet tai netrikdo kitų garso įrašymo veiksmų (pvz., įrašymo vaizdo kamera)."</string>
    <string name="permlab_captureVideoOutput" msgid="2246828773589094023">"fiksuoti vaizdo išvestį"</string>
    <string name="permdesc_captureVideoOutput" msgid="359481658034149860">"Programai leidžiama fiksuoti ir peradresuoti vaizdo išvestį."</string>
    <string name="permlab_captureSecureVideoOutput" msgid="7815398969303382016">"fiksuoti saugią vaizdo išvestį"</string>
    <string name="permdesc_captureSecureVideoOutput" msgid="2779793064709350289">"Programai leidžiama fiksuoti ir peradresuoti saugią vaizdo išvestį."</string>
    <string name="permlab_mediaContentControl" msgid="8749790560720562511">"medijos atkūrimo ir prieigos prie metaduomenų valdymas"</string>
    <string name="permdesc_mediaContentControl" msgid="1637478200272062">"Programai leidžiama valdyti medijos atkūrimą ir pasiekti medijos informaciją (pavadinimą, autorių ir t. t.)."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"keisti garso nustatymus"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Leidžiama programai keisti visuotinius garso nustatymus, pvz., garsumą ir tai, kuris garsiakalbis naudojamas išvesčiai."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"įrašyti garsą"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Leidžiama programai įrašyti garsą naudojant mikrofoną. Šis leidimas suteikia galimybę programai įrašyti garsą bet kada be jūsų patvirtinimo."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"fotografuoti ir filmuoti"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Leidžiama programai fotografuoti ir filmuoti kamera. Šis leidimas suteikia teisę programai naudoti kamerą bet kada be jūsų patvirtinimo."</string>
    <string name="permlab_cameraDisableTransmitLed" msgid="2651072630501126222">"neleisti perduoti LED indikatoriaus, kai naudojamas fotoaparatas"</string>
    <string name="permdesc_cameraDisableTransmitLed" msgid="4764585465480295341">"Leidžiama iš anksto įdiegtai sistemos programai išjungti fotoaparato naudojimo indikatoriaus LED."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"visam laikui neleisti planšetinio kompiuterio"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"visam laikui išjungti telefoną"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Leidžiama programai visam laikui išjungti visą planšetinį kompiuterį. Tai labai pavojinga."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Leidžiama programai išjungti visą telefoną visam laikui. Tai labai pavojinga."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"versti iš naujo įkelti planšetinio kompiuterio operacinę sistemą"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"pradėti telefono perkrovimą"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Leidžiama programai versti iš naujo paleisti planšetinio kompiuterio operacinę sistemą."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Leidžiama programai versti iš naujo paleisti telefono operacinę sistemą."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"pasiekti USB atm. failų sist."</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"pasiekti SD kortelės failų sistemą"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Leidžiama programai įrengti ir pašalinti keičiamos atmintinės failų sistemas."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"ištrinti USB atmintį"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"ištrinti SD kortelę"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Leidžiama programai formatuoti keičiamą saugyklą."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"gauti informacijos apie vidinę atmintinę"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Leidžiama programai gauti informacijos apie vidinę atmintį."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"kurti vidinę atmintinę"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Leidžiama programai sukurti vidinę atmintį."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"sunaikinti vidinę atmintinę"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Leidžiama programai sunaikinti vidinę atmintį."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"įrengti / pašalinti vidinę saugyklą"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Leidžiama programai įrengti / pašalinti vidinę atmintį."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"iš naujo pavadinti vidinę atmintinę"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Leidžiama programai pervardyti vidinę atmintį."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"valdyti vibraciją"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Leidžiama programai valdyti vibravimą."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"valdyti šviesos signalą"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Leidžiama programai valdyti šviesos signalą."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"valdyti USB įrenginių nuostatas ir leidimus"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Leidžiama programai valdyti USB įrenginių nuostatas ir leidimus."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"taikyti MTP protokolą"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Leidžiama prieiga prie pagrindinės MTP tvarkyklės taikyti MTP USB protokolą."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"bandyti aparatinę įrangą"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Leidžiama programai valdyti įvairius periferinius įrenginius aparatinės įrangos bandymo tikslais."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"skambinti tiesiogiai telefono numeriais"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Leidžiama programai skambinti telefonų numeriais be jūsų įsikišimo. Dėl to gali atsirasti nenumatytų apmokestinimų ar skambučių. Atminkite, kad programai neleidžiama skambinti pagalbos telefonų numeriais. Kenkėjiškos programos gali skambinti be jūsų patvirtinimo, o dėl to jums gali būti taikomi mokesčiai."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"skambinti tiesiogiai telefonų numeriais"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Leidžiama programai skambinti bet kuriuo telefono numeriu, įskaitant skubios pagalbos numerius, be jūsų įsikišimo. Kenkėjiškos programos gali atlikti nereikalingus ir neteisėtus skambučius skubios pagalbos numeriais."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"tiesiogiai pradėti CDMA planšetinio kompiuterio sąranką"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"tiesiogiai pradėti CDMA telefono sąranką"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Leidžiama programai pradėti CDMA parengimą. Kenkėjiškos programos gali be reikalo pradėti CDMA parengimą."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"valdyti vietos atnaujinimo įspėjimus"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Leidžiama programai įgalinti vietos atnaujinimo pranešimus, gautus iš radijo, ar jų neleisti. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"pasiekti registravimo ypatybes"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Programai suteikiama skaitymo / rašymo prieiga prie ypatybių, kurias įkėlė tikrinimo paslauga. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"pasirinkti valdiklius"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Leidžiama programai pranešti, kurios programos kuriuos valdiklius gali naudoti. Šį leidimą turinti programa gali kitoms programoms suteikti prieigą prie asmeninių duomenų. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"keisti telefono būseną"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Leidžiama programai valdyti įrenginio telefono funkcijas. Šį leidimą turinti programa gali perjungti tinklus, įjungti ir išjungti telefono radiją ir atlikti panašius veiksmus jūsų neįspėdama."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"skaityti telefono būseną ir tapatybę"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Leidžiama programai pasiekti telefono funkcijas įrenginyje. Šis leidimas suteikia teisę programai nustatyti telefono numerį ir įrenginio ID, tai, ar skambutis aktyvus, ir skambučiu prijungtą nuotolinį numerį."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"neleisti planšetiniam kompiuteriui užmigti"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"neleisti telefonui snausti"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Leidžiama programai neleisti planšetiniam kompiuteriui užmigti."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Leidžiama programai neleisti telefonui užmigti."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"perduoti duomenis infraraudonaisiais spinduliais"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Programai leidžiama naudoti planšetinio kompiuterio infraraudonųjų spindulių perdavimo įrenginį."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Programai leidžiama naudoti telefono infraraudonųjų spindulių perdavimo įrenginį."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"įjungti arba išjungti planšetinį kompiuterį"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"telefono įjungimas ir išjungimas"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Leidžiama programai įjungti ar išjungti planšetinį kompiuterį."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Leidžiama programai įjungti ar išjungti telefoną."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"paleisti gamyklos bandymo režime"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Paleisti kaip žemo lygio gamintojo bandymą, leidžiant užbaigti prieigą prie aparatinės planšetinio kompiuterio įrangos. Pasiekiama tik tada, kai planšetinis kompiuteris veikia gamintojo bandymo režimu."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Paleisti kaip žemo lygio gamintojo bandymą, leidžiant užbaigti prieigą prie aparatinės telefono įrangos. Galima tik kai telefonas veikia gamintojo bandymo režimu."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"nustatyti darbalaukio foną"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Leidžiama programai nustatyti sistemos darbalaukio foną."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"keisti ekrano fono dydį"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Leidžiama programai nustatyti sistemos darbalaukio fono dydžio užuominas."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"iš naujo nustatyti sistemą į gamyklos nustatymus"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Leidžiama programai visiškai iš naujo nustatyti sistemos nustatymus į gamyklinius ištrinant visus duomenis, konfigūraciją ir įdiegtas programas."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"nustatyti laiką"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Leidžiama programai keisti planšetinio kompiuterio laiką."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Leidžiama programai keisti telefono laiką."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"nustatyti laiko zoną"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Leidžiama programai keisti planšetinio kompiuterio laiko juostą."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Leidžiama programai keisti telefono laiko juostą."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"veikia kaip „AccountManagerService“"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Leidžiama programai kreiptis „AccountAuthenticators“."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"rasti paskyras įrenginyje"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Leidžiama programai gauti planšetinio kompiuterio žinomų paskyrų sąrašą. Gali būti įtrauktos visos paskyros, sukurtos įdiegtomis programomis."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Leidžiama programai gauti telefono žinomų paskyrų sąrašą. Gali būti įtrauktos visos paskyros, sukurtos įdiegtomis programomis."</string>
    <string name="permlab_authenticateAccounts" msgid="5265908481172736933">"kurti paskyras ir nustatyti slaptažodžius"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Leidžiama programai naudoti paskyros „AccountManager“ tapatumo nustatymo funkcijas, įskaitant paskyrų kūrimą, jų slaptažodžių gavimą ir nustatymą."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"pridėti arba pašalinti paskyras"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Leidžiama programai atlikti tokias operacijas kaip paskyrų pridėjimas ir pašalinimas bei slaptažodžių trynimas."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"naudoti įrenginyje esančias paskyras"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Leidžiama programai pateikti užklausą dėl tapatumo nustatymo prieigos raktų."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"žiūrėti tinklo ryšius"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Leidžiama programai peržiūrėti informaciją apie tinklo ryšius, pvz., kurie tinklai pasiekiami ir prijungti."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"visateisė tinklo prieiga"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Leidžiama programai kurti tinklo programines jungtis ir naudoti tinkintus tinklo protokolus. Naršyklė ir kitos programos teikia priemones siųsti duomenis į internetą, todėl norint siųsti duomenis į internetą šis leidimas nebūtinas."</string>
    <string name="permlab_writeApnSettings" msgid="505660159675751896">"keisti / perimti tinklo nustatymus ir srautą"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Leidžiama programai pakeisti tinklo nustatymus ir perimti bei tirti visą tinklo srautą, kad, pvz., pakeistų tarpinį serverį ir bet kurio APN prievadą. Kenkėjiškos programos gali stebėti, peradresuoti ar keisti tinklo paketus jums nežinant."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"keisti tinklo jungiamumą"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Leidžiama programai keisti tinklo jungiamumo būseną."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"keisti susietą jungiamumą"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Leidžiama programai keisti susieto tinklo jungiamumą."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"keisti fono duomenų naudojimo nustatymą"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Leidžiama programai keisti fono duomenų naudojimo nustatymą."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"žiūrėti „Wi-Fi“ ryšius"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Leidžiama programai peržiūrėti informaciją apie „Wi-Fi“ ryšio tinklus, pvz., ar įgalintas „Wi-Fi“, ir prijungtų „Wi-Fi“ įrenginių pavadinimus."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"prijungti prie „Wi-Fi“ ir atjungti nuo jo"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Leidžiama programai prisijungti prie „Wi-Fi“ ryšio prieigos taškų ir nuo jų atsijungti bei keisti įrenginio „Wi-Fi“ ryšio tinklų konfigūraciją."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"leisti „Wi-Fi“ daugiaadresio perdavimo priėmimą"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Leidžiama programai gauti paketus, siunčiamus į visus prie „Wi-Fi“ ryšio tinklo prijungtus įrenginius (ne tik į planšetinį kompiuterį), naudojančius daugiaadresio perdavimo adresus. Ji naudoja daugiau energijos nei ne daugiaadresio perdavimo režimas."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Leidžiama programai gauti paketus, siunčiamus į visus prie „Wi-Fi“ ryšio tinklo prijungtus įrenginius (ne tik į telefoną), naudojančius daugiaadresio perdavimo adresus. Ji naudoja daugiau energijos nei ne daugiaadresio perdavimo režimas."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"pasiekti „Bluetooth“ nustatymus"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Leidžiama programai konfigūruoti vietinį „Bluetooth“ planšetinį kompiuterį ir atrasti nuotolinius įrenginius bei su jais susieti."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Leidžiama programai konfigūruoti vietinį „Bluetooth“ telefoną ir atrasti bei susieti su nuotoliniais įrenginiais."</string>
    <string name="permlab_bluetoothPriv" msgid="4009494246009513828">"leisti „Bluetooth“ susiejimą naudojant programą"</string>
    <string name="permdesc_bluetoothPriv" product="tablet" msgid="8045735193417468857">"Leidžiama programai susieti su nuotolinio valdymo įrenginiais be naudotojo įsikišimo."</string>
    <string name="permdesc_bluetoothPriv" product="default" msgid="8045735193417468857">"Leidžiama programai susieti su nuotolinio valdymo įrenginiais be naudotojo įsikišimo."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"prisijungti prie WiMAX ir atsijungti nuo jo"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Leidžiama programai nustatyti, ar įgalintas „WiMAX“, ir informaciją apie visus prijungtus tinklus."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"Keisti „WiMAX“ būseną"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Leidžia programai prijungti planšetinį kompiuterį prie „WiMAX“ ryšio tinklų ir nuo jų atjungti."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Leidžia programai prijungti telefoną prie „WiMAX“ ryšio tinklų ir nuo jų atjungti."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"susieti su „Bluetooth“ įrenginiais"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Leidžiama programai peržiūrėti „Bluetooth“ konfigūraciją planšetiniame kompiuteryje ir užmegzti bei priimti ryšius iš susietų įrenginių."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Leidžiama programai peržiūrėti „Bluetooth“ konfigūraciją telefone ir užmegzti bei priimti ryšius iš susietų įrenginių."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"valdyti artimo lauko perdavimą (angl. „Near Field Communication“)"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Leidžiama programai perduoti artimojo lauko ryšių technologijos (ALR) žymas, korteles ir skaitymo programas."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"išjungti ekrano užraktą"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Leidžiama programai neleisti klavišo užrakto ir visos susijusios slaptažodžio apsaugos. Pvz., telefonas neleidžia klavišo užrakto priimant gaunamąjį skambutį ir pakartotinai jį įgalina, kai skambutis baigiamas."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"skaityti sinchronizavimo nustatymus"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Leidžiama programai skaityti ir sinchronizuoti paskyros nustatymus. Pvz., taip gali būti nustatoma, ar su paskyra sinchronizuota Žmonių programa."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"įjungti arba išjungti sinchronizavimą"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Leidžiama programai keisti sinchronizuotus paskyros nustatymus. Pvz., tai gali būti naudojama norint įgalinti Žmonių programos sinchronizavimą su paskyra."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"skaityti sinchronizavimo statistiką"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Leidžiama programai skaityti sinchronizuotą paskyros statistiką, įskaitant sinchronizuotų įvykių istoriją ir informaciją, kiek duomenų sinchronizuota."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"skaityti prenumeruojamus tiekimus"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Leidžiama programai gauti išsamios informacijos apie šiuo metu sinchronizuojamus sklaidos kanalus."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"rašyti prenumeruojamus kanalus"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Leidžiama programai keisti šiuo metu sinchronizuojamus sklaidos kanalus. Kenkėjiškos programos gali pakeisti sinchronizuojamus sklaidos kanalus."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"skaityti terminus, kuriuos pridėjote į žodyną"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Leidžiama programai skaityti visus žodžius, vardus ir frazes, kuriuos naudotojas išsaugojo naudotojo žodyne."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"pridėti žodžių prie naudotojo apibrėžto žodyno"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Leidžiama programai rašyti naujus žodžius į naudotojo žodyną."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"skaityti USB atminties turinį"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"skaityti SD kortelės turinį"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"Leidžiama skait. USB atmintį."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"Programai leidžiama skaityti SD kortelės turinį."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"keisti / trinti USB atm. turinį"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"keisti arba trinti SD kortelės turinį"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Leidž. progr. raš. į USB atm."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Leidžiama programai rašyti į SD kortelę."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"keisti / ištr. vid. med. atm. tur."</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Leidžiama programai keisti vidinės medijos saugyklos turinį."</string>
    <string name="permlab_manageDocs" product="default" msgid="5778318598448849829">"tvarkyti dokumentų saugyklą"</string>
    <string name="permdesc_manageDocs" product="default" msgid="8704323176914121484">"Leidžiama programai tvarkyti dokumentų saugyklą."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"pasiekti visų naud. išor. atm."</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Leidžiama programai pasiekti visų naudotojų išorinę atmintinę."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"pasiekti talpyklos failų sistemą"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Leidžiama programai skaityti talpyklos failų sistemą ir į ją rašyti."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"skambinti / priimti skambučius internetu"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Leidžiama programai naudoti SIP paslaugą norint skambinti / priimti skambučius internetu."</string>
    <string name="permlab_bind_call_service" msgid="6724009726671246551">"sąveika su gaunamojo skambučio ekranu"</string>
    <string name="permdesc_bind_call_service" msgid="8732547662442572435">"Programai leidžiama valdyti, kada ir kaip naudotojai matys gaunamojo skambučio ekraną."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"skaityti tinklo naudojimo istoriją"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Leidžiama programai skaityti konkrečių tinklų ir programų tinklo naudojimo istoriją."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"valdyti tinklo politiką"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Leidžiama programai valdyti tinklo politiką ir apibrėžti konkrečios programos taisykles."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"keisti tinklo naudojimo apskaitą"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Leidžiama programai keisti, kaip tinklas naudojamas, palyginti su programomis. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_markNetworkSocket" msgid="3658527214914959749">"modifikuoti lizdų ženklus"</string>
    <string name="permdesc_markNetworkSocket" msgid="7655568433696356578">"Programai leidžiama modifikuoti maršrutui parinkti skirtus lizdų ženklus"</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"pasiekti pranešimus"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Programai leidžiama gauti, patikrinti ir išvalyti pranešimus, įskaitant pranešimus, kuriuos paskelbė kitos programos."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"susisaistyti su pranešimų skaitymo priemonės paslauga"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Leidžiama turėtojui susisaistyti su pranešimų skaitymo priemonės paslaugos aukščiausio lygio sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"iškviesti operatoriaus pateiktą konfigūravimo programą"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Turėtojui leidžiama iškviesti operatoriaus pateiktą konfigūravimo programą. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"vykdyti tinklo sąlygų stebėjimą"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Leidžiama programai vykdyti tinklo sąlygų stebėjimą. To niekada neturėtų prireikti naudojant įprastas programas."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Nustatyti slaptažodžio taisykles"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Valdyti leidžiamą ekrano atrakinimo slaptažodžių ilgį ir leidžiamus naudoti simbolius."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Stebėti bandymus atrakinti ekraną"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Stebimas neteisingai įvestų slaptažodžių skaičius atrakinant ekraną ir užrakinti planšetinį kompiuterį arba ištrinti visus jame esančius duomenis, jei įvedama per daug neteisingų slaptažodžių."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Atrakindami ekraną stebėkite neteisingai įvestų slaptažodžių skaičių ir užrakinkite telefoną ar ištrinkite visus telefono duomenis, jei įvedama per daug neteisingų slaptažodžių."</string>
    <string name="policylab_resetPassword" msgid="2620077191242688955">"Pakeisti ekrano užrakinimo slaptažodį"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Pakeisti ekrano atrakinimo slaptažodį."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Užrakinti ekraną"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Valdyti, kaip ir kada užrakinamas ekranas."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Trinti visus duomenis"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Be įspėjimo ištrinti planšetinio kompiuterio duomenis atkuriant gamyklinius duomenis."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Be įspėjimo ištrinti telefono duomenis atkuriant gamyklinius duomenis."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Nustatyti įrenginio bendrąjį tarpinį serverį"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Nustatyti įrenginio bendrąjį tarpinį serverį, kad būtų naudojamas, kol įgalinta politika. Tik pirmasis įrenginio administratorius nustato efektyvų bendrąjį tarpinį serverį."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Nust. ekr. užr. slapt. gal. pab."</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Valdykite, kaip dažnai reikia keisti ekrano užrakinimo slaptažodį."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Nustatyti atmintinės šifruotę"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Reikalauti, kad saugomos programos duomenys būtų šifruoti."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Neleisti fotoaparatų"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Neleisti naudoti visų įrenginio fotoaparatų."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="266329104542638802">"Funkcijų išjung. klaviat. aps."</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Naudojant klaviatūros apsaugos funkciją, neleisti naudoti kai kurių funkcijų."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Pagrindinis"</item>
    <item msgid="869923650527136615">"Mobilusis"</item>
    <item msgid="7897544654242874543">"Darbo"</item>
    <item msgid="1103601433382158155">"Darbo faksas"</item>
    <item msgid="1735177144948329370">"Namų faksas"</item>
    <item msgid="603878674477207394">"Pranešimų gaviklis"</item>
    <item msgid="1650824275177931637">"Kita"</item>
    <item msgid="9192514806975898961">"Priskirtas"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Pagrindinis"</item>
    <item msgid="7084237356602625604">"Darbo"</item>
    <item msgid="1112044410659011023">"Kita"</item>
    <item msgid="2374913952870110618">"Priskirtas"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Pagrindinis"</item>
    <item msgid="5629153956045109251">"Darbo"</item>
    <item msgid="4966604264500343469">"Kita"</item>
    <item msgid="4932682847595299369">"Priskirtas"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Pagrindinis"</item>
    <item msgid="1359644565647383708">"Darbo"</item>
    <item msgid="7868549401053615677">"Kita"</item>
    <item msgid="3145118944639869809">"Priskirtas"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Darbo"</item>
    <item msgid="4378074129049520373">"Kita"</item>
    <item msgid="3455047468583965104">"Priskirtas"</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“ pokalbiai"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"„Jabber“"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Priskirtas"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Pagrindinis"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobilusis"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Darbo"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Darbo faksas"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Namų faksas"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pranešimų gaviklis"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Kita"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Atgalinis skambinimas"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Automobilis"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Vidinė telefono linija"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Pagrindinis"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Kitas faksas"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radijas"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"„Telex“"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Mobilusis darbo telefonas"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Darbo pranešimų gaviklis"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Asistentas"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Priskirtas"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Gimimo diena"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Sukaktis"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Kita"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Priskirtas"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Pagrindinis"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Darbo"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Kita"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobilusis"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Priskirtas"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Pagrindinis"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Darbo"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Kita"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Priskirtas"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Pagrindinis"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Darbo"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Kita"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Priskirtas"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangout"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"„Jabber“"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Darbo"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Kita"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Priskirtas"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Priskirtas"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Asistentas (-ė)"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brolis"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Vaikas"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Civilinis partneris"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Tėvas"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Draugas (-ė)"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Vadovas (-ė)"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Motina"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Vienas iš tėvų"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partneris (-ė)"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Rekomendavo"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Giminaitis (-ė)"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Sesuo"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Sutuoktinis (-ė)"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Priskirtas"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Pagrindinis"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Darbas"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Kita"</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Įveskite PIN kodą"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Įveskite PUK ir naują PIN kodus"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK kodas"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Naujas PIN kodas"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Palieskite, kad įves. slaptaž."</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Jei norite atrakinti, įveskite slaptažodį"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Jei norite atrakinti, įveskite PIN kodą"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Neteisingas PIN kodas."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Jei norite atrakinti, paspauskite „Meniu“ ir 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Pagalbos numeris"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Nėra paslaugos."</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Ekranas užrakintas."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Paspauskite „Meniu“, kad atrakintumėte ar skambintumėte pagalbos numeriu."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Paspauskite „Meniu“, jei norite atrakinti."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Nustatyti modelį, kad atrakintų"</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Skambutis pagalbos numeriu"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"grįžti prie skambučio"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Teisingai!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Bandykite dar kartą"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Bandykite dar kartą"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Viršijote maksimalų atrakinimo pagal veidą bandymų skaičių"</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Įkraunama, <xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Įkrauta"</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">"Prijunkite kroviklį."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Nėra SIM kortelės"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Planšetiniame kompiuteryje nėra SIM kortelės."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Telefone nėra SIM kortelės."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Įdėkite SIM kortelę."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"Trūksta SIM kortelės arba ji neskaitoma. Įdėkite SIM kortelę."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Negalima naudoti SIM kortelės."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"SIM kortelė visam laikui neleidžiama.\n Jei norite gauti kitą SIM kortelę, susisiekite su belaidžio ryšio paslaugos teikėju."</string>
    <string name="lockscreen_transport_prev_description" msgid="201594905152746886">"Ankstesnio takelio mygtukas"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Kito takelio mygtukas"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Pristabdymo mygtukas"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Paleidimo mygtukas"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Sustabdymo mygtukas"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Tik pagalbos skambučiai"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Tinklas užrakintas"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM kortelė užrakinta PUK kodu."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Žr. naudotojo vadovą arba susisiekite su klientų priežiūros tarnyba."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM kortelė užrakinta."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Atrakinama SD kortelė..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"Neteisingai apibrėžėte atrakinimo modelį <xliff:g id="NUMBER_0">%d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%d</xliff:g> sek."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Neteisingai įvedėte slaptažodį <xliff:g id="NUMBER_0">%d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%d</xliff:g> sek."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"PIN kodą neteisingai įvedėte <xliff:g id="NUMBER_0">%d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Neteisingai nurodėte savo atrakinimo modelį <xliff:g id="NUMBER_0">%d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. būsite paprašyti atrakinti planšetinį kompiuterį naudodami „Google“ prisijungimo duomenis.\n\n Bandykite dar kartą po <xliff:g id="NUMBER_2">%d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Neteisingai nurodėte savo atrakinimo modelį <xliff:g id="NUMBER_0">%d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. būsite paprašyti atrakinti telefoną naudodami „Google“ prisijungimo duomenis.\n\n Bandykite dar kartą po <xliff:g id="NUMBER_2">%d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"<xliff:g id="NUMBER_0">%d</xliff:g> kart. bandėte netinkamai atrakinti planšetinį kompiuterį. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. planšetiniame kompiuteryje bus iš naujo nustatyti numatytieji gamyklos nustatymai ir bus prarasti visi naudotojo duomenys."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"<xliff:g id="NUMBER_0">%d</xliff:g> kart. bandėte netinkamai atrakinti telefoną. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. telefone bus iš naujo nustatyti numatytieji gamyklos nustatymai ir bus prarasti visi naudotojo duomenys."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"<xliff:g id="NUMBER">%d</xliff:g> kart. bandėte netinkamai atrakinti planšetinį kompiuterį. Planšetinis kompiuteris bus iš naujo nustatytas į numatytuosius gamyklos nustatymus."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"<xliff:g id="NUMBER">%d</xliff:g> kart. bandėte netinkamai atrakinti telefoną. Telefonas bus iš naujo nustatytas į numatytuosius gamyklos nustatymus."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Bandyti dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sek."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Pamiršote modelį?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Paskyros atrakinimas"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Per daug šablonų bandymų"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Jei norite atrakinti, prisijunkite naudodami „Google“ paskyrą."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Naudotojo vardas (el. paštas)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Slaptažodis"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Prisijungti"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Neteisingas naudotojo vardas ar slaptažodis."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Pamiršote naudotojo vardą ar slaptažodį?\nApsilankykite šiuo adresu: "<b>"google.com/accounts/recovery?hl=lt"</b></string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Tikrinama..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Atblokuoti"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Garsas įjungtas"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Išjungti garsą"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Šablonas pradėtas"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Šablonas išvalytas"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Pridėtas langelis"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Šablonas užbaigtas"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. %2$d valdiklis iš %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Pridėti valdiklį."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Tuščia"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Atrakinimo sritis išplėsta."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Atrakinimo sritis sutraukta."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Valdiklis <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Naudotojo pasirinkimo valdiklis"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Būsena"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Fotoaparatas"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Medijos valdikliai"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Valdiklių pertvarkymas pradėtas."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Valdiklių pertvarkymas baigtas."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Valdiklis <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> ištrintas."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Išplėsti atrakinimo sritį."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Atrakinimas slystant."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Atrakinimas pagal piešinį."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Atrakinimas pagal veidą."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Atrakinimas įvedus PIN kodą."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Atrakinimas įvedus slaptažodį."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Atrakinimo pagal piešinį sritis."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Slydimo sritis."</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">"simbolis"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"žodis"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"nuoroda"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"eilutė"</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">"Gamyklos bandymas nepavyko"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Veiksmas FACTORY_TEST palaikomas tik paketuose, įdiegtuose /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Nerasta paketo, kuris teiktų FACTORY_TEST veiksmą."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Pakartotinai įkelti"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Puslapyje šiuo adresu: <xliff:g id="TITLE">%s</xliff:g>, teigiama:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Patvirtinti išėjimą"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Išeiti iš šio puslapio"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Likti šiame puslapyje"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nTikrai norite išeiti iš šio puslapio?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Patvirtinti"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Patarimas: palieskite dukart, kad padidintumėte ar sumažintumėte mastelį."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Automatinis pildymas"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Nust. aut. pild."</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">"Provincija"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Pašto kodas"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Valstija"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Pašto kodas"</string>
    <string name="autofill_county" msgid="237073771020362891">"Apskritis"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Sala"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Rajonas"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Departamentas"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektūra"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Parapija"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Sritis"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emyratas"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"skaityti žiniatinklio žymes ir istoriją"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Leidžiama programai skaityti visų URL, kuriais buvo lankytasi naršyklėje, ir visų naršyklės žymių istoriją. Pastaba: šis leidimas nesuteikiamas trečiosios šalies naršyklėms ar kitoms programoms, kuriomis galima naršyti žiniatinklį."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"rašyti žiniatinklio žymes ir istoriją"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Leidžiama programai keisti naršyklės istoriją ar žymes, išsaugotas planšetiniame kompiuteryje. Dėl to programai gali būti leidžiama ištrinti ar keisti naršyklės duomenis. Pastaba: šis leidimas nesuteikiamas trečiosios šalies naršyklėms ar kitoms programoms, kuriomis galima naršyti žiniatinklį."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Leidžiama programai keisti naršyklės istoriją ar žymes, išsaugotas telefone. Dėl to programai gali būti leidžiama ištrinti ar keisti naršyklės duomenis. Pastaba: šis leidimas nesuteikiamas trečiosios šalies naršyklėms ar kitoms programoms, kuriomis galima naršyti žiniatinklį."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"nustatyti pavojaus signalą"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Leidžiama programai nustatyti signalą įdiegtoje žadintuvo programoje. Kai kuriose žadintuvo programose ši funkcija gali nebūti nevykdoma."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"pridėti balso pašto pranešimų"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Leidžia programai pridėti pranešimų prie jūsų balso pašto gautųjų."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"keisti naršyklės geografinės vietos leidimus"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Leidžiama programai keisti naršyklės geografinės vietos leidimus. Kenkėjiškos programos gali tai naudoti, kad leistų siųsti vietos informaciją abejotinoms svetainėms."</string>
    <string name="permlab_packageVerificationAgent" msgid="5568139100645829117">"patikrinti paketus"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Leidžiama programai patikrinti, ar paketą galima įdiegti."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"susaistyti su paketo tikrinimo programa"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Savininkui leidžiama teikti užklausas patikrinti paketą. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"pasiekti nuosekliuosius prievadus"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Leidžiama savininkui pasiekti nuosekliuosius prievadus naudojant „SerialManager“ API."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"pasiekti turinio teikėjus iš išorės"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Leidžiama savininkui pasiekti turinio teikėjus naudojant apvalkalą. To niekada neturėtų prireikti naudojant įprastas programas."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"Atsisakyti autom. įrenginio atnaujinimų"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Leidžia savininkui pateikti pasiūlymą sistemai dėl tinkamo laiko iš naujo neinteraktyviai įkelti programą, kad būtų naujovinamas įrenginys."</string>
    <string name="save_password_message" msgid="767344687139195790">"Ar norite, kad naršyklė atsimintų šį slaptažodį?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Ne dabar"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Atsiminti"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Niekada"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Neturite leidimo atidaryti šį puslapį."</string>
    <string name="text_copied" msgid="4985729524670131385">"Tekstas nukopijuotas į iškarpinę."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Daugiau"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Meniu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"tarpas"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"„Enter“ klavišas"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"ištrinti"</string>
    <string name="search_go" msgid="8298016669822141719">"Ieškoti"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Ieškoti"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Paieškos užklausa"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Išvalyti užklausą"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Patvirtinti užklausą"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Paieška balsu"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Įgalinti naršymą liečiant?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"„<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g>“ nori įgalinti naršymą liečiant. Kai naršymas liečiant bus įjungtas, galėsite išgirsti ar peržiūrėti pirštu liečiamų elementų aprašus arba atlikdami gestus naudoti planšetinį kompiuterį."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"„<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g>“ nori įgalinti naršymą liečiant. Kai naršymas liečiant bus įjungtas, galėsite išgirsti ar peržiūrėti pirštu liečiamų elementų aprašus arba atlikdami gestus naudoti telefoną."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"Prieš 1 mėn."</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Prieš maždaug 1 mėnesį"</string>
  <plurals name="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"Prieš 1 sek."</item>
    <item quantity="other" msgid="3903706804349556379">"Prieš <xliff:g id="COUNT">%d</xliff:g> sek."</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"Prieš 1 minutę"</item>
    <item quantity="other" msgid="2176942008915455116">"Prieš <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"Prieš 1 valandą"</item>
    <item quantity="other" msgid="2467273239587587569">"Prieš <xliff:g id="COUNT">%d</xliff:g> val."</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Paskutinės <xliff:g id="COUNT">%d</xliff:g> dienos (-ų)"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Paskutinį mėnesį"</string>
    <string name="older" msgid="5211975022815554840">"Senesni"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"vakar"</item>
    <item quantity="other" msgid="2479586466153314633">"Prieš <xliff:g id="COUNT">%d</xliff:g> d."</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"po 1 sek."</item>
    <item quantity="other" msgid="1241926116443974687">"po <xliff:g id="COUNT">%d</xliff:g> sek."</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"po 1 min."</item>
    <item quantity="other" msgid="3330713936399448749">"po <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"po 1 val."</item>
    <item quantity="other" msgid="547290677353727389">"po <xliff:g id="COUNT">%d</xliff:g> val."</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"rytoj"</item>
    <item quantity="other" msgid="5109449375100953247">"po <xliff:g id="COUNT">%d</xliff:g> d."</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"Prieš 1 sek."</item>
    <item quantity="other" msgid="3699169366650930415">"Prieš <xliff:g id="COUNT">%d</xliff:g> sek."</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"Prieš 1 min."</item>
    <item quantity="other" msgid="851164968597150710">"Prieš <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"Prieš 1 valandą"</item>
    <item quantity="other" msgid="6889970745748538901">"Prieš <xliff:g id="COUNT">%d</xliff:g> val."</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"vakar"</item>
    <item quantity="other" msgid="3453342639616481191">"Prieš <xliff:g id="COUNT">%d</xliff:g> d."</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"po 1 sek."</item>
    <item quantity="other" msgid="5495880108825805108">"po <xliff:g id="COUNT">%d</xliff:g> sek."</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"po 1 min."</item>
    <item quantity="other" msgid="4216113292706568726">"po <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"po 1 val."</item>
    <item quantity="other" msgid="3705373766798013406">"po <xliff:g id="COUNT">%d</xliff:g> val."</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"rytoj"</item>
    <item quantity="other" msgid="2973062968038355991">"po <xliff:g id="COUNT">%d</xliff:g> d."</item>
  </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"<xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"<xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"<xliff:g id="YEAR">%s</xliff:g> m."</string>
    <string name="day" msgid="8144195776058119424">"d."</string>
    <string name="days" msgid="4774547661021344602">"d."</string>
    <string name="hour" msgid="2126771916426189481">"val."</string>
    <string name="hours" msgid="894424005266852993">"val."</string>
    <string name="minute" msgid="9148878657703769868">"min."</string>
    <string name="minutes" msgid="5646001005827034509">"min."</string>
    <string name="second" msgid="3184235808021478">"sek."</string>
    <string name="seconds" msgid="3161515347216589235">"sek."</string>
    <string name="week" msgid="5617961537173061583">"savaitė"</string>
    <string name="weeks" msgid="6509623834583944518">"sav."</string>
    <string name="year" msgid="4001118221013892076">"metai"</string>
    <string name="years" msgid="6881577717993213522">"metai"</string>
  <plurals name="duration_seconds">
    <item quantity="one" msgid="6962015528372969481">"1 sek."</item>
    <item quantity="other" msgid="1886107766577166786">"<xliff:g id="COUNT">%d</xliff:g> sek."</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 val."</item>
    <item quantity="other" msgid="3863962854246773930">"<xliff:g id="COUNT">%d</xliff:g> val."</item>
  </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Vaizdo įrašo problema"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Šis vaizdo įrašas netinkamas srautiniu būdu perduoti į šį įrenginį."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Negalima paleisti šio vaizdo įrašo."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"Gerai"</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">"vidurdienis"</string>
    <string name="Noon" msgid="3342127745230013127">"Vidurdienis"</string>
    <string name="midnight" msgid="7166259508850457595">"vidurnaktis"</string>
    <string name="Midnight" msgid="5630806906897892201">"Vidurnaktis"</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">"Pasirinkti visus"</string>
    <string name="cut" msgid="3092569408438626261">"Iškirpti"</string>
    <string name="copy" msgid="2681946229533511987">"Kopijuoti"</string>
    <string name="paste" msgid="5629880836805036433">"Įklijuoti"</string>
    <string name="replace" msgid="5781686059063148930">"Pakeisti•"</string>
    <string name="delete" msgid="6098684844021697789">"Ištrinti"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopijuoti URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Pasirinkti tekstą"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Teksto pasirinkimas"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Pridėti prie žodyno"</string>
    <string name="deleteText" msgid="6979668428458199034">"Ištrinti"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Įvesties būdas"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Teksto veiksmai"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Mažėja laisvos saugyklos vietos"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Kai kurios sistemos funkcijos gali neveikti"</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ vykdoma"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Palieskite, jei norite gauti daugiau informacijos arba sustabdyti programą."</string>
    <string name="ok" msgid="5970060430562524910">"Gerai"</string>
    <string name="cancel" msgid="6442560571259935130">"Atšaukti"</string>
    <string name="yes" msgid="5362982303337969312">"Gerai"</string>
    <string name="no" msgid="5141531044935541497">"Atšaukti"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Dėmesio"</string>
    <string name="loading" msgid="7933681260296021180">"Įkeliama..."</string>
    <string name="capital_on" msgid="1544682755514494298">"ĮJ."</string>
    <string name="capital_off" msgid="6815870386972805832">"IŠJ."</string>
    <string name="whichApplication" msgid="4533185947064773386">"Užbaigti veiksmą naudojant"</string>
    <string name="whichHomeApplication" msgid="4616420172727326782">"Pasirinkite programą, paleidžiamą spustelėjus pagrindinio ekrano mygtuką"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Šiam veiksmui tai naudoti pagal numatytuosius nustatymus."</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Numatytuosius nustatymus išvalykite nuėję į „Sistemos nustatymai“ &gt; „Programos“ &gt; „Atsisiųsta“."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Pasirinkti veiksmą"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Pasirinkite USB įrenginio programą"</string>
    <string name="noApplications" msgid="2991814273936504689">"Jokios programos negali atlikti šio veiksmo."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Deja, <xliff:g id="APPLICATION">%1$s</xliff:g> sustojo."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Deja, <xliff:g id="PROCESS">%1$s</xliff:g> sustojo."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"„<xliff:g id="APPLICATION">%2$s</xliff:g>“ neatsako.\n\nAr norite ją uždaryti?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Veiksmas „<xliff:g id="ACTIVITY">%1$s</xliff:g>“ neatsako.\n\nAr norite jį uždaryti?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"„<xliff:g id="APPLICATION">%1$s</xliff:g>“ neatsako. Ar norite ją uždaryti?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Procesas „<xliff:g id="PROCESS">%1$s</xliff:g>“ neatsako.\n\nAr norite jį uždaryti?"</string>
    <string name="force_close" msgid="8346072094521265605">"Gerai"</string>
    <string name="report" msgid="4060218260984795706">"Ataskaita"</string>
    <string name="wait" msgid="7147118217226317732">"Palaukti"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Puslapis neatsako.\n\nAr norite jį uždaryti?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Programa peradresuota"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ dabar vykdoma."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ buvo iš pradžių paleista."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Mastelis"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Visada rodyti"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Įgalinkite jį iš naujo nuėję į „Sistemos nustatymai“ &gt; „Programos“ &gt; „Atsisiųsta“."</string>
    <string name="smv_application" msgid="3307209192155442829">"Programa „<xliff:g id="APPLICATION">%1$s</xliff:g>“ (procesas „<xliff:g id="PROCESS">%2$s</xliff:g>“) pažeidė savo vykdomą „StrictMode“ politiką."</string>
    <string name="smv_process" msgid="5120397012047462446">"„<xliff:g id="PROCESS">%1$s</xliff:g>“ procesas pažeidė savo vykdomą „StrictMode“ politiką."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"„Android“ naujovinama..."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Optimizuojama <xliff:g id="NUMBER_0">%1$d</xliff:g> progr. iš <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Paleidžiamos programos."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Užbaigiamas paleidimas."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"Vykdoma „<xliff:g id="APP">%1$s</xliff:g>“"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Palieskite, kad perjungtumėte programą"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Perjungti programas?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Jau vykdoma kita programa, kurią reikia sustabdyti prieš paleidžiant naują."</string>
    <string name="old_app_action" msgid="493129172238566282">"Grįžti į <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Nepaleiskite naujos programos."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Paleisti „<xliff:g id="OLD_APP">%1$s</xliff:g>“"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Sustabdyti seną programą jos neišsaugant."</string>
    <string name="sendText" msgid="5209874571959469142">"Pasirinkite teksto veiksmą"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Skambučio garsumas"</string>
    <string name="volume_music" msgid="5421651157138628171">"Medijos garsumas"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Paleista naudojant „Bluetooth“"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Nustatytas tylus skambėjimo tonas"</string>
    <string name="volume_call" msgid="3941680041282788711">"Skambučio apimtis"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"„Bluetooth“ skambučio garsumas"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Signalo garsumas"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Pranešimo apimtis"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Garsumas"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"„Bluetooth“ garsumas"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Skambėjimo tono garsumas"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Skambučio garsumas"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Medijos garsumas"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Pranešimo apimtis"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Numatytasis skambėjimo tonas"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Numatytasis skambėjimo tonas (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Nėra"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Skambėjimo tonai"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Nežinomas skambėjimo tonas"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"Galimas „Wi-Fi“ tinklas"</item>
    <item quantity="other" msgid="4192424489168397386">"galimi „Wi-Fi“ tinklai"</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"Atidaryti galimą „Wi-Fi“ tinklą"</item>
    <item quantity="other" msgid="7915895323644292768">"Atidaryti galimus „Wi-Fi“ tinklus"</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Prisijungti prie „Wi-Fi“ ryšio tinklo"</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Prisijungti prie tinklo"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Nepavyko prisijungti prie „Wi-Fi“"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" turi prastą interneto ryšį."</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Tiesioginis „Wi-Fi“ ryšys"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Paleiskite „Wi-Fi Direct“. Bus išjungta „Wi-Fi“ programa / viešosios interneto prieigos taškas."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Nepavyko paleisti „Wi-Fi Direct“."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"„Wi-Fi Direct“ įjungta"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Jei norite peržiūrėti nustatymus, palieskite"</string>
    <string name="accept" msgid="1645267259272829559">"Sutikti"</string>
    <string name="decline" msgid="2112225451706137894">"Atmesti"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Pakvietimas išsiųstas"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Pakvietimas prisijungti"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Nuo:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Skirta:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Įveskite reikiamą PIN kodą:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN kodas:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"Planšetinis kompiuteris bus laikinai atjungtas nuo „Wi-Fi“, kol jis prijungtas prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"Telefonas bus laikinai atjungtas nuo „Wi-Fi“, kol bus prijungtas prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="select_character" msgid="3365550120617701745">"Įterpti simbolį"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"SMS pranešimų siuntimas"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"Naudojant &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; siunčiama daug SMS pranešimų. Ar norite leisti šiai programai toliau siųsti pranešimus?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Leisti"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Uždrausti"</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; norėtų išsiųsti pranešimą šiuo adresu: &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="3492025719868078457"><font fgcolor="#ffffb060">"Gali būti taikomi mokesčiai"</font>" paskyroje mobiliesiems."</string>
    <string name="sms_premium_short_code_details" msgid="5523826349105123687"><font fgcolor="#ffffb060">"Bus taikomi mokesčiai paskyroje mobiliesiems."</font></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Siųsti"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Atšaukti"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Atsiminti mano pasirinkimą"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Tai vėliau galėsite pakeisti skiltyje „Nustatymai“ &gt; „Programos“"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Visada leisti"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Niekada neleisti"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM kortelė pašalinta"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Mobilusis tinklas bus nepasiekiamas, kol nepaleisite iš naujo įdėję tinkamą SIM kortelę."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Atlikta"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"SIM kortelė pridėta"</string>
    <string name="sim_added_message" msgid="6599945301141050216">"Jei norite pasiekti mobiliojo ryšio tinklą, reikia iš naujo paleisti įrenginį."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Paleisti iš naujo"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Nustatyti laiką"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Nustatyti datą"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Nustatyti"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Baigta"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"NAUJAS: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Pateikė „<xliff:g id="APP_NAME">%1$s</xliff:g>“."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Nereikia leidimų"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"tai gali kainuoti"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"USB didelės talpos atmintis"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB prijungtas"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Prisijungėte prie kompiuterio per USB. Jei norite kopijuoti failus iš kompiuterio į „Android“ USB atmintį ir atvirkščiai, palieskite toliau pateiktą mygtuką."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Prisijungėte prie kompiuterio per USB. Jei norite kopijuoti failus iš kompiuterio į „Android“ SD kortelę ir atvirkščiai, palieskite toliau pateiktą mygtuką."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Įjungti USB saugyklą"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Iškilo problema naudojant USB atmintį kaip USB didelės talpos atmintį."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Iškilo problema naudojant SD kortelę kaip USB didelės talpos atmintį."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB prijungtas"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Palieskite, kad kopijuotumėte failus į kompiuterį / iš jo."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Išjungti USB saugyklą"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Palieskite, kad išjungtumėte USB atmintį."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"Naudojama USB saugykla"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Prieš išjungdami USB atmintį, iš kompiuterio pašalinkite („išstumkite“) savo „Android“ USB atmintį."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Prieš išjungdami USB atmintį, iš kompiuterio pašalinkite („išstumkite“) „Android“ SD kortelę."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Išjungti USB saugyklą"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Išjungiant USB atmintį iškilo problemų. Įsitikinkite, kad pašalinote USB prieglobą ir bandykite dar kartą."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Įjungti USB saugyklą"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Jei įjungsite USB atmintį, kai kurios naudojamos programos sustos ir gali būti negalimos, kol ją išjungsite."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"Nesėkminga USB operacija"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"Gerai"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Prij. kaip medijos įrenginys"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Prij. kaip fotoap."</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Prij. kaip diegimo programa"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Prijungta prie USB priedo"</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Jei norite matyti kitas USB parinktis, palieskite."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Formatuoti USB atmintį?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Formatuoti SD kortelę?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Bus ištrinti visi USB atmintyje saugomi failai. Šio veiksmo negalima atšaukti!"</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Bus prarasti visi kortelėje esantys duomenys."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Formatuoti"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"USB derinimas prijungtas"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Palieskite, kad neleistumėte USB derinimo."</string>
    <string name="select_input_method" msgid="4653387336791222978">"Pasirinkite įvesties metodą"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Nustatyti įvesties metodus"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Fizinė klaviatūra"</string>
    <string name="hardware" msgid="7517821086888990278">"Apar. įr."</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Pasirinkite klaviatūros išdėstymą"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Palieskite, kad pasirinktumėte klaviatūros išdėstymą."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" AĄBCČDEĘĖFGHIĮYJKLMNOPRSŠTUŲŪVZŽ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789AĄBCČDEĘĖFGHIĮYJKLMNOPRSŠTUŲŪVZŽ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"kandidatai"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"Ruošiama USB atmintinė"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"Ruošiama SD kortelė"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Tikrinama, ar nėra klaidų."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Tuščia USB atmintinė"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Tuščia SD kortelė"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"USB atmintis tuščia arba jos failų sistema nepalaikoma."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"USB atmintis tuščia arba jos failų sistema nepalaikoma."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Sugadinta USB atmintinė"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Pažeista SD kortelė"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"USB atmintis pažeista. Pabandykite formatuoti ją iš naujo."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"SD kortelė pažeista. Pabandykite formatuoti ją iš naujo."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"USB atmintinė netikėtai pašal."</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"SD kortelė netikėtai pašalinta"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Kad neprarastumėte duomenų, prieš pašalindami atjunkite USB atmintinę."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Išimti SD kortelę prieš pašalinant, kad nebūtų prarasti duomenys."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"Galima pašalinti USB atmintinę"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"Saugu pašalinti SD kortelę"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"Galite saugiau pašalinti USB atmintinę."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"Galite saugiai pašalinti SD kortelę."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"Pašalinta USB atmintinė"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Pašalinta SD kortelė"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"USB atmintinė pašalinta. Įdėti naują mediją."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"SD kortelė pašalinta. Įdėkite naują."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nerasta atitinkančios veiklos."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"atnaujinti komponento naudojimo statistiką"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Leidžiama programai keisti surinktą komponento naudojimo statistiką. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"kopijuoti turinį"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Leidžiama programai iškviesti numatytąją sudėtinio rodinio paslaugą, kad būtų kopijuojamas turinys. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Medijos išvesties nukreipimas"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Leidžiama programai nukreipti medijos išvestį į kitus išorinius įrenginius."</string>
    <string name="permlab_access_keyguard_secure_storage" msgid="7565552237977815047">"Pasiekti „KeyGuard“ saugyklą"</string>
    <string name="permdesc_access_keyguard_secure_storage" msgid="5866245484303285762">"Programai leidžiama pasiekti „KeyGuard“ saugyklą."</string>
    <string name="permlab_control_keyguard" msgid="172195184207828387">"Valdyti „KeyGuard“ rodymą ir slėpimą"</string>
    <string name="permdesc_control_keyguard" msgid="3043732290518629061">"Programai leidžiama valdyti „KeyGuard“."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Dukart palieskite, kad valdytumėte mastelio keitimą"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Nepavyko pridėti."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Pradėti"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Ieškoti"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Siųsti"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Kitas"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Atlikta"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Perž."</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Vykdyti"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Rinkti numerį \nnaudojant <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Sukurti adresatą\nnaudojant <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Pateikta mažiausiai vienos toliau nurodytos programos užklausa dėl leidimo dabar ir ateityje pasiekti jūsų paskyrą."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Ar norite leisti šią užklausą?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Užklausa dėl prieigos"</string>
    <string name="allow" msgid="7225948811296386551">"Leisti"</string>
    <string name="deny" msgid="2081879885755434506">"Atmesti"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Pateikta užklausa dėl leidimo"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Pateikta leidimo užklausa\ndėl <xliff:g id="ACCOUNT">%s</xliff:g> paskyros"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Įvesties būdas"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sinchronizuoti"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Pasiekiamumas"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Darbalaukio fonas"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Keisti darbalaukio foną"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Pranešimų skaitymo priemonė"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN suaktyvintas"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"VPN suaktyvino „<xliff:g id="APP">%s</xliff:g>“"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Palieskite, kad valdytumėte tinklą."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Prisijungta prie <xliff:g id="SESSION">%s</xliff:g>. Jei norite valdyti tinklą, palieskite."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Prisijungiama prie visada įjungto VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Prisijungta prie visada įjungto VPN"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Visada įjungto VPN klaida"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Jei norite konfigūruoti, palieskite."</string>
    <string name="upload_file" msgid="2897957172366730416">"Pasirinkti failą"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Nepasirinktas joks failas"</string>
    <string name="reset" msgid="2448168080964209908">"Atstatyti"</string>
    <string name="submit" msgid="1602335572089911941">"Pateikti"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Įgalintas automobilio režimas"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Palieskite, kad išeitumėte iš automobilio režimo."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Susietas ar aktyvus"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Jei norite nustatyti, palieskite."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Atgal"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Kitas"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Praleisti"</string>
    <string name="throttle_warning_notification_title" msgid="4890894267454867276">"Didelis mobiliųjų duomenų naudojimas"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Palieskite, kad sužinotumėte daugiau apie mobiliųjų duomenų naudojimą."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Viršyta mobilių duomenų riba"</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Palieskite, kad sužinotumėte daugiau apie mobiliųjų duomenų naudojimą."</string>
    <string name="no_matches" msgid="8129421908915840737">"Nėra atitikčių"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Ieškoti puslapyje"</string>
  <plurals name="matches_found">
    <item quantity="one" msgid="8167147081136579439">"1 atitiktis"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g> iš <xliff:g id="TOTAL">%d</xliff:g>"</item>
  </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Atlikta"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Pašalinama USB atmintis..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Pašalinama SD kortelė..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Ištrinama USB atmintis..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Ištrinama SD kortelė..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Nepavyko ištrinti USB atminties."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Nepavyko ištrinti SD kortelės."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"SD kortelė buvo pašalinta jos neatjungus."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"Šiuo metu USB atmintinė tikrinama."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"Šiuo metu SD kortelė tikrinama."</string>
    <string name="media_removed" msgid="7001526905057952097">"SD kortelė pašalinta."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"Šiuo metu USB atmintinė naudojama kompiuteryje."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"Šiuo metu SD kortelė naudojama kompiuteryje."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Nežinomos būsenos išorinė medija."</string>
    <string name="share" msgid="1778686618230011964">"Bendrinti"</string>
    <string name="find" msgid="4808270900322985960">"Ieškoti"</string>
    <string name="websearch" msgid="4337157977400211589">"Žiniat. paieška"</string>
    <string name="find_next" msgid="5742124618942193978">"Rasti kitą"</string>
    <string name="find_previous" msgid="2196723669388360506">"Rasti ankstesnį"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Vietos užklausa iš <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Vietos užklausa"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Užklausą pateikė <xliff:g id="NAME">%1$s</xliff:g> („<xliff:g id="SERVICE">%2$s</xliff:g>“)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Taip"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Ne"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Viršytas ištrynimo apribojimas"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Yra <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> ištr. element., skirt. <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g>, „<xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>“ pask. Ką norite daryti?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Ištrinti elementus"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Anuliuoti ištrynimus"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Kol kas nieko nedaryti"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Pasirinkti paskyrą"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Pridėti paskyrą"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Pridėti paskyrą"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Padidinti"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Sumažinti"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"Palieskite <xliff:g id="VALUE">%s</xliff:g> ir laikykite."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Slinkite aukštyn, kad padidintumėte, ir žemyn, kad sumažintumėte."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Padidinti minučių skaičių"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Sumažinti minučių skaičių"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Padidinti valandų skaičių"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Sumažinti valandų skaičių"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Nustatyti po pusiaudienio"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Nustatyti prieš pusiaudienį"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Padidinti mėnesių skaičių"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Sumažinti mėnesių skaičių"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Padidinti dienų skaičių"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Sumažinti dienų skaičių"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Padidinti metų skaičių"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Sumažinti metų skaičių"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Atšaukti"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Ištrinti"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Atlikta"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Režimo keitimas"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Įvesti"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Pasirinkite programą"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Bendrinti su"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Bendrinti su „<xliff:g id="APPLICATION_NAME">%s</xliff:g>“"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Slydimo valdymas. Palieskite ir laikykite."</string>
    <string name="description_direction_up" msgid="7169032478259485180">"Slyskite aukštyn link <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Slyskite žemyn link <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Slyskite į kairę link <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Slyskite į dešinę link <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Atrakinti"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Vaizdo kamera"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Begarsis"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Garsas įjungtas"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Paieška"</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Perbraukite pirštu, kad atrakintumėte."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Prijunkite ausines, kad išgirstumėte sakomus slaptažodžio klavišus."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Taškas."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Naršyti pagrindinį puslapį"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Naršyti į viršų"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Daugiau parinkčių"</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">"Vidinė atmintis"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD kortelė"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB atmintis"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Redaguoti"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Įspėjimas dėl duomenų naudojimo"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Palieskite ir žr. naud. ir nust."</string>
    <string name="data_usage_3g_limit_title" msgid="7093334419518706686">"2G–3G duomenys neleidžiami"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"4G duomenys neleidžiami"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Mobilieji duomenys neleidžiami"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"„Wi-Fi“ duomenys neleidžiami"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Palieskite, kad įgalintumėte."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"Viršyta 2G–3G duomenų riba"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Viršyta 4G duomenų riba"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Viršyta mobiliųjų duomenų riba"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Viršytas „Wi-Fi“ duomenų aprib."</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> viršyta nurodyta riba."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Apriboti foniniai duomenys"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Palieskite, kad pašalint. aprib."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Saugos sertifikatas"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Šis sertifikatas galioja."</string>
    <string name="issued_to" msgid="454239480274921032">"Išduota:"</string>
    <string name="common_name" msgid="2233209299434172646">"Bendras pavadinimas:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizacija:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organizacinis vienetas:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Išdavė:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Galiojimas:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Išduota:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Galiojimas baigiasi:"</string>
    <string name="serial_number" msgid="758814067660862493">"Serijos numeris:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Kontroliniai kodai"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"SHA-256 kontrolinis kodas"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"SHA-1 kontrolinis kodas"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Žr. viską"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Pasirinkti veiklą"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Bendrinti su"</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Siunčiama…"</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Paleisti naršyklę?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Priimti skambutį?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Visada"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Tik kartą"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Planšetinis kompiuteris"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefonas"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Ausinės"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Doko garsiakalbiai"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Sistema"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"„Bluetooth“ garsas"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Belaidis rodymas"</string>
    <string name="media_route_chooser_grouping_done" msgid="7966438307723317169">"Atlikta"</string>
    <string name="media_route_button_content_description" msgid="5758553567065145276">"Medijos išvestis"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Nuskaitoma..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Jungiama..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Pasiekiama"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Nepasiekiama"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"Naudojama"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Integruotas ekranas"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI ekranas"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Perdanga 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> tašk. colyje"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="6022119702628572080">", saugu"</string>
    <string name="wifi_display_notification_title" msgid="2223050649240326557">"Prijungtas belaidis monitorius"</string>
    <string name="wifi_display_notification_message" msgid="4498802012464170685">"Šis ekranas rodomas kitame įrenginyje"</string>
    <string name="wifi_display_notification_disconnect" msgid="6183754463561153372">"Atjungti"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Skambutis pagalbos numeriu"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Pamiršau atrakinimo piešinį"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Netinkamas atrakinimo piešinys"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Netinkamas slaptažodis"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Netinkamas PIN kodas"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Bandyti dar kartą po <xliff:g id="NUMBER">%1$d</xliff:g> sek."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Nupieškite atrakinimo piešinį"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Įveskite SIM PIN kodą"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Įveskite PIN kodą"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Įveskite slaptažodį"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"Dabar SIM neleidžiama. Jei norite tęsti, įveskite PUK kodą. Jei reikia išsamios informacijos, susisiekite su operatoriumi."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Įveskite pageidaujamą PIN kodą"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Patvirtinkite pageidaujamą PIN kodą"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Atrakinama SIM kortelė…"</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Netinkamas PIN kodas."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Įveskite PIN kodą, sudarytą iš 4–8 skaičių."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="7553388325654369575">"PUK kodas turėtų būti mažiausiai 8 skaitmenų."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Pakartotinai įveskite tinkamą PUK kodą. Pakartotinai bandant SIM bus neleidžiama visam laikui."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"PIN kodai neatitinka"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Per daug atrakinimo piešinių bandymų"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Jei norite atrakinti, prisijunkite naudodami „Google“ paskyrą."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Naudotojo vardas (el. paštas)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Slaptažodis"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Prisijungti"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Netinkamas naudotojo vardas ar slaptažodis."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Pamiršote naudotojo vardą ar slaptažodį?\nApsilankykite šiuo adresu: "<b>"google.com/accounts/recovery"</b></string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Tikrinama paskyra…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"PIN kodą netinkamai įvedėte <xliff:g id="NUMBER_0">%d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%d</xliff:g> sek."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"Neteisingai įvedėte slaptažodį <xliff:g id="NUMBER_0">%d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%d</xliff:g> sek."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%d</xliff:g> sek."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"<xliff:g id="NUMBER_0">%d</xliff:g> k. bandėte netinkamai atrakinti planšetinį kompiuterį. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. planšetiniame kompiuteryje bus iš naujo nustatyti numatytieji gamyklos nustatymai ir bus prarasti visi naudotojo duomenys."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"<xliff:g id="NUMBER_0">%d</xliff:g> k. bandėte netinkamai atrakinti telefoną. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. telefone bus iš naujo nustatyti numatytieji gamyklos nustatymai ir bus prarasti visi naudotojo duomenys."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"<xliff:g id="NUMBER">%d</xliff:g> k. bandėte netinkamai atrakinti planšetinį kompiuterį. Planšetiniame kompiuteryje bus iš naujo nustatyti numatytieji gamyklos nustatymai."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"<xliff:g id="NUMBER">%d</xliff:g> k. bandėte netinkamai atrakinti telefoną. Telefone bus iš naujo nustatyti numatytieji gamyklos nustatymai."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. būsite paprašyti atrakinti planšetinį kompiuterį naudodami „Google“ prisijungimo duomenis.\n\n Bandykite dar kartą po <xliff:g id="NUMBER_2">%d</xliff:g> sek."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%d</xliff:g> nesėkm. band. būsite paprašyti atrakinti telefoną naudodami „Google“ prisijungimo duomenis.\n\n Bandykite dar kartą po <xliff:g id="NUMBER_2">%d</xliff:g> sek."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" – "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Pašalinti"</string>
    <string name="safe_media_volume_warning" product="default" msgid="7324161939475478066">"Padidinti garsumą viršijant saugų lygį?\nIlgai klausantis dideliu garsumu gali sutrikti klausa."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Laikykite palietę dviem pirštais, kad įgalintumėte pritaikymo neįgaliesiems režimą."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Pritaikymas neįgaliesiems įgalintas."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Pritaikymo neįgaliesiems režimas atšauktas."</string>
    <string name="user_switched" msgid="3768006783166984410">"Dabartinis naudotojas: <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="owner_name" msgid="2716755460376028154">"Savininkas"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Klaida"</string>
    <string name="app_no_restricted_accounts" msgid="5739463249673727736">"Ši programa nepalaiko apribotų profilių paskyrų"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Nerasta programa šiam veiksmui apdoroti"</string>
    <string name="revoke" msgid="5404479185228271586">"Anuliuoti"</string>
    <string name="mediasize_iso_a0" msgid="1994474252931294172">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="3333060421529791786">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="3097535991925798280">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3023213259314236123">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="231745325296873764">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3484327407340865411">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="4861908487129577530">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="5890208588072936130">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="4319425041085816612">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="4882220529506432008">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="2382866026365359391">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="3651827147402009675">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="6072859628278739957">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="1348731852150380378">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="2612510181259261379">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="695151378838115434">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="4863754285582212487">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="5305816292139647241">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="531673542602786624">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="9164474595708850034">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="282102976764774160">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="4517141714407898976">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="3103521357901591100">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1231954105985048595">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="927702816980087462">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="835154173518304159">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="5095951985108194011">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="1985397450332305739">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8147421924174693013">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="8993994925276122950">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="6871178104139598957">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="7983532635227561362">"ISO S9"</string>
    <string name="mediasize_iso_c10" msgid="5040764293406765584">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="2841414839888344296">"Laiškas"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="5295836838862962809">"Oficialus laiškas"</string>
    <string name="mediasize_na_legal" msgid="8621364037680465666">"Teisinis"</string>
    <string name="mediasize_na_junior_legal" msgid="3309324162155085904">"Mažas teisinis"</string>
    <string name="mediasize_na_ledger" msgid="5567030340509075333">"Buhalterinis"</string>
    <string name="mediasize_na_tabloid" msgid="4571735038501661757">"Bulvarinė spauda"</string>
    <string name="mediasize_na_index_3x5" msgid="5182901917818625126">"3 x 5 indekso kortelė"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"4 x 6 indekso kortelė"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"5 x 8 indekso kortelė"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Nežinomas stačias"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Nežinomas gulsčias"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Atšaukta"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Klaida rašant turinį"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"nežinoma"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Spausdinimo paslauga neįgalinta"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"Paslauga „<xliff:g id="NAME">%s</xliff:g>“ įdiegta"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Palieskite, kad įgalintumėte"</string>
    <string name="restr_pin_enter_admin_pin" msgid="783643731895143970">"Įveskite administratoriaus PIN kodą"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Įveskite PIN kodą"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Neteisingas"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Dabartinis PIN kodas"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Naujas PIN kodas"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Patvirtinti naują PIN kodą"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Sukurti modifikavimo apribojimų PIN kodą"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"PIN kodas neatitinka. Bandykite dar kartą."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"PIN kodas per trumpas. Jis turi būti bent 4 skaitmenų."</string>
  <plurals name="restr_pin_countdown">
    <item quantity="one" msgid="311050995198548675">"Band. dar po 1 s"</item>
    <item quantity="other" msgid="4730868920742952817">"Band. dar po <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Vėliau bandykite dar kartą"</string>
    <string name="immersive_mode_confirmation" msgid="7227416894979047467">"Perbraukite nuo viršaus žemyn, kad išeitumėte iš viso ekrano režimo"</string>
</resources>
