<?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="202579285008794431">"B"</string>
    <string name="kilobyteShort" msgid="2214285521564195803">"KB"</string>
    <string name="megabyteShort" msgid="6649361267635823443">"MB"</string>
    <string name="gigabyteShort" msgid="7515809460261287991">"GB"</string>
    <string name="terabyteShort" msgid="1822367128583886496">"TB"</string>
    <string name="petabyteShort" msgid="5651571254228534832">"PB"</string>
    <string name="fileSizeSuffix" msgid="4233671691980131257">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="3381766946944136678">"&lt;Be pavadinimo&gt;"</string>
    <string name="emptyPhoneNumber" msgid="5812172618020360048">"(Nėra telefono numerio)"</string>
    <string name="unknownName" msgid="7078697621109055330">"Nežinoma"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2190754495304236490">"Balso paštas"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2285034592902077488">"MSISDN1"</string>
    <string name="mmiError" msgid="2862759606579822246">"Ryšio problema arba neteisingas MMI kodas."</string>
    <string name="mmiFdnError" msgid="3975490266767565852">"Operacija ribojama tik naudojant fiksuoto rinkimo numerius."</string>
    <string name="mmiErrorWhileRoaming" msgid="1204173664713870114">"Negalima pakeisti telefono skambučio peradresavimo nustatymų, kai naudojate tarptinklinį ryšį."</string>
    <string name="serviceEnabled" msgid="7549025003394765639">"Paslauga įgalinta."</string>
    <string name="serviceEnabledFor" msgid="1463104778656711613">"Paslauga buvo įgalinta:"</string>
    <string name="serviceDisabled" msgid="641878791205871379">"Paslauga išjungta."</string>
    <string name="serviceRegistered" msgid="3856192211729577482">"Registracija sėkminga."</string>
    <string name="serviceErased" msgid="997354043770513494">"Ištrynimas sėkmingas."</string>
    <string name="passwordIncorrect" msgid="917087532676155877">"Neteisingas slaptažodis."</string>
    <string name="mmiComplete" msgid="6341884570892520140">"MMI baigtas."</string>
    <string name="badPin" msgid="888372071306274355">"Įvestas senasis PIN kodas neteisingas."</string>
    <string name="badPuk" msgid="4232069163733147376">"Įvestas PUK kodas neteisingas."</string>
    <string name="mismatchPin" msgid="2929611853228707473">"Įvesti PIN kodai neatitinka."</string>
    <string name="invalidPin" msgid="7542498253319440408">"Įveskite PIN kodą, sudarytą iš 4–8 skaičių."</string>
    <string name="invalidPuk" msgid="8831151490931907083">"Įveskite 8 skaitmenų ar ilgesnį PUK kodą."</string>
    <string name="needPuk" msgid="7321876090152422918">"Jūsų SIM kortelė yra užrakinta PUK kodu. Jei norite ją atrakinti, įveskite PUK kodą."</string>
    <string name="needPuk2" msgid="7032612093451537186">"Įveskite PUK2 kodą, kad panaikintumėte SIM kortelės blokavimą."</string>
    <string name="enablePin" msgid="2543771964137091212">"Nepavyko. Įgalinti SIM / RUIM užraktą."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1619867269012213584">
      <item quantity="one">Liko <xliff:g id="NUMBER_1">%d</xliff:g> bandymas. Tada SIM kortelė bus užrakinta.</item>
      <item quantity="few">Liko <xliff:g id="NUMBER_1">%d</xliff:g> bandymai. Tada SIM kortelė bus užrakinta.</item>
      <item quantity="many">Liko <xliff:g id="NUMBER_1">%d</xliff:g> bandymo. Tada SIM kortelė bus užrakinta.</item>
      <item quantity="other">Liko <xliff:g id="NUMBER_1">%d</xliff:g> bandymų. Tada SIM kortelė bus užrakinta.</item>
    </plurals>
    <string name="imei" msgid="2157082351232630390">"IMEI"</string>
    <string name="meid" msgid="3291227361605924674">"MEID"</string>
    <string name="ClipMmi" msgid="4110549342447630629">"Įeinančio skambintojo ID"</string>
    <string name="ClirMmi" msgid="4702929460236547156">"Išeinančio skambintojo ID"</string>
    <string name="ColpMmi" msgid="4736462893284419302">"Prijungtos eilutės ID"</string>
    <string name="ColrMmi" msgid="5889782479745764278">"Prijungtos eilutės ID apribojimas"</string>
    <string name="CfMmi" msgid="8390012691099787178">"Skambučio peradresavimas"</string>
    <string name="CwMmi" msgid="3164609577675404761">"Laukiantis skambutis"</string>
    <string name="BaMmi" msgid="7205614070543372167">"Skambučio paleidimas"</string>
    <string name="PwdMmi" msgid="3360991257288638281">"Slaptažodžio keitimas"</string>
    <string name="PinMmi" msgid="7133542099618330959">"PIN pakeitimas"</string>
    <string name="CnipMmi" msgid="4897531155968151160">"Skambinimo numeris yra"</string>
    <string name="CnirMmi" msgid="885292039284503036">"Skambinimo numeris apribotas"</string>
    <string name="ThreeWCMmi" msgid="2436550866139999411">"Skambinimas trimis būdais"</string>
    <string name="RuacMmi" msgid="1876047385848991110">"Nepageidaujamų įkyrių skambučių atmetimas"</string>
    <string name="CndMmi" msgid="185136449405618437">"Skambinimo numerio pristatymas"</string>
    <string name="DndMmi" msgid="8797375819689129800">"Netrukdyti"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="4511621022859867988">"Skambintojo ID numatytieji nustatymai apriboti. Kitas skambutis: apribotas"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="5036749051007098105">"Skambintojo ID pagal numatytuosius nustatymus yra apribotas. Kitas skambutis: neapribotas"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="1022781126694885017">"Skambintojo ID pagal numatytuosius nustatymus nustatomas į neapribotą. Kitas skambutis: apribotas"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2491576172356463443">"Skambintojo ID pagal numatytuosius nustatymus yra neapribotas. Kitas skambutis: neapribotas"</string>
    <string name="serviceNotProvisioned" msgid="8289333510236766193">"Paslauga neteikiama."</string>
    <string name="CLIRPermanent" msgid="166443681876381118">"Negalima pakeisti skambinančiojo ID nustatymo."</string>
    <string name="RestrictedOnDataTitle" msgid="1500576417268169774">"Duomenų paslaugos mobiliesiems nėra"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="2852916906106191866">"Skambučių pagalbos numeriu paslaugos nėra"</string>
    <string name="RestrictedOnNormalTitle" msgid="7009474589746551737">"Balso skambučių paslauga neteikiama"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="3982069078579103087">"Balso skambučių arba skambučių pagalbos numeriu paslaugos nėra"</string>
    <string name="RestrictedStateContent" msgid="7693575344608618926">"Laikinai išjungė operatorius"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="5228235722511044687">"SIM kortelėje <xliff:g id="SIMNUMBER">%d</xliff:g> laikinai išjungė operatorius"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="1008329951315753038">"Nepavyko pasiekti mobiliojo ryšio tinklo"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="2086506181486324860">"Pabandykite pakeisti pageidaujamą tinklą. Palieskite, kad pakeistumėte."</string>
    <string name="EmergencyCallWarningTitle" msgid="1615688002899152860">"Skambučių pagalbos numeriu paslauga nepasiekiama"</string>
    <string name="EmergencyCallWarningSummary" msgid="1194185880092805497">"Negalima skambinti pagalbos numeriu naudojant „Wi‑Fi“"</string>
    <string name="notification_channel_network_alert" msgid="4788053066033851841">"Įspėjimai"</string>
    <string name="notification_channel_call_forward" msgid="8230490317314272406">"Skambučio peradresavimas"</string>
    <string name="notification_channel_emergency_callback" msgid="54074839059123159">"Atskambinimo pagalbos numeriu režimas"</string>
    <string name="notification_channel_mobile_data_status" msgid="1941911162076442474">"Mobiliojo ryšio duomenų būsena"</string>
    <string name="notification_channel_sms" msgid="1243384981025535724">"SMS pranešimai"</string>
    <string name="notification_channel_voice_mail" msgid="8457433203106654172">"Balso pašto pranešimai"</string>
    <string name="notification_channel_wfc" msgid="9048240466765169038">"„Wi-Fi“ skambinimas"</string>
    <string name="notification_channel_sim" msgid="5098802350325677490">"SIM būsena"</string>
    <string name="notification_channel_sim_high_prio" msgid="642361929452850928">"Didelio prioriteto SIM kortelės būsena"</string>
    <string name="peerTtyModeFull" msgid="337553730440832160">"Lygiavertis naudotojas pateikė užklausą dėl TTY režimo FULL"</string>
    <string name="peerTtyModeHco" msgid="5626377160840915617">"Lygiavertis naudotojas pateikė užklausą dėl TTY režimo HCO"</string>
    <string name="peerTtyModeVco" msgid="572208600818270944">"Lygiavertis naudotojas pateikė užklausą dėl TTY režimo VCO"</string>
    <string name="peerTtyModeOff" msgid="2420380956369226583">"Lygiavertis naudotojas pateikė užklausą dėl TTY režimo OFF"</string>
    <string name="serviceClassVoice" msgid="2065556932043454987">"„Voice“"</string>
    <string name="serviceClassData" msgid="4148080018967300248">"Duomenys"</string>
    <string name="serviceClassFAX" msgid="2561653371698904118">"FAKSAS"</string>
    <string name="serviceClassSMS" msgid="1547664561704509004">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="2029856900898545984">"Asinchroniški duomenys"</string>
    <string name="serviceClassDataSync" msgid="7895071363569133704">"Sinchronizuoti"</string>
    <string name="serviceClassPacket" msgid="1430642951399303804">"Paketas"</string>
    <string name="serviceClassPAD" msgid="6850244583416306321">"PAD"</string>
    <string name="roamingText0" msgid="7793257871609854208">"Tarptinklinio ryšio rodiklis įjungtas"</string>
    <string name="roamingText1" msgid="5073028598334616445">"Tarptinklinio ryšio rodiklis išjungtas"</string>
    <string name="roamingText2" msgid="2834048284153110598">"Tarptinklinio ryšio rodiklis blyksi"</string>
    <string name="roamingText3" msgid="831690234035748988">"Ne kaimynystėje"</string>
    <string name="roamingText4" msgid="2171252529065590728">"Ne pastate"</string>
    <string name="roamingText5" msgid="4294671587635796641">"Tarptinklinis ryšys – pageidaujama sistema"</string>
    <string name="roamingText6" msgid="5536156746637992029">"Tarptinklinis ryšys – galima sistema"</string>
    <string name="roamingText7" msgid="1783303085512907706">"Tarptinklinis ryšys – sąjungos partneris"</string>
    <string name="roamingText8" msgid="7774800704373721973">"Tarptinklinis ryšys – svarbiausias partneris"</string>
    <string name="roamingText9" msgid="1933460020190244004">"Tarptinklinis ryšys – visos paslaugos funkcijos"</string>
    <string name="roamingText10" msgid="7434767033595769499">"Tarptinklinis ryšys – dalinis paslaugos veikimas"</string>
    <string name="roamingText11" msgid="5245687407203281407">"Tarptinklinio ryšio reklamjuostė įjungta"</string>
    <string name="roamingText12" msgid="673537506362152640">"Tarptinklinio ryšio reklamjuostė išjungta"</string>
    <string name="roamingTextSearching" msgid="5323235489657753486">"Ieškoma paslaugos"</string>
    <string name="wfcRegErrorTitle" msgid="3193072971584858020">"„Wi‑Fi“ skambinimo nustatyti nepavyko"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="468830943567116703">"Jei norite skambinti ir siųsti pranešimus naudodami „Wi-Fi“, pirmiausia paprašykite operatoriaus nustatyti šią paslaugą. Tada vėl įjunkite „Wi-Fi“ skambinimą skiltyje „Nustatymai“. (Klaidos kodas: <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
    <item msgid="4795145070505729156">"Kilo problema registruojant „Wi‑Fi“ skambinimą pas operatorių: <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (2982505428519096311) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="3165949348000906194">"<xliff:g id="SPN">%s</xliff:g> „Wi-Fi“ skambinimas"</string>
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen" msgid="3836827895369365298">"<xliff:g id="SPN">%s</xliff:g> „Wi-Fi“ skambinimas"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="4895315549916165700">"WLAN skambutis"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="255919245825481510">"<xliff:g id="SPN">%s</xliff:g> WLAN skambutis"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="7232899594327126970">"<xliff:g id="SPN">%s</xliff:g> „Wi-Fi“"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="8383917598312067365">"„Wi-Fi“ skambinimas | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="6865214948822061486">"<xliff:g id="SPN">%s</xliff:g> „VoWifi“"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="6178935388378661755">"„Wi-Fi“ skambinimas"</string>
    <string name="wfcSpnFormat_wifi" msgid="1376356951297043426">"Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="7178561009225028264">"„Wi-Fi“ skambinimas"</string>
    <string name="wfcSpnFormat_vowifi" msgid="8371335230890725606">"VoWifi"</string>
    <string name="wifi_calling_off_summary" msgid="5626710010766902560">"Išjungta"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1035175836270943089">"Skambinimas naudojant „Wi-Fi“"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="4958965609212575619">"Skambinimas naudojant mobiliojo ryšio tinklą"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="104951993894678665">"Tik „Wi-Fi“"</string>
    <string name="cfTemplateNotForwarded" msgid="862202427794270501">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: neperadresuota"</string>
    <string name="cfTemplateForwarded" msgid="9132506315842157860">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="735042369233323609">"<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="5619930473441550596">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: neperadresuota"</string>
    <string name="cfTemplateRegisteredTime" msgid="5222794399642525045">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: neperadresuota"</string>
    <string name="fcComplete" msgid="1080909484660507044">"Funkcijos kodas baigtas."</string>
    <string name="fcError" msgid="5325116502080221346">"Ryšio problema arba neteisingas funkcijos kodas."</string>
    <string name="httpErrorOk" msgid="6206751415788256357">"Gerai"</string>
    <string name="httpError" msgid="3406003584150566720">"Įvyko tinklo klaida."</string>
    <string name="httpErrorLookup" msgid="3099834738227549349">"Nepavyko rasti URL."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="3976195595501606787">"Svetainės tapatybės nustatymo schema nepalaikoma."</string>
    <string name="httpErrorAuth" msgid="469553140922938968">"Nepavyko nustatyti tapatybės."</string>
    <string name="httpErrorProxyAuth" msgid="7229662162030113406">"Tapatybės nustatymas naudojant tarpinį serverį buvo nesėkmingas."</string>
    <string name="httpErrorConnect" msgid="3295081579893205617">"Nepavyko prisijungti prie serverio."</string>
    <string name="httpErrorIO" msgid="3860318696166314490">"Nepavyko susisiekti su serveriu. Vėliau bandykite dar kartą."</string>
    <string name="httpErrorTimeout" msgid="7446272815190334204">"Baigėsi ryšio su serveriu laikas."</string>
    <string name="httpErrorRedirectLoop" msgid="8455757777509512098">"Šiame puslapyje yra per daug serverio peradresavimų."</string>
    <string name="httpErrorUnsupportedScheme" msgid="2664108769858966374">"Protokolas nepalaikomas."</string>
    <string name="httpErrorFailedSslHandshake" msgid="546319061228876290">"Nepavyko užmegzti saugaus ryšio."</string>
    <string name="httpErrorBadUrl" msgid="754447723314832538">"Nepavyko atidaryti puslapio, nes URL netinkamas."</string>
    <string name="httpErrorFile" msgid="3400658466057744084">"Nepavyko pasiekti failo."</string>
    <string name="httpErrorFileNotFound" msgid="5191433324871147386">"Nepavyko rasti pageidaujamo failo."</string>
    <string name="httpErrorTooManyRequests" msgid="2149677715552037198">"Apdorojama per daug užklausų. Vėliau bandykite dar kartą."</string>
    <string name="notification_title" msgid="5783748077084481121">"<xliff:g id="ACCOUNT">%1$s</xliff:g> prisijungimo klaida"</string>
    <string name="contentServiceSync" msgid="2341041749565687871">"Sinchronizuoti"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="5766411446676388623">"Sinchronizuoti nepavyko"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4562226280528716090">"Bandoma ištrinti per daug turinio (<xliff:g id="CONTENT_TYPE">%s</xliff:g>)."</string>
    <string name="low_memory" product="tablet" msgid="5557552311566179924">"Planšetinio kompiuterio atmintis pilna. Kad atlaisvintumėte vietos, ištrinkite kelis failus."</string>
    <string name="low_memory" product="watch" msgid="3479447988234030194">"Laikrodžio saugykla pilna. Ištrinkite kelis failus, kad atlaisvintumėte vietos."</string>
    <string name="low_memory" product="tv" msgid="8803524975509826759">"TV saugykla pilna. Ištrinkite kai kuriuos failus, kad atlaisvintumėte vietos."</string>
    <string name="low_memory" product="default" msgid="2539532364144025569">"Telefono atmintis pilna. Ištrinkite kai kuriuos failus, kad atlaisvintumėte vietos."</string>
    <plurals name="ssl_ca_cert_warning" formatted="false" msgid="2288194355006173029">
      <item quantity="one">Sertifikato įgaliojimai įdiegti</item>
      <item quantity="few">Sertifikato įgaliojimai įdiegti</item>
      <item quantity="many">Sertifikato įgaliojimai įdiegti</item>
      <item quantity="other">Sertifikato įgaliojimai įdiegti</item>
    </plurals>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4961102218216815242">"Nežinoma trečioji šalis"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="4564941950768783879">"Darbo profilio administratorius"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="217337232273211674">"<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5891181538182009328">"Darbo profilis ištrintas"</string>
    <string name="work_profile_deleted_details" msgid="3773706828364418016">"Trūksta darbo profilio administratoriaus programos arba ji sugadinta. Todėl darbo profilis ir susiję duomenys buvo ištrinti. Jei reikia pagalbos, susisiekite su administratoriumi."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="2477244968924647232">"Darbo profilis nebepasiekiamas šiame įrenginyje"</string>
    <string name="work_profile_deleted_reason_maximum_password_failure" msgid="1080323158315663167">"Per daug slaptažodžio bandymų"</string>
    <string name="network_logging_notification_title" msgid="554983187553845004">"Įrenginys yra tvarkomas"</string>
    <string name="network_logging_notification_text" msgid="1327373071132562512">"Šį įrenginį tvarko organizacija ir gali stebėti tinklo srautą. Palieskite, kad gautumėte daugiau informacijos."</string>
    <string name="factory_reset_warning" msgid="6858705527798047809">"Įrenginys bus ištrintas"</string>
    <string name="factory_reset_message" msgid="2657049595153992213">"Administratoriaus programos negalima naudoti. Dabar įrenginio duomenys bus ištrinti.\n\nJei turite klausimų, susisiekite su organizacijos administratoriumi."</string>
    <string name="printing_disabled_by" msgid="3517499806528864633">"Neleidžiama spausdinti (<xliff:g id="OWNER_APP">%s</xliff:g>)."</string>
    <string name="me" msgid="6207584824693813140">"Aš"</string>
    <string name="power_dialog" product="tablet" msgid="8333207765671417261">"Planšetinio kompiuterio parinktys"</string>
    <string name="power_dialog" product="tv" msgid="5941745051236770764">"TV parinktys"</string>
    <string name="power_dialog" product="default" msgid="1107775420270203046">"Telefono parinktys"</string>
    <string name="silent_mode" msgid="8796112363642579333">"Tylus režimas"</string>
    <string name="turn_on_radio" msgid="2961717788170634233">"Įjungti bevielį"</string>
    <string name="turn_off_radio" msgid="7222573978109933360">"Išjungti bevielį"</string>
    <string name="screen_lock" msgid="2072642720826409809">"Ekrano užraktas"</string>
    <string name="power_off" msgid="4111692782492232778">"Išjungiamas maitinimas"</string>
    <string name="silent_mode_silent" msgid="5079789070221150912">"Skambutis išjungtas"</string>
    <string name="silent_mode_vibrate" msgid="8821830448369552678">"Vibracija skambinant"</string>
    <string name="silent_mode_ring" msgid="6039011004781526678">"Skambutis įjungtas"</string>
    <string name="reboot_to_update_title" msgid="2125818841916373708">"„Android“ sistemos naujinys"</string>
    <string name="reboot_to_update_prepare" msgid="6978842143587422365">"Ruošiamasi atnaujinti…"</string>
    <string name="reboot_to_update_package" msgid="4644104795527534811">"Apdorojamas naujinio paketas…"</string>
    <string name="reboot_to_update_reboot" msgid="4474726009984452312">"Paleidžiama iš naujo…"</string>
    <string name="reboot_to_reset_title" msgid="2226229680017882787">"Gamyklinių duomenų atkūrimas"</string>
    <string name="reboot_to_reset_message" msgid="3347690497972074356">"Paleidžiama iš naujo…"</string>
    <string name="shutdown_progress" msgid="5017145516412657345">"Išsijungia..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="2872769463279602432">"Planšetinio kompiuterio veikimas bus sustabdytas."</string>
    <string name="shutdown_confirm" product="tv" msgid="9187068694573722129">"TV bus išjungtas."</string>
    <string name="shutdown_confirm" product="watch" msgid="2977299851200240146">"Laikrodis išsijungs."</string>
    <string name="shutdown_confirm" product="default" msgid="136816458966692315">"Telefonas bus išjungtas."</string>
    <string name="shutdown_confirm_question" msgid="796151167261608447">"Ar norite išjungti?"</string>
    <string name="reboot_safemode_title" msgid="5853949122655346734">"Iš naujo įkelti operacinę sistemą saugos režimu"</string>
    <string name="reboot_safemode_confirm" msgid="1658357874737219624">"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="8183172372995396653">"Naujos"</string>
    <string name="no_recent_tasks" msgid="9063946524312275906">"Nėra naujausių programų."</string>
    <string name="global_actions" product="tablet" msgid="4412132498517933867">"Planšetinio kompiuterio parinktys"</string>
    <string name="global_actions" product="tv" msgid="2020669784083287370">"TV parinktys"</string>
    <string name="global_actions" product="default" msgid="6410072189971495460">"Telefono parinktys"</string>
    <string name="global_action_lock" msgid="6949357274257655383">"Ekrano užraktas"</string>
    <string name="global_action_power_off" msgid="4404936470711393203">"Išjungiamas maitinimas"</string>
    <string name="global_action_emergency" msgid="1387617624177105088">"Skambutis pagalbos numeriu"</string>
    <string name="global_action_bug_report" msgid="5127867163044170003">"Pranešimas apie riktą"</string>
    <string name="global_action_logout" msgid="6093581310002476511">"Baigti seansą"</string>
    <string name="global_action_screenshot" msgid="2610053466156478564">"Ekrano kopija"</string>
    <string name="bugreport_title" msgid="8549990811777373050">"Pranešim. apie riktą"</string>
    <string name="bugreport_message" msgid="5212529146119624326">"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 riktą bus paruoštas siųsti; būkite kantrūs."</string>
    <string name="bugreport_option_interactive_title" msgid="7968287837902871289">"Interakt. ataskaita"</string>
    <string name="bugreport_option_interactive_summary" msgid="8493795476325339542">"Naudokite tai esant daugumai aplinkybių. Galite stebėti ataskaitos eigą, įvesti daugiau išsamios informacijos apie problemą ir padaryti ekrano kopijų. Gali būti praleidžiamos kelios rečiau naudojamos skiltys, kurių ataskaitų teikimas ilgai trunka."</string>
    <string name="bugreport_option_full_title" msgid="7681035745950045690">"Išsami ataskaita"</string>
    <string name="bugreport_option_full_summary" msgid="1975130009258435885">"Naudokite šią parinktį, kad sistemos veikimas būtų kuo mažiau trikdomas, kai įrenginys nereaguoja ar yra per lėtas arba kai jums reikia visų ataskaitos skilčių. Negalėsite įvesti daugiau išsamios informacijos ar padaryti papildomų ekrano kopijų."</string>
    <plurals name="bugreport_countdown" formatted="false" msgid="3906120379260059206">
      <item quantity="one">Pranešimo apie riktą ekrano kopija bus užfiksuota po <xliff:g id="NUMBER_1">%d</xliff:g> sekundės.</item>
      <item quantity="few">Pranešimo apie riktą ekrano kopija bus užfiksuota po <xliff:g id="NUMBER_1">%d</xliff:g> sekundžių.</item>
      <item quantity="many">Pranešimo apie riktą ekrano kopija bus užfiksuota po <xliff:g id="NUMBER_1">%d</xliff:g> sekundės.</item>
      <item quantity="other">Pranešimo apie riktą ekrano kopija bus užfiksuota po <xliff:g id="NUMBER_1">%d</xliff:g> sekundžių.</item>
    </plurals>
    <string name="global_action_toggle_silent_mode" msgid="8464352592860372188">"Tylus režimas"</string>
    <string name="global_action_silent_mode_on_status" msgid="2371892537738632013">"Garsas IŠJUNGTAS"</string>
    <string name="global_action_silent_mode_off_status" msgid="6608006545950920042">"Garsas ĮJUNGTAS"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="6911684460146916206">"Lėktuvo režimas"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="5508025516695361936">"ĮJUNGTAS lėktuvo režimas"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="8522219771500505475">"lėktuvo režimas IŠJUNGTAS"</string>
    <string name="global_action_settings" msgid="4671878836947494217">"Nustatymai"</string>
    <string name="global_action_assist" msgid="2517047220311505805">"Pagalba"</string>
    <string name="global_action_voice_assist" msgid="6655788068555086695">"Voice Assist"</string>
    <string name="global_action_lockdown" msgid="2475471405907902963">"Užrakinimas"</string>
    <string name="status_bar_notification_info_overflow" msgid="3330152558746563475">"999+"</string>
    <string name="notification_hidden_text" msgid="2835519769868187223">"Naujas pranešimas"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6465975799223304567">"Virtualioji klaviatūra"</string>
    <string name="notification_channel_physical_keyboard" msgid="5417306456125988096">"Fizinė klaviatūra"</string>
    <string name="notification_channel_security" msgid="8516754650348238057">"Sauga"</string>
    <string name="notification_channel_car_mode" msgid="2123919247040988436">"Automobilio režimas"</string>
    <string name="notification_channel_account" msgid="6436294521740148173">"Paskyros būsena"</string>
    <string name="notification_channel_developer" msgid="1691059964407549150">"Kūrėjų pranešimai"</string>
    <string name="notification_channel_updates" msgid="7907863984825495278">"Naujiniai"</string>
    <string name="notification_channel_network_status" msgid="2127687368725272809">"Tinklo būsena"</string>
    <string name="notification_channel_network_alerts" msgid="6312366315654526528">"Tinklo įspėjimai"</string>
    <string name="notification_channel_network_available" msgid="6083697929214165169">"Tinklas pasiekiamas"</string>
    <string name="notification_channel_vpn" msgid="1628529026203808999">"VPN būsena"</string>
    <string name="notification_channel_device_admin" msgid="6384932669406095506">"IT administratoriaus įspėjimai"</string>
    <string name="notification_channel_alerts" msgid="5070241039583668427">"Įspėjimai"</string>
    <string name="notification_channel_retail_mode" msgid="3732239154256431213">"Demonstracinė versija mažmenininkams"</string>
    <string name="notification_channel_usb" msgid="1528280969406244896">"USB jungtis"</string>
    <string name="notification_channel_heavy_weight_app" msgid="17455756500828043">"Programa paleista"</string>
    <string name="notification_channel_foreground_service" msgid="7102189948158885178">"Programos, naudojančios akumuliatoriaus energiją"</string>
    <string name="foreground_service_app_in_background" msgid="1439289699671273555">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ naudoja akumuliatoriaus energiją"</string>
    <string name="foreground_service_apps_in_background" msgid="7340037176412387863">"Programų, naudojančių akumuliatoriaus energiją: <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="foreground_service_tap_for_details" msgid="9078123626015586751">"Palieskite ir sužinokite išsamios informacijos apie akumuliatoriaus bei duomenų naudojimą"</string>
    <string name="foreground_service_multiple_separator" msgid="5002287361849863168">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="8974401416068943888">"Saugos režimas"</string>
    <string name="android_system_label" msgid="5974767339591067210">"„Android“ sistema"</string>
    <string name="user_owner_label" msgid="8628726904184471211">"Perjungti į asmeninį profilį"</string>
    <string name="managed_profile_label" msgid="7316778766973512382">"Perjungti į darbo profilį"</string>
    <string name="permgrouplab_contacts" msgid="4254143639307316920">"Kontaktai"</string>
    <string name="permgroupdesc_contacts" msgid="9163927941244182567">"pasiekti kontaktus"</string>
    <string name="permgrouprequest_contacts" msgid="7755354139254094668">"Suteikti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; galimybę pasiekti kontaktus?"</string>
    <string name="permgrouplab_location" msgid="1858277002233964394">"Vietovė"</string>
    <string name="permgroupdesc_location" msgid="1995955142118450685">"pasiekti įrenginio vietovės informaciją"</string>
    <string name="permgrouprequest_location" msgid="5261379525646615507">"Suteikti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; galimybę pasiekti įrenginio vietovę?"</string>
    <string name="permgrouprequestdetail_location" msgid="8223089637855613805">"Programa galės pasiekti vietovę, tik kai ją naudosite"</string>
    <string name="permgroupbackgroundrequest_location" msgid="534202103935528927">"Leisti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; pasiekti šio įrenginio vietovę &lt;b&gt;visą laiką&lt;/b&gt;?"</string>
    <string name="permgroupbackgroundrequestdetail_location" msgid="5230541171285233536">"Šiuo metu programa gali pasiekti vietovę, tik kai ją naudojate"</string>
    <string name="permgrouplab_calendar" msgid="6426860926123033230">"Kalendorius"</string>
    <string name="permgroupdesc_calendar" msgid="6762751063361489379">"pasiekti kalendorių"</string>
    <string name="permgrouprequest_calendar" msgid="2680538977344557840">"Suteikti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; galimybę pasiekti kalendorių?"</string>
    <string name="permgrouplab_sms" msgid="795737735126084874">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="5726462398070064542">"siųsti ir peržiūrėti SMS pranešimus"</string>
    <string name="permgrouprequest_sms" msgid="3985338150822482831">"Leisti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; siųsti ir peržiūrėti SMS pranešimus?"</string>
    <string name="permgrouplab_storage" msgid="1121695277384787841">"Saugykla"</string>
    <string name="permgroupdesc_storage" msgid="6351503740613026600">"pasiekti nuotraukas, mediją ir failus įrenginyje"</string>
    <string name="permgrouprequest_storage" msgid="1594774620878445266">"Suteikti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; galimybę pasiekti įrenginio nuotraukas, mediją ir failus?"</string>
    <string name="permgrouplab_microphone" msgid="2480597427667420076">"Mikrofonas"</string>
    <string name="permgroupdesc_microphone" msgid="1047786732792487722">"įrašyti garso įrašą"</string>
    <string name="permgrouprequest_microphone" msgid="4942966684471718126">"Leisti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; įrašyti garsą?"</string>
    <string name="permgrouplab_activityRecognition" msgid="3324466667921775766">"Fizinė veikla"</string>
    <string name="permgroupdesc_activityRecognition" msgid="4725624819457670704">"galimybė pasiekti fizinę veiklą"</string>
    <string name="permgrouprequest_activityRecognition" msgid="693328554262727556">"Leisti programai &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; pasiekti fizinės veiklos duomenis?"</string>
    <string name="permgrouplab_camera" msgid="9090413408963547706">"Fotoaparatas"</string>
    <string name="permgroupdesc_camera" msgid="7585150538459320326">"fotografuoti ir filmuoti"</string>
    <string name="permgrouprequest_camera" msgid="2697305443703328372">"Leisti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; fotografuoti ir įrašyti vaizdo įrašus?"</string>
    <string name="permgrouplab_calllog" msgid="7926834372073550288">"Skambučių žurnalai"</string>
    <string name="permgroupdesc_calllog" msgid="2026996642917801803">"skaityti ir rašyti telefono skambučių žurnalą"</string>
    <string name="permgrouprequest_calllog" msgid="7565344038959817408">"Leisti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; pasiekti jūsų telefono skambučių žurnalus?"</string>
    <string name="permgrouplab_phone" msgid="570318944091926620">"Telefonas"</string>
    <string name="permgroupdesc_phone" msgid="270048070781478204">"skambinti ir tvarkyti telefonų skambučius"</string>
    <string name="permgrouprequest_phone" msgid="6430085454721364373">"Leisti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; skambinti ir tvarkyti telefono skambučius?"</string>
    <string name="permgrouplab_sensors" msgid="9134046949784064495">"Kūno jutikliai"</string>
    <string name="permgroupdesc_sensors" msgid="2610631290633747752">"pasiekti jutiklių duomenis apie gyvybinius ženklus"</string>
    <string name="permgrouprequest_sensors" msgid="2431000833343586816">"Suteikti &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; galimybę pasiekti jutiklių duomenis apie gyvybinius ženklus?"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="7554282892101587296">"Gauti lango turinį"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="6195610527625237661">"Tikrinti lango, su kuriuo sąveikaujate, turinį."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="327598364696316213">"Įjungti „Naršyti paliečiant“"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="4394677060796752976">"Paliesti elementai bus ištariami garsiai. Be to, ekrane gali būti naršoma naudojant gestus."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2772371671541753254">"Stebėti jūsų įvedamą tekstą"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="2381315802405773092">"Įtraukiami asmeniniai duomenys, pavyzdžiui, kredito kortelių numeriai ir slaptažodžiai."</string>
    <string name="capability_title_canControlMagnification" msgid="7701572187333415795">"Valdyti ekrano didinimą"</string>
    <string name="capability_desc_canControlMagnification" msgid="2206586716709254805">"Valdyti ekrano mastelio keitimo lygį ir pozicijos nustatymą."</string>
    <string name="capability_title_canPerformGestures" msgid="9106545062106728987">"Veiksmai gestais"</string>
    <string name="capability_desc_canPerformGestures" msgid="6619457251067929726">"Galima paliesti, perbraukti, suimti ir atlikti kitus veiksmus gestais."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="1189053104594608091">"Piršto antspaudo gestai"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="6861869337457461274">"Gali užfiksuoti gestus, atliktus naudojant įrenginio piršto antspaudo jutiklį."</string>
    <string name="permlab_statusBar" msgid="8798267849526214017">"išjungti ar keisti būsenos juostą"</string>
    <string name="permdesc_statusBar" msgid="5809162768651019642">"Leidžiama programai neleisti būsenos juostos arba pridėti ir pašalinti sistemos piktogramas."</string>
    <string name="permlab_statusBarService" msgid="2523421018081437981">"būti būsenos juosta"</string>
    <string name="permdesc_statusBarService" msgid="6652917399085712557">"Leidžiama programai būti būsenos juosta."</string>
    <string name="permlab_expandStatusBar" msgid="1184232794782141698">"išskleisti / sutraukti būsenos juostą"</string>
    <string name="permdesc_expandStatusBar" msgid="7180756900448498536">"Leidžiama programai išskleisti arba sutraukti būsenos juostą."</string>
    <string name="permlab_install_shortcut" msgid="7451554307502256221">"įdiegti sparčiuosius klavišus"</string>
    <string name="permdesc_install_shortcut" msgid="4476328467240212503">"Programai leidžiama pridėti sparčiuosius klavišus prie pagrindinio ekrano be naudotojo įsikišimo."</string>
    <string name="permlab_uninstall_shortcut" msgid="295263654781900390">"pašalinti sparčiuosius klavišus"</string>
    <string name="permdesc_uninstall_shortcut" msgid="1924735350988629188">"Programai leidžiama pašalinti sparčiuosius klavišus iš pagrindinio ekrano be naudotojo įsikišimo."</string>
    <string name="permlab_processOutgoingCalls" msgid="4075056020714266558">"peradresuoti išsiunčiamuosius skambučius"</string>
    <string name="permdesc_processOutgoingCalls" msgid="7833149750590606334">"Leidžiama programai peržiūrėti renkamą numerį siunčiamojo skambučio metu suteikiant galimybę peradresuoti skambutį kitu numeriu arba visiškai nutraukti skambutį."</string>
    <string name="permlab_answerPhoneCalls" msgid="4131324833663725855">"atsakyti į telefonų skambučius"</string>
    <string name="permdesc_answerPhoneCalls" msgid="894386681983116838">"Programai leidžiama atsakyti į gaunamąjį telefono skambutį."</string>
    <string name="permlab_receiveSms" msgid="505961632050451881">"gauti teksto pranešimus (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="1797345626687832285">"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="4000650116674380275">"gauti teksto pranešimus (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="958102423732219710">"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_readCellBroadcasts" msgid="5869884450872137693">"skaityti mobiliuoju transliuojamus pranešimus"</string>
    <string name="permdesc_readCellBroadcasts" msgid="672513437331980168">"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_subscribedFeedsRead" msgid="217624769238425461">"skaityti prenumeruojamus tiekimus"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="6911349196661811865">"Leidžiama programai gauti išsamios informacijos apie šiuo metu sinchronizuojamus sklaidos kanalus."</string>
    <string name="permlab_sendSms" msgid="7757368721742014252">"siųsti ir peržiūrėti SMS pranešimus"</string>
    <string name="permdesc_sendSms" msgid="6757089798435130769">"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_readSms" msgid="5164176626258800297">"skaityti teksto pranešimus (SMS arba MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="7912990447198112829">"Ši programa gali nuskaityti visus planšetiniame kompiuteryje saugomus SMS (teksto) pranešimus."</string>
    <string name="permdesc_readSms" product="tv" msgid="8967963387951154530">"Ši programa gali nuskaityti visus TV saugomus SMS (teksto) pranešimus."</string>
    <string name="permdesc_readSms" product="default" msgid="774753371111699782">"Ši programa gali nuskaityti visus telefone saugomus SMS (teksto) pranešimus."</string>
    <string name="permlab_receiveWapPush" msgid="4223747702856929056">"gauti teksto pranešimus (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="1638677888301778457">"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="7460048811831750262">"nuskaityti vykdomas programas"</string>
    <string name="permdesc_getTasks" msgid="7388138607018233726">"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_manageProfileAndDeviceOwners" msgid="639849495253987493">"tvarkyti profilio ir įrenginio savininkus"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="7304240671781989283">"Leisti programai nustatyti profilio savininkus ir įrenginio savininką."</string>
    <string name="permlab_reorderTasks" msgid="7598562301992923804">"pertvarkyti vykdomas programas"</string>
    <string name="permdesc_reorderTasks" msgid="8796089937352344183">"Leidžiama programai perkelti užduotis į priekinį planą ir foną. Programa gali tai daryti be jūsų įsikišimo."</string>
    <string name="permlab_enableCarMode" msgid="893019409519325311">"įgalinti automobilio režimą"</string>
    <string name="permdesc_enableCarMode" msgid="56419168820473508">"Leidžiama programai įgalinti automobilio režimą."</string>
    <string name="permlab_killBackgroundProcesses" msgid="6559320515561928348">"uždaryti kitas programas"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="2357013583055434685">"Leidžiama programai baigti kitų programų fone vykdomus procesus. Dėl to gali būti sustabdytos kitos programos."</string>
    <string name="permlab_systemAlertWindow" msgid="5757218350944719065">"Ši programa gali būti rodoma virš kitų programų"</string>
    <string name="permdesc_systemAlertWindow" msgid="1145660714855738308">"Ši programa gali būti rodoma virš kitų programų arba kitų ekrano sričių. Tai gali trukdyti įprastai naudoti programas ir pakeisti kitų programų rodymo būdą."</string>
    <string name="permlab_runInBackground" msgid="541863968571682785">"vykdyti fone"</string>
    <string name="permdesc_runInBackground" msgid="4344539472115495141">"Ši programa gali būti vykdoma fone. Dėl to akumuliatorius gali būti greičiau išeikvojamas."</string>
    <string name="permlab_useDataInBackground" msgid="783415807623038947">"naudoti duomenis fone"</string>
    <string name="permdesc_useDataInBackground" msgid="1230753883865891987">"Ši programa gali naudoti duomenis fone. Dėl to gali būti sunaudojama daugiau duomenų."</string>
    <string name="permlab_persistentActivity" msgid="464970041740567970">"nustatyti, kad programa būtų visada vykdoma"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="6055271149187369916">"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="tv" msgid="2616944406357387366">"Programai leidžiama nustatyti, kad tam tikros jos dalys nuolat išliktų atmintyje. Dėl to gali sumažėti kitoms programoms pasiekiamos atminties ir sulėtėti TV."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="1914841924366562051">"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_foregroundService" msgid="1768855976818467491">"vykdyti priekiniame plane veikiančią paslaugą"</string>
    <string name="permdesc_foregroundService" msgid="8720071450020922795">"Programai leidžiama naudoti priekiniame plane veikiančias paslaugas."</string>
    <string name="permlab_getPackageSize" msgid="375391550792886641">"matuoti programos atmintinės vietą"</string>
    <string name="permdesc_getPackageSize" msgid="742743530909966782">"Leidžiama programai nuskaityti kodą, duomenis ir talpykloje saugoti dydžius"</string>
    <string name="permlab_writeSettings" msgid="8057285063719277394">"keisti sistemos nustatymus"</string>
    <string name="permdesc_writeSettings" msgid="8293047411196067188">"Leidžiama programai keisti sistemos nustatymų duomenis. Kenkėjiškos programos gali sugadinti jūsų sistemos konfigūraciją."</string>
    <string name="permlab_receiveBootCompleted" msgid="6643339400247325379">"paleisti paleidžiant"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="5565659082718177484">"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="tv" msgid="2701244540810970401">"Programai leidžiama nustatyti, kad ji būtų paleidžiama iškart baigus paleisti sistemą. Taip gali ilgiau užtrukti TV paleidimas, o programa gali sulėtinti visą planšetinio kompiuterio sistemą, nes ji visada veikia."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="7912677044558690092">"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="4552241916400572230">"siųsti pritraukiantį perdavimą"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="5058486069846384013">"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="tv" msgid="4148011273011857829">"Programai leidžiama siųsti fiksuojamąsias transliacijas, kurios išlieka pasiekiamos pasibaigus transliacijai. Dėl per didelio naudojimo TV gali veikti lėtai arba nestabiliai, nes naudojama per daug atminties."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="134529339678913453">"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="8776395111787429099">"skaityti kontaktus"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="80783131858366692">"Programai leidžiama skaityti duomenis apie planšetiniame kompiuteryje saugomus kontaktus. Š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="tv" msgid="4930202526885367788">"Programai leidžiama skaityti duomenis apie televizoriuje saugomus kontaktus. Š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="6808717801527690363">"Programai leidžiama skaityti duomenis apie telefone saugomus kontaktus. Š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="8919430536404830430">"keisti kontaktus"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="6422419281427826181">"Programai leidžiama keisti duomenis apie planšetiniame kompiuteryje saugomus kontaktus. Su šiuo leidimu programos gali ištrinti kontaktinius duomenis."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="7554829984159606156">"Programai leidžiama keisti duomenis apie televizoriuje saugomus kontaktus. Su šiuo leidimu programos gali ištrinti kontaktinius duomenis."</string>
    <string name="permdesc_writeContacts" product="default" msgid="8304795696237065281">"Programai leidžiama keisti duomenis apie telefone saugomus kontaktus. Su šiuo leidimu programos gali ištrinti kontaktinius duomenis."</string>
    <string name="permlab_readCallLog" msgid="1739990210293505948">"skaityti skambučių žurnalą"</string>
    <string name="permdesc_readCallLog" msgid="8964770895425873433">"Ši programa gali nuskaityti skambučių istoriją."</string>
    <string name="permlab_writeCallLog" msgid="670292975137658895">"rašyti skambučių žurnalą"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="2657525794731690397">"Programai leidžiama skaityti planšetinio kompiuterio skambučių žurnalą, įskaitant duomenis apie gaunamuosius ir siunčiamuosius 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="tv" msgid="220754624705969171">"Programai leidžiama keisti TV skambučių žurnalą, įskaitant duomenis apie gaunamuosius ir siunčiamuosius skambučius. Taip kenkėjiškos programos gali ištrinti arba pakeisti skambučių žurnalą."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="5903033505665134802">"Programai leidžiama skaityti telefono skambučių žurnalą, įskaitant duomenis apie gaunamuosius ir siunčiamuosius skambučius. Kenkėjiškos programos tai gali naudoti, kad ištrintų ar keistų jūsų skambučių žurnalą."</string>
    <string name="permlab_bodySensors" msgid="3411035315357380862">"pas. k. jut. (pvz., pul. dažn. st. įr.)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="2365357960407973997">"Programai leidžiama pasiekti duomenis, gautus iš jutiklių, stebinčių fizinę būseną, pvz., širdies ritmą."</string>
    <string name="permlab_readCalendar" msgid="6408654259475396200">"Skaityti kalendoriaus įvykius arba išsamią informaciją"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="515452384059803326">"Ši programa gali nuskaityti visus planšetiniame kompiuteryje saugomus kalendoriaus įvykius ir bendrinti arba išsaugoti kalendoriaus duomenis."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="4359404686228921749">"Ši programa gali nuskaityti visus TV saugomus kalendoriaus įvykius ir bendrinti arba išsaugoti kalendoriaus duomenis."</string>
    <string name="permdesc_readCalendar" product="default" msgid="9118823807655829957">"Ši programa gali nuskaityti visus telefone saugomus kalendoriaus įvykius ir bendrinti arba išsaugoti kalendoriaus duomenis."</string>
    <string name="permlab_writeCalendar" msgid="6422137308329578076">"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="8722230940717092850">"Ši programa gali pridėti, pašalinti arba pakeisti planšetiniame kompiuteryje esančius kalendoriaus įvykius. Ši programa gali siųsti pranešimus, kurie gali atrodyti atsiųsti kalendoriaus savininkų, arba pakeisti įvykius nepranešusi jų savininkams."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="6841397610226826926">"Ši programa gali pridėti, pašalinti arba pakeisti TV esančius kalendoriaus įvykius. Ši programa gali siųsti pranešimus, kurie atrodys atsiųsti kalendoriaus savininkų, arba pakeisti įvykius nepranešusi jų savininkams."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="5416380074475634233">"Ši programa gali pridėti, pašalinti arba pakeisti telefone esančius kalendoriaus įvykius. Ši programa gali siųsti pranešimus, kurie atrodys atsiųsti kalendoriaus savininkų, arba pakeisti įvykius nepranešusi jų savininkams."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="5162339812057983988">"pasiekti papildomas vietos teikimo įrankio komandas"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="355369611979907967">"Programai leidžiama pasiekti papildomas vietovės nustatymo paslaugų teikėjų komandas. Dėl to programa gali trukdyti veikti GPS ar kitiems vietovės nustatymo šaltiniams."</string>
    <string name="permlab_accessFineLocation" msgid="6426318438195622966">"pasiekti tikslią vietovę, tik kai programa veikia priekiniame plane"</string>
    <string name="permdesc_accessFineLocation" msgid="3056141052532120237">"Ši programa gali gauti tikslius jūsų vietovės duomenis bet kuriuo metu, kai veikia priekiniame plane. Šios vietovės paslaugos turi būti įjungtos ir pasiekiamos telefone, kad programa galėtų jas naudoti. Tai gali padidinti akumuliatoriaus energijos suvartojimą."</string>
    <string name="permlab_accessCoarseLocation" msgid="8215351553392299056">"pasiekti apytikslę vietovę (pagal tinklo duomenis), tik kai programa veikia priekiniame plane"</string>
    <string name="permdesc_accessCoarseLocation" product="tablet" msgid="7479449026750078899">"Ši programa gali gauti jūsų vietos informaciją naudodamasi tinklo šaltinių, pvz., mobiliojo ryšio bokštų ir „Wi-Fi“ tinklų, duomenimis, bet tik kai ji yra naudojama priekiniame plane. Šios vietovės paslaugos turi būti įjungtos ir pasiekiamos planšetiniame kompiuteryje, kad programa galėtų jas naudoti."</string>
    <string name="permdesc_accessCoarseLocation" product="tv" msgid="1912601926375190585">"Ši programa gali gauti jūsų vietos informaciją naudodamasi tinklo šaltinių, pvz., mobiliojo ryšio bokštų ir „Wi-Fi“ tinklų, duomenimis, bet tik kai ji yra naudojama priekiniame plane. Šios vietovės paslaugos turi būti įjungtos ir pasiekiamos TV, kad programa galėtų jas naudoti."</string>
    <string name="permdesc_accessCoarseLocation" product="automotive" msgid="2154996109427085674">"Ši programa gali gauti apytikslius jūsų vietovės duomenis, tik kai veikia priekiniame plane. Šios vietovės paslaugos turi būti įjungtos ir pasiekiamos automobilyje, kad programa galėtų jas naudoti."</string>
    <string name="permdesc_accessCoarseLocation" product="default" msgid="8962998102400124341">"Ši programa gali gauti jūsų vietos informaciją naudodamasi tinklo šaltinių, pvz., mobiliojo ryšio bokštų ir „Wi-Fi“ tinklų, duomenimis, bet tik kai ji yra naudojama priekiniame plane. Šios vietovės paslaugos turi būti įjungtos ir pasiekiamos telefone, kad programa galėtų jas naudoti."</string>
    <string name="permlab_accessBackgroundLocation" msgid="1721164702777366138">"prieiga prie vietovės fone"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="6904788108073882096">"Jei papildomai suteikiama prieiga prie apytikslės arba tikslios vietovės, programa gali pasiekti vietovės duomenis veikdama fone."</string>
    <string name="permlab_modifyAudioSettings" msgid="6129039778010031815">"keisti garso nustatymus"</string>
    <string name="permdesc_modifyAudioSettings" msgid="8687227609663124921">"Leidžiama programai keisti visuotinius garso nustatymus, pvz., garsumą ir tai, kuris garsiakalbis naudojamas išvesčiai."</string>
    <string name="permlab_recordAudio" msgid="1208457423054219147">"įrašyti garsą"</string>
    <string name="permdesc_recordAudio" msgid="3976213377904701093">"Ši programa gali bet kada įrašyti garsą naudodama mikrofoną."</string>
    <string name="permlab_sim_communication" msgid="176788115994050692">"siųsti komandas į SIM kortelę"</string>
    <string name="permdesc_sim_communication" msgid="4179799296415957960">"Programai leidžiama siųsti komandas į SIM kortelę. Tai labai pavojinga."</string>
    <string name="permlab_activityRecognition" msgid="1782303296053990884">"atpažinti fizinę veiklą"</string>
    <string name="permdesc_activityRecognition" msgid="8667484762991357519">"Ši programa gali atpažinti jūsų fizinę veiklą."</string>
    <string name="permlab_camera" msgid="6320282492904119413">"fotografuoti ir filmuoti"</string>
    <string name="permdesc_camera" msgid="1354600178048761499">"Ši programa gali bet kada fotografuoti ir įrašyti vaizdo įrašų naudodama fotoaparatą."</string>
    <string name="permlab_vibrate" msgid="8596800035791962017">"valdyti vibraciją"</string>
    <string name="permdesc_vibrate" msgid="8733343234582083721">"Leidžiama programai valdyti vibravimą."</string>
    <string name="permlab_callPhone" msgid="1798582257194643320">"skambinti tiesiogiai telefono numeriais"</string>
    <string name="permdesc_callPhone" msgid="5439809516131609109">"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_accessImsCallService" msgid="442192920714863782">"pasiekti IMS skambučių paslaugą"</string>
    <string name="permdesc_accessImsCallService" msgid="6328551241649687162">"Programai leidžiama naudoti IMS paslaugą, kad būtų galima atlikti skambučius be jūsų įsikišimo."</string>
    <string name="permlab_readPhoneState" msgid="8138526903259297969">"skaityti telefono būseną ir tapatybę"</string>
    <string name="permdesc_readPhoneState" msgid="7229063553502788058">"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_manageOwnCalls" msgid="9033349060307561370">"nukreipti skambučius per sistemą"</string>
    <string name="permdesc_manageOwnCalls" msgid="4431178362202142574">"Programai leidžiama nukreipti jos skambučius per sistemą siekiant pagerinti skambinimo paslaugas."</string>
    <string name="permlab_callCompanionApp" msgid="3654373653014126884">"matyti ir valdyti skambučius per sistemą."</string>
    <string name="permdesc_callCompanionApp" msgid="8474168926184156261">"Programai leidžiama matyti ir valdyti vykstančius skambučius įrenginyje. Tai apima tokią informaciją kaip skambučių telefono numeriai ir skambučių būsena."</string>
    <string name="permlab_acceptHandover" msgid="2925523073573116523">"tęsti skambutį naudojant kitą programą"</string>
    <string name="permdesc_acceptHandovers" msgid="7129026180128626870">"Programai leidžiama tęsti skambutį, kuris buvo pradėtas naudojant kitą programą."</string>
    <string name="permlab_readPhoneNumbers" msgid="5668704794723365628">"skaityti telefonų numerius"</string>
    <string name="permdesc_readPhoneNumbers" msgid="7368652482818338871">"Programai leidžiama pasiekti įrenginio telefonų numerius."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1527660973931694000">"neleisti planšetiniam kompiuteriui užmigti"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2597122827869353116">"neleisti įjungti TV miego būsenos"</string>
    <string name="permlab_wakeLock" product="default" msgid="569409726861695115">"neleisti telefonui snausti"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="2441742939101526277">"Leidžiama programai neleisti planšetiniam kompiuteriui užmigti."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="7562330010764851191">"Programai leidžiama nustatyti, kad TV nebūtų perjungtas į miego būseną."</string>
    <string name="permdesc_wakeLock" product="default" msgid="3689523792074007163">"Leidžiama programai neleisti telefonui užmigti."</string>
    <string name="permlab_transmitIr" msgid="8077196086358004010">"perduoti duomenis infraraudonaisiais spinduliais"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5884738958581810253">"Programai leidžiama naudoti planšetinio kompiuterio infraraudonųjų spindulių perdavimo įrenginį."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="4453220932790148184">"Programai leidžiama naudoti TV infraraudonųjų spindulių siųstuvą."</string>
    <string name="permdesc_transmitIr" product="default" msgid="8484193849295581808">"Programai leidžiama naudoti telefono infraraudonųjų spindulių perdavimo įrenginį."</string>
    <string name="permlab_setWallpaper" msgid="6959514622698794511">"nustatyti darbalaukio foną"</string>
    <string name="permdesc_setWallpaper" msgid="2973996714129021397">"Leidžiama programai nustatyti sistemos darbalaukio foną."</string>
    <string name="permlab_setWallpaperHints" msgid="1153485176642032714">"keisti ekrano fono dydį"</string>
    <string name="permdesc_setWallpaperHints" msgid="6257053376990044668">"Leidžiama programai nustatyti sistemos darbalaukio fono dydžio užuominas."</string>
    <string name="permlab_setTimeZone" msgid="7922618798611542432">"nustatyti laiko zoną"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1788868809638682503">"Leidžiama programai keisti planšetinio kompiuterio laiko juostą."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="1000749751269030813">"Programai leidžiama pakeisti TV laiko juostą."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4611828585759488256">"Leidžiama programai keisti telefono laiko juostą."</string>
    <string name="permlab_getAccounts" msgid="5304317160463582791">"rasti paskyras įrenginyje"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="1784452755887604512">"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="tv" msgid="3233589616751852028">"Programai leidžiama gauti TV pasiekiamų paskyrų sąrašą. Tai gali būti įdiegtų programų sukurtos paskyros."</string>
    <string name="permdesc_getAccounts" product="default" msgid="2491273043569751867">"Leidžiama programai gauti telefono žinomų paskyrų sąrašą. Gali būti įtrauktos visos paskyros, sukurtos įdiegtomis programomis."</string>
    <string name="permlab_accessNetworkState" msgid="2349126720783633918">"žiūrėti tinklo ryšius"</string>
    <string name="permdesc_accessNetworkState" msgid="4394564702881662849">"Leidžiama programai peržiūrėti informaciją apie tinklo ryšius, pvz., kurie tinklai pasiekiami ir prijungti."</string>
    <string name="permlab_createNetworkSockets" msgid="3224420491603590541">"turėti visateisę tinklo prieigą"</string>
    <string name="permdesc_createNetworkSockets" msgid="7722020828749535988">"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_changeNetworkState" msgid="8945711637530425586">"keisti tinklo jungiamumą"</string>
    <string name="permdesc_changeNetworkState" msgid="649341947816898736">"Leidžiama programai keisti tinklo jungiamumo būseną."</string>
    <string name="permlab_changeTetherState" msgid="9079611809931863861">"keisti susietą jungiamumą"</string>
    <string name="permdesc_changeTetherState" msgid="3025129606422533085">"Leidžiama programai keisti susieto tinklo jungiamumą."</string>
    <string name="permlab_accessWifiState" msgid="5552488500317911052">"žiūrėti „Wi-Fi“ ryšius"</string>
    <string name="permdesc_accessWifiState" msgid="6913641669259483363">"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="7947824109713181554">"prijungti prie „Wi-Fi“ ir atjungti nuo jo"</string>
    <string name="permdesc_changeWifiState" msgid="7170350070554505384">"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="285626875870754696">"leisti „Wi-Fi“ daugiaadresio perdavimo priėmimą"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="191079868596433554">"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="tv" msgid="1253281508485111166">"Programai leidžiama gauti paketus, kurie išsiųsti visiems „Wi-Fi“ tinklo įrenginiams, naudojantiems kelių perdavimų adresus, o ne tik TV. Veikiant šiam režimui naudojama daugiau energijos."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="8296627590220222740">"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="6490373569441946064">"pasiekti „Bluetooth“ nustatymus"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="5370837055438574863">"Leidžiama programai konfigūruoti vietinį „Bluetooth“ planšetinį kompiuterį ir atrasti nuotolinius įrenginius bei su jais susieti."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="1822785266335294155">"Programai leidžiama konfigūruoti TV „Bluetooth“ ir aptikti bei susieti TV su nuotoliniais įrenginiais."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="7381341743021234863">"Leidžiama programai konfigūruoti vietinį „Bluetooth“ telefoną ir atrasti bei susieti su nuotoliniais įrenginiais."</string>
    <string name="permlab_accessWimaxState" msgid="7029563339012437434">"prisijungti prie WiMAX ir atsijungti nuo jo"</string>
    <string name="permdesc_accessWimaxState" msgid="5372734776802067708">"Leidžiama programai nustatyti, ar įgalintas „WiMAX“, ir informaciją apie visus prijungtus tinklus."</string>
    <string name="permlab_changeWimaxState" msgid="6223305780806267462">"keisti „WiMAX“ būseną"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="4011097664859480108">"Leidžia programai prijungti planšetinį kompiuterį prie „WiMAX“ ryšio tinklų ir nuo jų atjungti."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="6876948244710106021">"Programai leidžiama prijungti TV prie „WiMAX“ tinklų ir atjungti nuo jų."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="1551666203780202101">"Leidžia programai prijungti telefoną prie „WiMAX“ ryšio tinklų ir nuo jų atjungti."</string>
    <string name="permlab_bluetooth" msgid="586333280736937209">"susieti su „Bluetooth“ įrenginiais"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3053222571491402635">"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="tv" msgid="3546625329740068213">"Programai leidžiama peržiūrėti TV „Bluetooth“ konfigūraciją ir kurti bei priimti ryšius su susietais įrenginiais."</string>
    <string name="permdesc_bluetooth" product="default" msgid="2779606714091276746">"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="1904455246837674977">"valdyti artimo lauko perdavimą (angl. „Near Field Communication“)"</string>
    <string name="permdesc_nfc" msgid="8352737680695296741">"Leidžiama programai perduoti artimojo lauko ryšių technologijos (ALR) žymas, korteles ir skaitymo programas."</string>
    <string name="permlab_disableKeyguard" msgid="3605253559020928505">"išjungti ekrano užraktą"</string>
    <string name="permdesc_disableKeyguard" msgid="3223710003098573038">"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_requestPasswordComplexity" msgid="1808977190557794109">"pateikti ekrano užrakto sudėtingumo užklausą"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="1130556896836258567">"Leidžiama programai sužinoti ekrano užrakto sudėtingumo lygį (aukštas, vidutinis, žemas arba nėra), nurodantį galimą ekrano užrakto trukmės diapazoną ir tipą. Be to, programa gali pasiūlyti naudotojams atnaujinti ekrano užraktą į tam tikrą lygį, bet naudotojai gali laisvai nepaisyti ir išeiti. Atminkite, kad ekrano užraktas nesaugomas kaip grynasis tekstas, todėl programa nežino tikslaus slaptažodžio."</string>
    <string name="permlab_useBiometric" msgid="6314741124749633786">"naudoti biometrinę aparatinę įrangą"</string>
    <string name="permdesc_useBiometric" msgid="7502858732677143410">"Leidžiama programai naudoti biometrinę aparatinę įrangą tapatybei nustatyti"</string>
    <string name="permlab_manageFingerprint" msgid="7432667156322821178">"tvarkyti piršto antspaudo aparatinę įrangą"</string>
    <string name="permdesc_manageFingerprint" msgid="2025616816437339865">"Leidžiama programai aktyvinti metodus, norint pridėti ir ištrinti naudojamus kontrolinių kodų šablonus."</string>
    <string name="permlab_useFingerprint" msgid="1001421069766751922">"naudoti piršto antspaudo aparatinę įrangą"</string>
    <string name="permdesc_useFingerprint" msgid="412463055059323742">"Leidžiama programai naudoti piršto antspaudo aparatinę įrangą tapatybei nustatyti"</string>
    <string name="permlab_audioWrite" msgid="8501705294265669405">"keisti muzikos kolekciją"</string>
    <string name="permdesc_audioWrite" msgid="8057399517013412431">"Programai leidžiama keisti muzikos kolekciją."</string>
    <string name="permlab_videoWrite" msgid="5940738769586451318">"keisti vaizdo įrašų kolekciją"</string>
    <string name="permdesc_videoWrite" msgid="6124731210613317051">"Programai leidžiama keisti vaizdo įrašų kolekciją."</string>
    <string name="permlab_imagesWrite" msgid="1774555086984985578">"keisti nuotraukų kolekciją"</string>
    <string name="permdesc_imagesWrite" msgid="5195054463269193317">"Programai leidžiama keisti nuotraukų kolekciją."</string>
    <string name="permlab_mediaLocation" msgid="7368098373378598066">"skaityti vietoves iš medijos kolekcijos"</string>
    <string name="permdesc_mediaLocation" msgid="597912899423578138">"Programai leidžiama skaityti vietoves iš medijos kolekcijos."</string>
    <string name="biometric_dialog_default_title" msgid="5284880398508155088">"Savo tapatybės patvirtinimas"</string>
    <string name="biometric_error_hw_unavailable" msgid="2494077380540615216">"Biometrinė aparatinė įranga nepasiekiama"</string>
    <string name="biometric_error_user_canceled" msgid="6732303949695293730">"Autentifikavimas atšauktas"</string>
    <string name="biometric_not_recognized" msgid="5106687642694635888">"Neatpažinta"</string>
    <string name="biometric_error_canceled" msgid="8266582404844179778">"Autentifikavimas atšauktas"</string>
    <string name="biometric_error_device_not_secured" msgid="3129845065043995924">"Nenustatytas PIN kodas, atrakinimo piešinys arba slaptažodis"</string>
    <string name="fingerprint_acquired_partial" msgid="8532380671091299342">"Aptiktas dalinis piršto antspaudas. Bandykite dar kartą."</string>
    <string name="fingerprint_acquired_insufficient" msgid="2545149524031515411">"Nepavyko apdoroti piršto antspaudo. Bandykite dar kartą."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="4694800187151533990">"Piršto antspaudo jutiklis purvinas. Nuvalykite ir bandykite dar kartą."</string>
    <string name="fingerprint_acquired_too_fast" msgid="5151661932298844352">"Per greitai judinate pirštą. Bandykite dar kartą."</string>
    <string name="fingerprint_acquired_too_slow" msgid="6683510291554497580">"Per lėtai judinate pirštą. Bandykite dar kartą."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_authenticated" msgid="2024862866860283100">"Piršto antspaudas autentifikuotas"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="8867889115112348167">"Veidas autentifikuotas"</string>
    <string name="face_authenticated_confirmation_required" msgid="6872632732508013755">"Veidas autentifikuotas, paspauskite patvirtinimo mygtuką"</string>
    <string name="fingerprint_error_hw_not_available" msgid="4571700896929561202">"Piršto antspaudo aparatinė įranga nepasiekiama."</string>
    <string name="fingerprint_error_no_space" msgid="6126456006769817485">"Negalima išsaugoti piršto antspaudo. Pašalinkite esamą piršto antspaudą."</string>
    <string name="fingerprint_error_timeout" msgid="2946635815726054226">"Baigėsi piršto antspaudo nustatymo skirtasis laikas. Bandykite dar kartą."</string>
    <string name="fingerprint_error_canceled" msgid="540026881380070750">"Piršto antspaudo operacija atšaukta."</string>
    <string name="fingerprint_error_user_canceled" msgid="7685676229281231614">"Piršto antspaudo operaciją atšaukė naudotojas."</string>
    <string name="fingerprint_error_lockout" msgid="7853461265604738671">"Per daug bandymų. Vėliau bandykite dar kartą."</string>
    <string name="fingerprint_error_lockout_permanent" msgid="3895478283943513746">"Per daug bandymų. Piršto antspaudo jutiklis išjungtas."</string>
    <string name="fingerprint_error_unable_to_process" msgid="1148553603490048742">"Bandykite dar kartą."</string>
    <string name="fingerprint_error_no_fingerprints" msgid="8671811719699072411">"Neužregistruota jokių kontrolinių kodų."</string>
    <string name="fingerprint_error_hw_not_present" msgid="578914350967423382">"Šiame įrenginyje nėra kontrolinio kodo jutiklio."</string>
    <string name="fingerprint_name_template" msgid="8941662088160289778">"<xliff:g id="FINGERID">%d</xliff:g> pirštas"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_icon_content_description" msgid="4741068463175388817">"Piršto antspaudo piktograma"</string>
    <string name="permlab_manageFace" msgid="4569549381889283282">"tvarkyti Atrakinimo pagal veidą aparatinę įrangą"</string>
    <string name="permdesc_manageFace" msgid="6204569688492710471">"Programai leidžiama aktyv. metodus, norint pridėti ir ištrinti naudojamus veidų šablonus."</string>
    <string name="permlab_useFaceAuthentication" msgid="1011430526454859030">"naudoti Atrakinimo pagal veidą aparatinę įrangą"</string>
    <string name="permdesc_useFaceAuthentication" msgid="3115697017684668012">"Programai leidžiama naudoti Atrakinimo pagal veidą aparatinę įrangą tapatybei nustatyti"</string>
    <string name="face_recalibrate_notification_name" msgid="6006095897989257026">"Atrakinimas pagal veidą"</string>
    <string name="face_recalibrate_notification_title" msgid="5944930528030496897">"Pakartotinis veido registravimas"</string>
    <string name="face_recalibrate_notification_content" msgid="892757485125249962">"Kad patobulintumėte atpažinimą, iš naujo užregistruokite veidą"</string>
    <string name="face_acquired_insufficient" msgid="2150805835949162453">"Neužfiks. tikslūs veido duom. Bandykite dar kartą."</string>
    <string name="face_acquired_too_bright" msgid="8070756048978079164">"Per šviesu. Išbandykite mažesnį apšvietimą."</string>
    <string name="face_acquired_too_dark" msgid="252573548464426546">"Per tamsu. Išbandykite šviesesnį apšvietimą."</string>
    <string name="face_acquired_too_close" msgid="1628767882971469833">"Laikykite telefoną toliau."</string>
    <string name="face_acquired_too_far" msgid="5098567726427173896">"Laikykite telefoną arčiau."</string>
    <string name="face_acquired_too_high" msgid="4868033653626081839">"Laikykite telefoną aukščiau."</string>
    <string name="face_acquired_too_low" msgid="1512237819632165945">"Laikykite telefoną žemiau."</string>
    <string name="face_acquired_too_right" msgid="2513391513020932655">"Pasukite telefoną kairėn."</string>
    <string name="face_acquired_too_left" msgid="8882499346502714350">"Pasukite telefoną dešinėn."</string>
    <string name="face_acquired_poor_gaze" msgid="4427153558773628020">"Žiūrėkite tiesiai į įrenginį."</string>
    <string name="face_acquired_not_detected" msgid="2945945257956443257">"Veidas turi būti prieš telefoną."</string>
    <string name="face_acquired_too_much_motion" msgid="8199691445085189528">"Įrenginys per daug judinamas. Nejudink. telefono."</string>
    <string name="face_acquired_recalibrate" msgid="8724013080976469746">"Užregistruokite veidą iš naujo."</string>
    <string name="face_acquired_too_different" msgid="4699657338753282542">"Nebegalima atpažinti veido. Bandykite dar kartą."</string>
    <string name="face_acquired_too_similar" msgid="7684650785108399370">"Per daug panašu, pakeiskite veido išraišką."</string>
    <string name="face_acquired_pan_too_extreme" msgid="7822191262299152527">"Nesukite tiek galvos."</string>
    <string name="face_acquired_tilt_too_extreme" msgid="8119978324129248059">"Nesukite tiek galvos."</string>
    <string name="face_acquired_roll_too_extreme" msgid="1442830503572636825">"Nesukite tiek galvos."</string>
    <string name="face_acquired_obscured" msgid="4917643294953326639">"Patraukite viską, kas užstoja jūsų veidą."</string>
    <string name="face_acquired_sensor_dirty" msgid="8968391891086721678">"Išvalykite ekrano viršų, įskaitant juodą juostą"</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="5085202213036026288">"Nepavyko patv. veido. Aparatinė įranga negalima."</string>
    <string name="face_error_timeout" msgid="522924647742024699">"Band. naudoti Atrakinimą pagal veidą dar kartą."</string>
    <string name="face_error_no_space" msgid="5649264057026021723">"Nepavyko išs. naujų veido duomenų. Pirm. ištrinkite senus."</string>
    <string name="face_error_canceled" msgid="2164434737103802131">"Veido atpažinimo operacija atšaukta."</string>
    <string name="face_error_user_canceled" msgid="8553045452825849843">"Atrakinimą pagal veidą atšaukė naudotojas."</string>
    <string name="face_error_lockout" msgid="7864408714994529437">"Per daug bandymų. Vėliau bandykite dar kartą."</string>
    <string name="face_error_lockout_permanent" msgid="8277853602168960343">"Per daug bandymų. Atrakinimas pagal veidą išjungtas."</string>
    <string name="face_error_unable_to_process" msgid="5723292697366130070">"Nepavyko patvirtinti veido. Bandykite dar kartą."</string>
    <string name="face_error_not_enrolled" msgid="7369928733504691611">"Nenustatėte Atrakinimo pagal veidą."</string>
    <string name="face_error_hw_not_present" msgid="1070600921591729944">"Atrakinimas pagal veidą šiame įrenginyje nepalaikomas."</string>
    <string name="face_name_template" msgid="3877037340223318119">"<xliff:g id="FACEID">%d</xliff:g> veidas"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_icon_content_description" msgid="465030547475916280">"Veido pkt."</string>
    <string name="permlab_readSyncSettings" msgid="6250532864893156277">"skaityti sinchronizavimo nustatymus"</string>
    <string name="permdesc_readSyncSettings" msgid="1325658466358779298">"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="6583154300780427399">"įjungti arba išjungti sinchronizavimą"</string>
    <string name="permdesc_writeSyncSettings" msgid="6029151549667182687">"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="3747407238320105332">"skaityti sinchronizavimo statistiką"</string>
    <string name="permdesc_readSyncStats" msgid="3867809926567379434">"Leidžiama programai skaityti sinchronizuotą paskyros statistiką, įskaitant sinchronizuotų įvykių istoriją ir informaciją, kiek duomenų sinchronizuota."</string>
    <string name="permlab_sdcardRead" msgid="5791467020950064920">"skaityti bendr. atmint. turinį"</string>
    <string name="permdesc_sdcardRead" msgid="6872973242228240382">"Pr. leidž. sk. bendr. atm. t."</string>
    <string name="permlab_sdcardWrite" msgid="4863021819671416668">"keisti / trinti bendr. atm. t."</string>
    <string name="permdesc_sdcardWrite" msgid="8376047679331387102">"Pr. leidž. raš. bendr. atm. t."</string>
    <string name="permlab_use_sip" msgid="8250774565189337477">"skambinti / priimti SIP skambučius"</string>
    <string name="permdesc_use_sip" msgid="3590270893253204451">"Leidžiama programai skambinti ir priimti SIP skambučius."</string>
    <string name="permlab_register_sim_subscription" msgid="1653054249287576161">"registruoti naujus telekomunikacijų SIM ryšius"</string>
    <string name="permdesc_register_sim_subscription" msgid="4183858662792232464">"Programai leidžiama registruoti naujus telekomunikacijų SIM ryšius."</string>
    <string name="permlab_register_call_provider" msgid="6135073566140050702">"registruoti naujus telekomunikacijų ryšius"</string>
    <string name="permdesc_register_call_provider" msgid="4201429251459068613">"Programai leidžiama registruoti naujus telekomunikacijų ryšius."</string>
    <string name="permlab_connection_manager" msgid="3179365584691166915">"tvarkyti telekomunikacijų ryšius"</string>
    <string name="permdesc_connection_manager" msgid="1426093604238937733">"Programai leidžiama tvarkyti telekomunikacijų ryšius."</string>
    <string name="permlab_bind_incall_service" msgid="5990625112603493016">"sąveika su gaunamojo skambučio ekranu"</string>
    <string name="permdesc_bind_incall_service" msgid="4124917526967765162">"Programai leidžiama valdyti, kada ir kaip naudotojai matys gaunamojo skambučio ekraną."</string>
    <string name="permlab_bind_connection_service" msgid="5409268245525024736">"sąveikauti su telefonijos paslaugomis"</string>
    <string name="permdesc_bind_connection_service" msgid="6261796725253264518">"Programai leidžiama sąveikauti su telefonijos paslaugomis skambučiams atlikti / gauti."</string>
    <string name="permlab_control_incall_experience" msgid="6436863486094352987">"naudotojui teikti paslaugas vykstant skambučiui"</string>
    <string name="permdesc_control_incall_experience" msgid="5896723643771737534">"Programai leidžiama teikti naudotojui paslaugas vykstant skambučiui."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="8470402862501573795">"skaityti tinklo naudojimo istoriją"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="1112962304941637102">"Leidžiama programai skaityti konkrečių tinklų ir programų tinklo naudojimo istoriją."</string>
    <string name="permlab_manageNetworkPolicy" msgid="6872549423152175378">"valdyti tinklo politiką"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="1865663268764673296">"Leidžiama programai valdyti tinklo politiką ir apibrėžti konkrečios programos taisykles."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="7448790834938749041">"keisti tinklo naudojimo apskaitą"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5076042642247205390">"Leidžiama programai keisti, kaip tinklas naudojamas, palyginti su programomis. Neskirta naudoti įprastoms programoms."</string>
    <string name="permlab_accessNotifications" msgid="7130360248191984741">"pasiekti pranešimus"</string>
    <string name="permdesc_accessNotifications" msgid="761730149268789668">"Programai leidžiama gauti, patikrinti ir išvalyti pranešimus, įskaitant pranešimus, kuriuos paskelbė kitos programos."</string>
    <string name="permlab_bindNotificationListenerService" msgid="5848096702733262458">"susisaistyti su pranešimų skaitymo priemonės paslauga"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="4970553694467137126">"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_bindConditionProviderService" msgid="5245421224814878483">"susaistyti su sąlygos teikėjo paslauga"</string>
    <string name="permdesc_bindConditionProviderService" msgid="6106018791256120258">"Turėtojui leidžiama susaistyti programą su sąlygos teikėjo paslaugos aukščiausio lygio sąsaja. Įprastoms programoms to niekada neturėtų prireikti."</string>
    <string name="permlab_bindDreamService" msgid="4776175992848982706">"susisaistyti su mėgstama paslauga"</string>
    <string name="permdesc_bindDreamService" msgid="9129615743300572973">"Savininkui leidžiama susisaistyti su mėgstamos paslaugos aukščiausio lygio sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_invokeCarrierSetup" msgid="5098810760209818140">"iškviesti operatoriaus pateiktą konfigūravimo programą"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4790845896063237887">"Turėtojui leidžiama iškviesti operatoriaus pateiktą konfigūravimo programą. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_accessNetworkConditions" msgid="1270732533356286514">"vykdyti tinklo sąlygų stebėjimą"</string>
    <string name="permdesc_accessNetworkConditions" msgid="2959269186741956109">"Leidžiama programai vykdyti tinklo sąlygų stebėjimą. To niekada neturėtų prireikti naudojant įprastas programas."</string>
    <string name="permlab_setInputCalibration" msgid="932069700285223434">"keisti įvesties įrenginio kalibravimą"</string>
    <string name="permdesc_setInputCalibration" msgid="2937872391426631726">"Leidžiama programai keisti jutiklinio ekrano kalibravimo parametrus. Neturėtų prireikti naudojant įprastas programas."</string>
    <string name="permlab_accessDrmCertificates" msgid="6473765454472436597">"gali pasiekti DRM sertifikatus"</string>
    <string name="permdesc_accessDrmCertificates" msgid="6983139753493781941">"Programai leidžiama pasiekti ir naudoti DRM sertifikatus. Neturėtų prireikti naudojant įprastas programas."</string>
    <string name="permlab_handoverStatus" msgid="7620438488137057281">"gauti „Android“ perdavimo funkcijos perkėlimo būseną"</string>
    <string name="permdesc_handoverStatus" msgid="3842269451732571070">"Programai leidžiama gauti informaciją apie dabartinius „Android“ perdavimo funkcijos perkėlimus"</string>
    <string name="permlab_removeDrmCertificates" msgid="710576248717404416">"pašalinti DRM sertifikatus"</string>
    <string name="permdesc_removeDrmCertificates" msgid="4068445390318355716">"Programai leidžiama pašalinti DRM sertifikatus. Neturėtų prireikti naudojant įprastas programas."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="3363450860593096967">"susaistyti su operatoriaus susirašinėjimo paslauga"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="6316457028173478345">"Leidžiama savininkui susisaistyti su aukščiausio lygio operatoriaus susirašinėjimo paslaugos sąsaja. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="permlab_bindCarrierServices" msgid="2395596978626237474">"susaistyti su operatoriaus paslaugomis"</string>
    <string name="permdesc_bindCarrierServices" msgid="9185614481967262900">"Savininkui leidžiama susisaistyti su operatoriaus paslaugomis. To niekada neturėtų prireikti naudojant įprastas programas."</string>
    <string name="permlab_access_notification_policy" msgid="5524112842876975537">"pasiekti „Do Not Disturb“"</string>
    <string name="permdesc_access_notification_policy" msgid="8538374112403845013">"Leidžiama programai skaityti ir rašyti „Do Not Disturb“ konfigūraciją."</string>
    <string name="permlab_startViewPermissionUsage" msgid="1504564328641112341">"pradėti peržiūrėti leidimo naudojimą"</string>
    <string name="permdesc_startViewPermissionUsage" msgid="2820325605959586538">"Leidžia savininkui pradėti naudoti programos leidimą. Įprastoms programoms to neturėtų prireikti."</string>
    <string name="policylab_limitPassword" msgid="4851829918814422199">"Nustatyti slaptažodžio taisykles"</string>
    <string name="policydesc_limitPassword" msgid="4105491021115793793">"Valdykite, kokio ilgio ekrano užrakto slaptažodžius ir PIN kodus galima naudoti."</string>
    <string name="policylab_watchLogin" msgid="7599669460083719504">"Stebėti bandymus atrakinti ekraną"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="2388436408621909298">"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="TV" msgid="1880525102716729482">"Stebėti atrakinant ekraną įvestų netinkamų slaptažodžių skaičių ir užrakinti TV arba ištrinti visus TV duomenis, jei per daug kartų įvedamas netinkamas slaptažodis."</string>
    <string name="policydesc_watchLogin" product="default" msgid="4885030206253600299">"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="policydesc_watchLogin_secondaryUser" product="tablet" msgid="2049038943004297474">"Stebėkite atrakinant ekraną įvestų netinkamų slaptažodžių skaičių ir užrakinkite planšetinį kompiuterį arba ištrinkite visus šio naudotojo duomenis, jei per daug kartų įvedamas netinkamas slaptažodis."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="TV" msgid="1253625325967736219">"Stebėkite atrakinant ekraną įvestų netinkamų slaptažodžių skaičių ir užrakinkite TV arba ištrinkite visus šio naudotojo duomenis, jei per daug kartų įvedamas netinkamas slaptažodis."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="9177645136475155924">"Stebėkite atrakinant ekraną įvestų netinkamų slaptažodžių skaičių ir užrakinkite telefoną arba ištrinkite visus šio naudotojo duomenis, jei per daug kartų įvedamas netinkamas slaptažodis."</string>
    <string name="policylab_resetPassword" msgid="214556238645096520">"Pakeisti ekrano užraktą"</string>
    <string name="policydesc_resetPassword" msgid="4626419138439341851">"Pakeisti ekrano užraktą."</string>
    <string name="policylab_forceLock" msgid="7360335502968476434">"Užrakinti ekraną"</string>
    <string name="policydesc_forceLock" msgid="1008844760853899693">"Valdyti, kaip ir kada užrakinamas ekranas."</string>
    <string name="policylab_wipeData" msgid="1359485247727537311">"Trinti visus duomenis"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="7245372676261947507">"Be įspėjimo ištrinti planšetinio kompiuterio duomenis atkuriant gamyklinius duomenis."</string>
    <string name="policydesc_wipeData" product="tv" msgid="8755409895408717659">"Ištrinti TV duomenis be įspėjimo atliekant gamyklinių duomenų atkūrimą."</string>
    <string name="policydesc_wipeData" product="default" msgid="8036084184768379022">"Be įspėjimo ištrinti telefono duomenis atkuriant gamyklinius duomenis."</string>
    <string name="policylab_wipeData_secondaryUser" msgid="413813645323433166">"Naudotojo duomenų ištrynimas"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="2336676480090926470">"Ištrinkite šio naudotojo duomenis šiame planšetiniame kompiuteryje be įspėjimo."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="7310266499158746034">"Ištrinkite šio naudotojo duomenis šiame TV be įspėjimo."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="2788325512167208654">"Ištrinkite šio naudotojo duomenis šiame telefone be įspėjimo."</string>
    <string name="policylab_setGlobalProxy" msgid="215332221188670221">"Nustatyti įrenginio bendrąjį tarpinį serverį"</string>
    <string name="policydesc_setGlobalProxy" msgid="7149665222705519604">"Nustatykite įrenginio visuotinį tarpinį serverį, kuris bus naudojamas, kai politika įgalinta. Tik įrenginio savininkas gali nustatyti visuotinį tarpinį serverį."</string>
    <string name="policylab_expirePassword" msgid="6015404400532459169">"Ekr. užr. slaptaž. gal. l. n."</string>
    <string name="policydesc_expirePassword" msgid="9136524319325960675">"Pakeiskite, kaip dažnai reikia keisti ekrano užrakto slaptažodį, PIN kodą arba atrakinimo piešinį."</string>
    <string name="policylab_encryptedStorage" msgid="9012936958126670110">"Nustatyti atmintinės šifruotę"</string>
    <string name="policydesc_encryptedStorage" msgid="1102516950740375617">"Reikalauti, kad saugomos programos duomenys būtų šifruoti."</string>
    <string name="policylab_disableCamera" msgid="5749486347810162018">"Neleisti fotoaparatų"</string>
    <string name="policydesc_disableCamera" msgid="3204405908799676104">"Neleisti naudoti visų įrenginio fotoaparatų."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="5071855750149949741">"Išj. kai kurias ekran. užr. f."</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="6641673177041195957">"Neleisti naudoti kai kurių ekrano užrakto funkcijų."</string>
  <string-array name="phoneTypes">
    <item msgid="8996339953292723951">"Namų"</item>
    <item msgid="7740243458912727194">"Mobilusis"</item>
    <item msgid="8526146065496663766">"Darbo"</item>
    <item msgid="8150904584178569699">"Darbo faksas"</item>
    <item msgid="4537253139152229577">"Namų faksas"</item>
    <item msgid="6751245029698664340">"Pranešimų gaviklis"</item>
    <item msgid="1692790665884224905">"Kita"</item>
    <item msgid="6216981255272016212">"Tinkintas"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="7786349763648997741">"Pagrindinis"</item>
    <item msgid="435564470865989199">"Darbo"</item>
    <item msgid="4199433197875490373">"Kita"</item>
    <item msgid="3233938986670468328">"Tinkintas"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="3861463339764243038">"Pagrindinis"</item>
    <item msgid="5472578890164979109">"Darbo"</item>
    <item msgid="5718921296646594739">"Kita"</item>
    <item msgid="5523122236731783179">"Tinkintas"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="588088543406993772">"Pagrindinis"</item>
    <item msgid="5503060422020476757">"Darbo"</item>
    <item msgid="2530391194653760297">"Kita"</item>
    <item msgid="7640927178025203330">"Tinkintas"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="6144047813304847762">"Darbo"</item>
    <item msgid="7402720230065674193">"Kita"</item>
    <item msgid="808230403067569648">"Tinkintas"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="7535761744432206400">"AIM"</item>
    <item msgid="2236558491789293993">"Windows Live"</item>
    <item msgid="4925858989398000295">"Yahoo"</item>
    <item msgid="5203383604393320577">"Skype"</item>
    <item msgid="6142060795155127001">"QQ"</item>
    <item msgid="8831467252725610081">"„Google“ pokalbiai"</item>
    <item msgid="4717545739447438044">"ICQ"</item>
    <item msgid="8293711853624033835">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="5120365721260686814">"Tinkintas"</string>
    <string name="phoneTypeHome" msgid="3880132427643623588">"Namų"</string>
    <string name="phoneTypeMobile" msgid="1178852541462086735">"Mobilusis"</string>
    <string name="phoneTypeWork" msgid="6604967163358864607">"Darbo"</string>
    <string name="phoneTypeFaxWork" msgid="6757519896109439123">"Darbo faksas"</string>
    <string name="phoneTypeFaxHome" msgid="6678559953115904345">"Namų faksas"</string>
    <string name="phoneTypePager" msgid="576402072263522767">"Pranešimų gaviklis"</string>
    <string name="phoneTypeOther" msgid="6918196243648754715">"Kita"</string>
    <string name="phoneTypeCallback" msgid="3455781500844157767">"Atgalinis skambinimas"</string>
    <string name="phoneTypeCar" msgid="4604775148963129195">"Automobilis"</string>
    <string name="phoneTypeCompanyMain" msgid="4482773154536455441">"Vidinė telefono linija"</string>
    <string name="phoneTypeIsdn" msgid="2496238954533998512">"ISDN"</string>
    <string name="phoneTypeMain" msgid="5199722006991000111">"Pagrindinis"</string>
    <string name="phoneTypeOtherFax" msgid="3037145630364770357">"Kitas faksas"</string>
    <string name="phoneTypeRadio" msgid="2637819130239264771">"Radijas"</string>
    <string name="phoneTypeTelex" msgid="2558783611711876562">"„Telex“"</string>
    <string name="phoneTypeTtyTdd" msgid="532038552105328779">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="7522314392003565121">"Mobilusis darbo telefonas"</string>
    <string name="phoneTypeWorkPager" msgid="3748332310638505234">"Darbo pranešimų gaviklis"</string>
    <string name="phoneTypeAssistant" msgid="757550783842231039">"Asistentas"</string>
    <string name="phoneTypeMms" msgid="1799747455131365989">"MMS"</string>
    <string name="eventTypeCustom" msgid="3257367158986466481">"Tinkintas"</string>
    <string name="eventTypeBirthday" msgid="7770026752793912283">"Gimimo diena"</string>
    <string name="eventTypeAnniversary" msgid="4684702412407916888">"Sukaktis"</string>
    <string name="eventTypeOther" msgid="530671238533887997">"Kita"</string>
    <string name="emailTypeCustom" msgid="1809435350482181786">"Tinkintas"</string>
    <string name="emailTypeHome" msgid="1597116303154775999">"Pagrindinis"</string>
    <string name="emailTypeWork" msgid="2020095414401882111">"Darbo"</string>
    <string name="emailTypeOther" msgid="5131130857030897465">"Kita"</string>
    <string name="emailTypeMobile" msgid="787155077375364230">"Mobilusis"</string>
    <string name="postalTypeCustom" msgid="5645590470242939129">"Tinkintas"</string>
    <string name="postalTypeHome" msgid="7562272480949727912">"Pagrindinis"</string>
    <string name="postalTypeWork" msgid="8553425424652012826">"Darbo"</string>
    <string name="postalTypeOther" msgid="7094245413678857420">"Kita"</string>
    <string name="imTypeCustom" msgid="5653384545085765570">"Tinkintas"</string>
    <string name="imTypeHome" msgid="6996507981044278216">"Pagrindinis"</string>
    <string name="imTypeWork" msgid="2099668940169903123">"Darbo"</string>
    <string name="imTypeOther" msgid="8068447383276219810">"Kita"</string>
    <string name="imProtocolCustom" msgid="4437878287653764692">"Tinkintas"</string>
    <string name="imProtocolAim" msgid="4050198236506604378">"AIM"</string>
    <string name="imProtocolMsn" msgid="2257148557766499232">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="5373338758093392231">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="1486297589164830043">"Skype"</string>
    <string name="imProtocolQq" msgid="7254708777029006592">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="9194016024343166782">"Hangout"</string>
    <string name="imProtocolIcq" msgid="2410325380427389521">"ICQ"</string>
    <string name="imProtocolJabber" msgid="7919269388889582015">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="4985002408136148256">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="8684458700669564172">"Darbo"</string>
    <string name="orgTypeOther" msgid="5450675258408005553">"Kita"</string>
    <string name="orgTypeCustom" msgid="1126322047677329218">"Tinkintas"</string>
    <string name="relationTypeCustom" msgid="282938315217441351">"Tinkintas"</string>
    <string name="relationTypeAssistant" msgid="4057605157116589315">"Asistentas (-ė)"</string>
    <string name="relationTypeBrother" msgid="7141662427379247820">"Brolis"</string>
    <string name="relationTypeChild" msgid="9076258911292693601">"Vaikas"</string>
    <string name="relationTypeDomesticPartner" msgid="7825306887697559238">"Civilinis partneris"</string>
    <string name="relationTypeFather" msgid="3856225062864790596">"Tėvas"</string>
    <string name="relationTypeFriend" msgid="3192092625893980574">"Draugas (-ė)"</string>
    <string name="relationTypeManager" msgid="2272860813153171857">"Vadovas (-ė)"</string>
    <string name="relationTypeMother" msgid="2331762740982699460">"Motina"</string>
    <string name="relationTypeParent" msgid="4177920938333039882">"Vienas iš tėvų"</string>
    <string name="relationTypePartner" msgid="4018017075116766194">"Partneris (-ė)"</string>
    <string name="relationTypeReferredBy" msgid="5285082289602849400">"Rekomendavo"</string>
    <string name="relationTypeRelative" msgid="3396498519818009134">"Giminaitis (-ė)"</string>
    <string name="relationTypeSister" msgid="3721676005094140671">"Sesuo"</string>
    <string name="relationTypeSpouse" msgid="6916682664436031703">"Sutuoktinis (-ė)"</string>
    <string name="sipAddressTypeCustom" msgid="6283889809842649336">"Tinkintas"</string>
    <string name="sipAddressTypeHome" msgid="5918441930656878367">"Pagrindinis"</string>
    <string name="sipAddressTypeWork" msgid="7873967986701216770">"Darbas"</string>
    <string name="sipAddressTypeOther" msgid="6317012577345187275">"Kita"</string>
    <string name="quick_contacts_not_available" msgid="1262709196045052223">"Nerasta jokių programų šiam kontaktui peržiūrėti."</string>
    <string name="keyguard_password_enter_pin_code" msgid="6401406801060956153">"Įveskite PIN kodą"</string>
    <string name="keyguard_password_enter_puk_code" msgid="3112256684547584093">"Įveskite PUK ir naują PIN kodus"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="2825313071899938305">"PUK kodas"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="5505434724229581207">"Naujas PIN kodas"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="4032288032993261520"><font size="17">"Palieskite, kad įves. slaptaž."</font></string>
    <string name="keyguard_password_enter_password_code" msgid="2751130557661643482">"Jei norite atrakinti, įveskite slaptažodį"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="7792964196473964340">"Jei norite atrakinti, įveskite PIN kodą"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="8583732939138432793">"Neteisingas PIN kodas."</string>
    <string name="keyguard_label_text" msgid="3841953694564168384">"Jei norite atrakinti, paspauskite „Meniu“ ir 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="2978165477085612673">"Pagalbos numeris"</string>
    <string name="lockscreen_carrier_default" msgid="6192313772955399160">"Nėra paslaugos"</string>
    <string name="lockscreen_screen_locked" msgid="7364905540516041817">"Ekranas užrakintas."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="7982445492532123308">"Paspauskite „Meniu“, kad atrakintumėte ar skambintumėte pagalbos numeriu."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="7434061749374801753">"Paspauskite „Meniu“, jei norite atrakinti."</string>
    <string name="lockscreen_pattern_instructions" msgid="3169991838169244941">"Nustatyti modelį, kad atrakintų"</string>
    <string name="lockscreen_emergency_call" msgid="7500692654885445299">"Skambutis pagalbos numeriu"</string>
    <string name="lockscreen_return_to_call" msgid="3156883574692006382">"grįžti prie skambučio"</string>
    <string name="lockscreen_pattern_correct" msgid="8050630103651508582">"Teisingai!"</string>
    <string name="lockscreen_pattern_wrong" msgid="2940138714468358458">"Bandykite dar kartą"</string>
    <string name="lockscreen_password_wrong" msgid="8605355913868947490">"Bandykite dar kartą"</string>
    <string name="lockscreen_storage_locked" msgid="634993789186443380">"Atrakinę pasieksite visas funkcijas ir duomenis"</string>
    <string name="faceunlock_multiple_failures" msgid="681991538434031708">"Viršijote maksimalų atrakinimo pagal veidą bandymų skaičių"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="1248431165144893792">"Nėra SIM kortelės"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="8596805728510570760">"Planšetiniame kompiuteryje nėra SIM kortelės."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="1165408361036993077">"TV nėra SIM kortelės."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="1408695081255172556">"Telefone nėra SIM kortelės."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="8473601862688263903">"Įdėkite SIM kortelę."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3664999892038416334">"Trūksta SIM kortelės arba ji neskaitoma. Įdėkite SIM kortelę."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="3812893366715730539">"Negalima naudoti SIM kortelės."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="4358929052509450807">"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="2879469521751181478">"Ankstesnis takelis"</string>
    <string name="lockscreen_transport_next_description" msgid="2931509904881099919">"Kitas takelis"</string>
    <string name="lockscreen_transport_pause_description" msgid="6705284702135372494">"Pristabdyti"</string>
    <string name="lockscreen_transport_play_description" msgid="106868788691652733">"Leisti"</string>
    <string name="lockscreen_transport_stop_description" msgid="1449552232598355348">"Stabdyti"</string>
    <string name="lockscreen_transport_rew_description" msgid="7680106856221622779">"Sukti atgal"</string>
    <string name="lockscreen_transport_ffw_description" msgid="4763794746640196772">"Sukti pirmyn"</string>
    <string name="emergency_calls_only" msgid="3057351206678279851">"Tik pagalbos skambučiai"</string>
    <string name="lockscreen_network_locked_message" msgid="2814046965899249635">"Tinklas užrakintas"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="6618356415831082174">"SIM kortelė užrakinta PUK kodu."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="5307979043730860995">"Žr. naudotojo vadovą arba susisiekite su klientų priežiūros tarnyba."</string>
    <string name="lockscreen_sim_locked_message" msgid="3160196135801185938">"SIM kortelė užrakinta."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="2286497117428409709">"Atrakinama SD kortelė..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6458790975898594240">"Neteisingai apibrėžėte atrakinimo modelį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%2$d</xliff:g> sek."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="3118353451602377380">"Neteisingai įvedėte slaptažodį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%2$d</xliff:g> sek."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="2874278239714821984">"PIN kodą neteisingai įvedėte <xliff:g id="NUMBER_0">%1$d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%2$d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="3069635524964070596">"Neteisingai nurodėte savo atrakinimo modelį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%2$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">%3$d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="8418060136796780268">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Dar po <xliff:g id="NUMBER_1">%2$d</xliff:g> nesėkming. bandym. būsite paprašyti atrakinti TV prisijungdami prie „Google“.\n\n Bandykite dar kartą už <xliff:g id="NUMBER_2">%3$d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="5691623136957148335">"Neteisingai nurodėte savo atrakinimo modelį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%2$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">%3$d</xliff:g> sek."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="7914445759242151426">"<xliff:g id="NUMBER_0">%1$d</xliff:g> kart. bandėte netinkamai atrakinti planšetinį kompiuterį. Po dar <xliff:g id="NUMBER_1">%2$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="tv" msgid="2736747741914666082">"Netinkamai bandėte atrakinti TV <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Dar po <xliff:g id="NUMBER_1">%2$d</xliff:g> nesėkming. bandym. bus atkurti gamykliniai TV nustatymai, o visi naudotojo duomenys bus prarasti."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="1166532464798446579">"<xliff:g id="NUMBER_0">%1$d</xliff:g> kart. bandėte netinkamai atrakinti telefoną. Po dar <xliff:g id="NUMBER_1">%2$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="8682445539263683414">"<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="tv" msgid="2373955520011165432">"Netinkamai bandėte atrakinti TV <xliff:g id="NUMBER">%d</xliff:g> k. Dabar bus atkurti gamykliniai TV nustatymai."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="2203704707679895487">"<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="6807200118164539589">"Bandyti dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sek."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="8362442730606839031">"Pamiršote modelį?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="9218940117797602518">"Paskyros atrakinimas"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="3775904917743034195">"Per daug šablonų bandymų"</string>
    <string name="lockscreen_glogin_instructions" msgid="4695162942525531700">"Jei norite atrakinti, prisijunkite naudodami „Google“ paskyrą."</string>
    <string name="lockscreen_glogin_username_hint" msgid="6916101478673157045">"Naudotojo vardas (el. paštas)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="3031027901286812848">"Slaptažodis"</string>
    <string name="lockscreen_glogin_submit_button" msgid="3590556636347843733">"Prisijungti"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="4369219936865697679">"Neteisingas naudotojo vardas ar slaptažodis."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1683405808525090649">"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="2607271802803381645">"Tikrinama..."</string>
    <string name="lockscreen_unlock_label" msgid="4648257878373307582">"Atblokuoti"</string>
    <string name="lockscreen_sound_on_label" msgid="1660281470535492430">"Garsas įjungtas"</string>
    <string name="lockscreen_sound_off_label" msgid="2331496559245450053">"Išjungti garsą"</string>
    <string name="lockscreen_access_pattern_start" msgid="3778502525702613399">"Šablonas pradėtas"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="7493849102641167049">"Šablonas išvalytas"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6746676335293144163">"Pridėtas langelis"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="2931364927622563465">"Pridėtas <xliff:g id="CELL_INDEX">%1$s</xliff:g> taškas"</string>
    <string name="lockscreen_access_pattern_detected" msgid="3931150554035194012">"Šablonas užbaigtas"</string>
    <string name="lockscreen_access_pattern_area" msgid="1288780416685002841">"Atrakinimo pagal piešinį sritis."</string>
    <string name="keyguard_accessibility_widget_changed" msgid="7298011259508200234">"%1$s. %2$d valdiklis iš %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8245795023551343672">"Pridėti valdiklį."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="544239307077644480">"Tuščia"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="7768634718706488951">"Atrakinimo sritis išplėsta."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="4729922043778400434">"Atrakinimo sritis sutraukta."</string>
    <string name="keyguard_accessibility_widget" msgid="6776892679715699875">"Valdiklis <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1466067610235696600">"Naudotojo pasirinkimo valdiklis"</string>
    <string name="keyguard_accessibility_status" msgid="6792745049712397237">"Būsena"</string>
    <string name="keyguard_accessibility_camera" msgid="7862557559464986528">"Fotoaparatas"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="2267379779900620614">"Medijos valdikliai"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="7066213328912939191">"Valdiklių pertvarkymas pradėtas."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="1083806817600593490">"Valdiklių pertvarkymas baigtas."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="1509738950119878705">"Valdiklis <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> ištrintas."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="4215280881346033434">"Išplėsti atrakinimo sritį."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2968195219692413046">"Atrakinimas slystant."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="8669128146589233293">"Atrakinimas pagal piešinį."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="632407612842329815">"Atrakinimas pagal veidą."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="4020864007967340068">"Atrakinimas įvedus PIN kodą."</string>
    <string name="keyguard_accessibility_sim_pin_unlock" msgid="4895939120871890557">"SIM kortelės PIN kodo atrakinimas."</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="3459003464041899101">"SIM kortelės PUK kodo atrakinimas."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="6130186108581153265">"Atrakinimas įvedus slaptažodį."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="1419570880512350689">"Atrakinimo pagal piešinį sritis."</string>
    <string name="keyguard_accessibility_slide_area" msgid="4331399051142520176">"Slydimo sritis."</string>
    <string name="password_keyboard_label_symbol_key" msgid="2716255580853511949">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="5294837425652726684">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="8528261816395508841">"ALT"</string>
    <string name="granularity_label_character" msgid="8903387663153706317">"simbolis"</string>
    <string name="granularity_label_word" msgid="3686589158760620518">"žodis"</string>
    <string name="granularity_label_link" msgid="9007852307112046526">"nuoroda"</string>
    <string name="granularity_label_line" msgid="376204904280620221">"eilutė"</string>
    <string name="factorytest_failed" msgid="3190979160945298006">"Gamyklos bandymas nepavyko"</string>
    <string name="factorytest_not_system" msgid="5658160199925519869">"Veiksmas FACTORY_TEST palaikomas tik paketuose, įdiegtuose /system/app."</string>
    <string name="factorytest_no_action" msgid="339252838115675515">"Nerasta paketo, kuris teiktų FACTORY_TEST veiksmą."</string>
    <string name="factorytest_reboot" msgid="2050147445567257365">"Pakartotinai įkelti"</string>
    <string name="js_dialog_title" msgid="7464775045615023241">"Puslapyje šiuo adresu: <xliff:g id="TITLE">%s</xliff:g>, teigiama:"</string>
    <string name="js_dialog_title_default" msgid="3769524569903332476">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="7012587995876771246">"Patvirtinti išėjimą"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="4274257182303565509">"Išeiti iš šio puslapio"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="3873765747622415310">"Likti šiame puslapyje"</string>
    <string name="js_dialog_before_unload" msgid="7213364985774778744">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nTikrai norite išeiti iš šio puslapio?"</string>
    <string name="save_password_label" msgid="9161712335355510035">"Patvirtinti"</string>
    <string name="double_tap_toast" msgid="7065519579174882778">"Patarimas: palieskite dukart, kad padidintumėte ar sumažintumėte mastelį."</string>
    <string name="autofill_this_form" msgid="3187132440451621492">"Automatinis pildymas"</string>
    <string name="setup_autofill" msgid="5431369130866618567">"Nust. aut. pild."</string>
    <string name="autofill_window_title" msgid="4379134104008111961">"Automatinis pildymas naudojant „<xliff:g id="SERVICENAME">%1$s</xliff:g>“"</string>
    <string name="autofill_address_name_separator" msgid="8190155636149596125">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3402882515222673691">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="760522655085707045">", "</string>
    <string name="autofill_address_summary_format" msgid="8417010069362125194">"$1$2$3"</string>
    <string name="autofill_province" msgid="3676846437741893159">"Provincija"</string>
    <string name="autofill_postal_code" msgid="7034789388968295591">"Pašto kodas"</string>
    <string name="autofill_state" msgid="3341725337190434069">"Valstija"</string>
    <string name="autofill_zip_code" msgid="1315503730274962450">"Pašto kodas"</string>
    <string name="autofill_county" msgid="7781382735643492173">"Apskritis"</string>
    <string name="autofill_island" msgid="5367139008536593734">"Sala"</string>
    <string name="autofill_district" msgid="6428712062213557327">"Rajonas"</string>
    <string name="autofill_department" msgid="9047276226873531529">"Departamentas"</string>
    <string name="autofill_prefecture" msgid="7267397763720241872">"Prefektūra"</string>
    <string name="autofill_parish" msgid="6847960518334530198">"Parapija"</string>
    <string name="autofill_area" msgid="8289022370678448983">"Sritis"</string>
    <string name="autofill_emirate" msgid="2544082046790551168">"Emyratas"</string>
    <string name="permlab_readHistoryBookmarks" msgid="9102293913842539697">"skaityti žiniatinklio žymes ir istoriją"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="2323799501008967852">"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="6090259925187986937">"rašyti žiniatinklio žymes ir istoriją"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="573341025292489065">"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="tv" msgid="755207379344494691">"Programai leidžiama keisti TV saugomą naršyklės istoriją arba žymes. Taip programai gali būti leidžiama ištrinti arba pakeisti naršyklės duomenis. Pastaba: šio leidimo gali nepritaikyti trečiųjų šalių naršyklės arba kitos programos, kurias naudojant galima naršyti žiniatinklyje."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="2245203087160913652">"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="1158001610254173567">"nustatyti pavojaus signalą"</string>
    <string name="permdesc_setAlarm" msgid="2185033720060109640">"Leidžiama programai nustatyti signalą įdiegtoje žadintuvo programoje. Kai kuriose žadintuvo programose ši funkcija gali nebūti nevykdoma."</string>
    <string name="permlab_addVoicemail" msgid="4770245808840814471">"pridėti balso pašto pranešimų"</string>
    <string name="permdesc_addVoicemail" msgid="5470312139820074324">"Leidžia programai pridėti pranešimų prie jūsų balso pašto gautųjų."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="8605631647492879449">"keisti naršyklės geografinės vietos leidimus"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="5817346421222227772">"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="save_password_message" msgid="2146409467245462965">"Ar norite, kad naršyklė atsimintų šį slaptažodį?"</string>
    <string name="save_password_notnow" msgid="2878327088951240061">"Ne dabar"</string>
    <string name="save_password_remember" msgid="6490888932657708341">"Atsiminti"</string>
    <string name="save_password_never" msgid="6776808375903410659">"Niekada"</string>
    <string name="open_permission_deny" msgid="5136793905306987251">"Neturite leidimo atidaryti šį puslapį."</string>
    <string name="text_copied" msgid="2531420577879738860">"Tekstas nukopijuotas į iškarpinę."</string>
    <string name="copied" msgid="4675902854553014676">"Nukopijuota"</string>
    <string name="more_item_label" msgid="7419249600215749115">"Daugiau"</string>
    <string name="prepend_shortcut_label" msgid="1743716737502867951">"Meniu+"</string>
    <string name="menu_meta_shortcut_label" msgid="1623390163674762478">"„Meta“ +"</string>
    <string name="menu_ctrl_shortcut_label" msgid="131911133027196485">"„Ctrl“ +"</string>
    <string name="menu_alt_shortcut_label" msgid="343761069945250991">"„Alt“ +"</string>
    <string name="menu_shift_shortcut_label" msgid="5443936876111232346">"„Shift“ +"</string>
    <string name="menu_sym_shortcut_label" msgid="4037566049061218776">"„Sym“ +"</string>
    <string name="menu_function_shortcut_label" msgid="2367112760987662566">"„Function“ +"</string>
    <string name="menu_space_shortcut_label" msgid="5949311515646872071">"tarpas"</string>
    <string name="menu_enter_shortcut_label" msgid="6709499510082897320">"„Enter“ klavišas"</string>
    <string name="menu_delete_shortcut_label" msgid="4365787714477739080">"ištrinti"</string>
    <string name="search_go" msgid="2141477624421347086">"Ieškoti"</string>
    <string name="search_hint" msgid="455364685740251925">"Paieška…"</string>
    <string name="searchview_description_search" msgid="1045552007537359343">"Ieškoti"</string>
    <string name="searchview_description_query" msgid="7430242366971716338">"Paieškos užklausa"</string>
    <string name="searchview_description_clear" msgid="1989371719192982900">"Išvalyti užklausą"</string>
    <string name="searchview_description_submit" msgid="6771060386117334686">"Patvirtinti užklausą"</string>
    <string name="searchview_description_voice" msgid="42360159504884679">"Paieška balsu"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="5095399706284943314">"Įgalinti naršymą liečiant?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="1037295476738940824">"„<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="4312979647356179250">"„<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="4538030857114635777">"Prieš 1 mėn."</string>
    <string name="beforeOneMonthDurationPast" msgid="8315149541372065392">"Prieš maždaug 1 mėnesį"</string>
    <plurals name="last_num_days" formatted="false" msgid="687443109145393632">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> pastaroji diena</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> pastarosios dienos</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> pastarosios dienos</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> pastarųjų dienų</item>
    </plurals>
    <string name="last_month" msgid="1528906781083518683">"Paskutinį mėnesį"</string>
    <string name="older" msgid="1645159827884647400">"Senesni"</string>
    <string name="preposition_for_date" msgid="2780767868832729599">"<xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="4336835286453822053">"<xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="3149809685340130039">"<xliff:g id="YEAR">%s</xliff:g> m."</string>
    <string name="day" msgid="8394717255950176156">"d."</string>
    <string name="days" msgid="4570879797423034973">"d."</string>
    <string name="hour" msgid="7796325297097314653">"val."</string>
    <string name="hours" msgid="8517014849629200683">"val."</string>
    <string name="minute" msgid="8369209540986467610">"min."</string>
    <string name="minutes" msgid="3456532942641808971">"min."</string>
    <string name="second" msgid="9210875257112211713">"sek."</string>
    <string name="seconds" msgid="2175052687727971048">"sek."</string>
    <string name="week" msgid="907127093960923779">"savaitė"</string>
    <string name="weeks" msgid="3516247214269821391">"sav."</string>
    <string name="year" msgid="5182610307741238982">"metai"</string>
    <string name="years" msgid="5797714729103773425">"metai"</string>
    <string name="now_string_shortest" msgid="3684914126941650330">"dabar"</string>
    <plurals name="duration_minutes_shortest" formatted="false" msgid="7519574894537185135">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
    </plurals>
    <plurals name="duration_hours_shortest" formatted="false" msgid="2838655994500499651">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> val.</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest" formatted="false" msgid="3686058472983158496">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> d.</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> d.</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> d.</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> d.</item>
    </plurals>
    <plurals name="duration_years_shortest" formatted="false" msgid="8299112348723640338">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> m.</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> m.</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> m.</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> m.</item>
    </plurals>
    <plurals name="duration_minutes_shortest_future" formatted="false" msgid="849196137176399440">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g>min</item>
    </plurals>
    <plurals name="duration_hours_shortest_future" formatted="false" msgid="5386373597343170388">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest_future" formatted="false" msgid="814754627092787227">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g> d.</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g> d.</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g> d.</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g> d.</item>
    </plurals>
    <plurals name="duration_years_shortest_future" formatted="false" msgid="7683731800140202145">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g> m.</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g> m.</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g> m.</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g> m.</item>
    </plurals>
    <plurals name="duration_minutes_relative" formatted="false" msgid="6569851308583028344">
      <item quantity="one">prieš <xliff:g id="COUNT_1">%d</xliff:g> minutę</item>
      <item quantity="few">prieš <xliff:g id="COUNT_1">%d</xliff:g> minutes</item>
      <item quantity="many">prieš <xliff:g id="COUNT_1">%d</xliff:g> minutės</item>
      <item quantity="other">prieš <xliff:g id="COUNT_1">%d</xliff:g> minučių</item>
    </plurals>
    <plurals name="duration_hours_relative" formatted="false" msgid="420434788589102019">
      <item quantity="one">prieš <xliff:g id="COUNT_1">%d</xliff:g> valandą</item>
      <item quantity="few">prieš <xliff:g id="COUNT_1">%d</xliff:g> valandas</item>
      <item quantity="many">prieš <xliff:g id="COUNT_1">%d</xliff:g> valandos</item>
      <item quantity="other">prieš <xliff:g id="COUNT_1">%d</xliff:g> valandų</item>
    </plurals>
    <plurals name="duration_days_relative" formatted="false" msgid="6056425878237482431">
      <item quantity="one">prieš <xliff:g id="COUNT_1">%d</xliff:g> dieną</item>
      <item quantity="few">prieš <xliff:g id="COUNT_1">%d</xliff:g> dienas</item>
      <item quantity="many">prieš <xliff:g id="COUNT_1">%d</xliff:g> dienos</item>
      <item quantity="other">prieš <xliff:g id="COUNT_1">%d</xliff:g> dienų</item>
    </plurals>
    <plurals name="duration_years_relative" formatted="false" msgid="2179998228861172159">
      <item quantity="one">prieš <xliff:g id="COUNT_1">%d</xliff:g> metus</item>
      <item quantity="few">prieš <xliff:g id="COUNT_1">%d</xliff:g> metus</item>
      <item quantity="many">prieš <xliff:g id="COUNT_1">%d</xliff:g> metų</item>
      <item quantity="other">prieš <xliff:g id="COUNT_1">%d</xliff:g> metų</item>
    </plurals>
    <plurals name="duration_minutes_relative_future" formatted="false" msgid="5759885720917567723">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g> minutės</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g> minučių</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g> minutės</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g> minučių</item>
    </plurals>
    <plurals name="duration_hours_relative_future" formatted="false" msgid="8963511608507707959">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g> valandos</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g> valandų</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g> valandos</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g> valandų</item>
    </plurals>
    <plurals name="duration_days_relative_future" formatted="false" msgid="1964709470979250702">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g> dienos</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g> dienų</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g> dienos</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g> dienų</item>
    </plurals>
    <plurals name="duration_years_relative_future" formatted="false" msgid="3985129025134896371">
      <item quantity="one">po <xliff:g id="COUNT_1">%d</xliff:g> metų</item>
      <item quantity="few">po <xliff:g id="COUNT_1">%d</xliff:g> metų</item>
      <item quantity="many">po <xliff:g id="COUNT_1">%d</xliff:g> metų</item>
      <item quantity="other">po <xliff:g id="COUNT_1">%d</xliff:g> metų</item>
    </plurals>
    <string name="VideoView_error_title" msgid="5750686717225068016">"Vaizdo įrašo problema"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3782449246085134720">"Šis vaizdo įrašas netinkamas srautiniu būdu perduoti į šį įrenginį."</string>
    <string name="VideoView_error_text_unknown" msgid="7658683339707607138">"Negalima paleisti šio vaizdo įrašo."</string>
    <string name="VideoView_error_button" msgid="5138809446603764272">"Gerai"</string>
    <string name="relative_time" msgid="8572030016028033243">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="8365974533050605886">"vidurdienis"</string>
    <string name="Noon" msgid="6902418443846838189">"Vidurdienis"</string>
    <string name="midnight" msgid="3646671134282785114">"vidurnaktis"</string>
    <string name="Midnight" msgid="8176019203622191377">"Vidurnaktis"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="8689459651807876423">"<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="2302144714803345056">"<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="1532369154488982046">"Pasirinkti visus"</string>
    <string name="cut" msgid="2561199725874745819">"Iškirpti"</string>
    <string name="copy" msgid="5472512047143665218">"Kopijuoti"</string>
    <string name="failed_to_copy_to_clipboard" msgid="725919885138539875">"Nepavyko nukopijuoti į iškarpinę"</string>
    <string name="paste" msgid="461843306215520225">"Įklijuoti"</string>
    <string name="paste_as_plain_text" msgid="7664800665823182587">"Įklijuoti kaip grynąjį tekstą"</string>
    <string name="replace" msgid="7842675434546657444">"Pakeisti•"</string>
    <string name="delete" msgid="1514113991712129054">"Ištrinti"</string>
    <string name="copyUrl" msgid="6229645005987260230">"Kopijuoti URL"</string>
    <string name="selectTextMode" msgid="3225108910999318778">"Pasirinkti tekstą"</string>
    <string name="undo" msgid="3175318090002654673">"Anuliuoti"</string>
    <string name="redo" msgid="7231448494008532233">"Grąžinti"</string>
    <string name="autofill" msgid="511224882647795296">"Automatinis pildymas"</string>
    <string name="textSelectionCABTitle" msgid="5151441579532476940">"Teksto pasirinkimas"</string>
    <string name="addToDictionary" msgid="8041821113480950096">"Pridėti prie žodyno"</string>
    <string name="deleteText" msgid="4200807474529938112">"Ištrinti"</string>
    <string name="inputMethod" msgid="1784759500516314751">"Įvesties būdas"</string>
    <string name="editTextMenuTitle" msgid="857666911134482176">"Teksto veiksmai"</string>
    <string name="email" msgid="2503484245190492693">"Siųsti el. laišką"</string>
    <string name="email_desc" msgid="8291893932252173537">"Siųsti el. laišką pasirinktu adresu"</string>
    <string name="dial" msgid="4954567785798679706">"Skambinti"</string>
    <string name="dial_desc" msgid="3072967472129276617">"Skambinti pasirinktu telefono numeriu"</string>
    <string name="map" msgid="6865483125449986339">"Žemėlapis"</string>
    <string name="map_desc" msgid="1068169741300922557">"Rasti vietą pasirinktu adresu"</string>
    <string name="browse" msgid="8692753594669717779">"Atidaryti"</string>
    <string name="browse_desc" msgid="5328523986921597700">"Atidaryti pasirinktą URL"</string>
    <string name="sms" msgid="3976991545867187342">"Rašyti pranešimą"</string>
    <string name="sms_desc" msgid="997349906607675955">"Siųsti pranešimą pasirinktu telefono numeriu"</string>
    <string name="add_contact" msgid="7404694650594333573">"Pridėti"</string>
    <string name="add_contact_desc" msgid="6419581556288775911">"Pridėti prie kontaktų"</string>
    <string name="view_calendar" msgid="4274396845124626977">"Peržiūrėti"</string>
    <string name="view_calendar_desc" msgid="1739770773927245564">"Peržiūrėti kalendoriuje pasirinktą laiką"</string>
    <string name="add_calendar_event" msgid="5564364269553091740">"Tvarkaraštis"</string>
    <string name="add_calendar_event_desc" msgid="5827530672900331107">"Planuoti įvykį pasirinktam laikui"</string>
    <string name="view_flight" msgid="2042802613849690108">"Stebėti"</string>
    <string name="view_flight_desc" msgid="2802812586218764790">"Stebėti pasirinktą skrydį"</string>
    <string name="translate" msgid="1416909787202727524">"Versti"</string>
    <string name="translate_desc" msgid="4096225388385338322">"Versti pasirinktą tekstą"</string>
    <string name="define" msgid="5214255850068764195">"Apibrėžti"</string>
    <string name="define_desc" msgid="6916651934713282645">"Apibrėžti pasirinktą tekstą"</string>
    <string name="low_internal_storage_view_title" msgid="9024241779284783414">"Mažėja laisvos saugyklos vietos"</string>
    <string name="low_internal_storage_view_text" msgid="8172166728369697835">"Kai kurios sistemos funkcijos gali neveikti"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="7368968163411251788">"Sistemos saugykloje nepakanka vietos. Įsitikinkite, kad yra 250 MB laisvos vietos, ir paleiskite iš naujo."</string>
    <string name="app_running_notification_title" msgid="8985999749231486569">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ vykdoma"</string>
    <string name="app_running_notification_text" msgid="5120815883400228566">"Palieskite, kad gautumėte daugiau informacijos arba galėtumėte sustabdyti programą."</string>
    <string name="ok" msgid="2646370155170753815">"Gerai"</string>
    <string name="cancel" msgid="6908697720451760115">"Atšaukti"</string>
    <string name="yes" msgid="9069828999585032361">"Gerai"</string>
    <string name="no" msgid="5122037903299899715">"Atšaukti"</string>
    <string name="dialog_alert_title" msgid="651856561974090712">"Dėmesio"</string>
    <string name="loading" msgid="3138021523725055037">"Įkeliama..."</string>
    <string name="capital_on" msgid="2770685323900821829">"ĮJ."</string>
    <string name="capital_off" msgid="7443704171014626777">"IŠJ."</string>
    <string name="whichApplication" msgid="5432266899591255759">"Užbaigti veiksmą naudojant"</string>
    <string name="whichApplicationNamed" msgid="6969946041713975681">"Užbaigti veiksmą naudojant %1$s"</string>
    <string name="whichApplicationLabel" msgid="7852182961472531728">"Užbaigti veiksmą"</string>
    <string name="whichViewApplication" msgid="5733194231473132945">"Atidaryti naudojant"</string>
    <string name="whichViewApplicationNamed" msgid="415164730629690105">"Atidaryti naudojant %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="7367556735684742409">"Atidaryti"</string>
    <string name="whichOpenHostLinksWith" msgid="7645631470199397485">"Atidaryti <xliff:g id="HOST">%1$s</xliff:g> nuorodas naudojant"</string>
    <string name="whichOpenLinksWith" msgid="1120936181362907258">"Atidaryti nuorodas naudojant"</string>
    <string name="whichOpenLinksWithApp" msgid="6917864367861910086">"Atidaryti nuorodas naudojant „<xliff:g id="APPLICATION">%1$s</xliff:g>“"</string>
    <string name="whichOpenHostLinksWithApp" msgid="2401668560768463004">"Atidaryti <xliff:g id="HOST">%1$s</xliff:g> nuorodas naudojant „<xliff:g id="APPLICATION">%2$s</xliff:g>“"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="7805857277166106236">"Suteikti prieigą"</string>
    <string name="whichEditApplication" msgid="6191568491456092812">"Redaguoti naudojant"</string>
    <string name="whichEditApplicationNamed" msgid="8096494987978521514">"Redaguoti naudojant %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="1463288652070140285">"Redaguoti"</string>
    <string name="whichSendApplication" msgid="4143847974460792029">"Bendrinti"</string>
    <string name="whichSendApplicationNamed" msgid="4470386782693183461">"Bendrinti naudojant %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="7467813004769188515">"Bendrinti"</string>
    <string name="whichSendToApplication" msgid="77101541959464018">"Siųsti naudojant"</string>
    <string name="whichSendToApplicationNamed" msgid="3385686512014670003">"Siųsti naudojant „%1$s“"</string>
    <string name="whichSendToApplicationLabel" msgid="3543240188816513303">"Siųsti"</string>
    <string name="whichHomeApplication" msgid="8276350727038396616">"Pasirinkti pagrindinę programą"</string>
    <string name="whichHomeApplicationNamed" msgid="5855990024847433794">"Naudoti „%1$s“ kaip pagrindinę programą"</string>
    <string name="whichHomeApplicationLabel" msgid="8907334282202933959">"Užfiksuoti vaizdą"</string>
    <string name="whichImageCaptureApplication" msgid="2737413019463215284">"Užfiksuoti vaizdą naudojant"</string>
    <string name="whichImageCaptureApplicationNamed" msgid="8820702441847612202">"Užfiksuoti vaizdą naudojant „%1$s“"</string>
    <string name="whichImageCaptureApplicationLabel" msgid="6505433734824988277">"Užfiksuoti vaizdą"</string>
    <string name="alwaysUse" msgid="3153558199076112903">"Šiam veiksmui tai naudoti pagal numatytuosius nustatymus."</string>
    <string name="use_a_different_app" msgid="4987790276170972776">"Naudoti kitą programą"</string>
    <string name="clearDefaultHintMsg" msgid="1325866337702524936">"Numatytuosius nustatymus išvalykite nuėję į „Sistemos nustatymai“ &gt; „Programos“ &gt; „Atsisiųsta“."</string>
    <string name="chooseActivity" msgid="8563390197659779956">"Pasirinkti veiksmą"</string>
    <string name="chooseUsbActivity" msgid="2096269989990986612">"Pasirinkite USB įrenginio programą"</string>
    <string name="noApplications" msgid="1186909265235544019">"Jokios programos negali atlikti šio veiksmo."</string>
    <string name="aerr_application" msgid="4090916809370389109">"<xliff:g id="APPLICATION">%1$s</xliff:g> sustabdyta"</string>
    <string name="aerr_process" msgid="4268018696970966407">"<xliff:g id="PROCESS">%1$s</xliff:g> sustabdytas"</string>
    <string name="aerr_application_repeated" msgid="7804378743218496566">"„<xliff:g id="APPLICATION">%1$s</xliff:g>“ vis sustabdoma"</string>
    <string name="aerr_process_repeated" msgid="1153152413537954974">"Procesas „<xliff:g id="PROCESS">%1$s</xliff:g>“ vis sustabdomas"</string>
    <string name="aerr_restart" msgid="2789618625210505419">"Atidaryti programą dar kartą"</string>
    <string name="aerr_report" msgid="3095644466849299308">"Siųsti atsiliepimą"</string>
    <string name="aerr_close" msgid="3398336821267021852">"Uždaryti"</string>
    <string name="aerr_mute" msgid="2304972923480211376">"Ignoruoti, kol įrenginys bus paleistas iš naujo"</string>
    <string name="aerr_wait" msgid="3198677780474548217">"Laukti"</string>
    <string name="aerr_close_app" msgid="8318883106083050970">"Uždaryti programą"</string>
    <string name="anr_title" msgid="7290329487067300120"></string>
    <string name="anr_activity_application" msgid="8121716632960340680">"„<xliff:g id="APPLICATION">%2$s</xliff:g>“ neatsako"</string>
    <string name="anr_activity_process" msgid="3477362583767128667">"„<xliff:g id="ACTIVITY">%1$s</xliff:g>“ neatsako"</string>
    <string name="anr_application_process" msgid="4978772139461676184">"„<xliff:g id="APPLICATION">%1$s</xliff:g>“ neatsako"</string>
    <string name="anr_process" msgid="1664277165911816067">"Procesas „<xliff:g id="PROCESS">%1$s</xliff:g>“ neatsako"</string>
    <string name="force_close" msgid="9035203496368973803">"Gerai"</string>
    <string name="report" msgid="2149194372340349521">"Pranešti"</string>
    <string name="wait" msgid="7765985809494033348">"Palaukti"</string>
    <string name="webpage_unresponsive" msgid="7850879412195273433">"Puslapis neatsako.\n\nAr norite jį uždaryti?"</string>
    <string name="launch_warning_title" msgid="6725456009564953595">"Programa peradresuota"</string>
    <string name="launch_warning_replace" msgid="3073392976283203402">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ dabar vykdoma."</string>
    <string name="launch_warning_original" msgid="3332206576800169626">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ buvo iš pradžių paleista."</string>
    <string name="screen_compat_mode_scale" msgid="8627359598437527726">"Mastelis"</string>
    <string name="screen_compat_mode_show" msgid="5080361367584709857">"Visada rodyti"</string>
    <string name="screen_compat_mode_hint" msgid="4032272159093750908">"Įgalinkite jį iš naujo nuėję į „Sistemos nustatymai“ &gt; „Programos“ &gt; „Atsisiųsta“."</string>
    <string name="unsupported_display_size_message" msgid="7265211375269394699">"Programoje „<xliff:g id="APP_NAME">%1$s</xliff:g>“ nepalaikomas dabartinis ekrano dydžio nustatymas ir ji gali netinkamai veikti."</string>
    <string name="unsupported_display_size_show" msgid="980129850974919375">"Visada rodyti"</string>
    <string name="unsupported_compile_sdk_message" msgid="7326293500707890537">"Programa „<xliff:g id="APP_NAME">%1$s</xliff:g>“ buvo sukurta nesuderinamos versijos „Android“ OS ir gali netinkamai veikti. Gali būti pasiekiama atnaujintos versijos programa."</string>
    <string name="unsupported_compile_sdk_show" msgid="1601210057960312248">"Visada rodyti"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="1103639989147664456">"Tikrinti, ar yra naujinių"</string>
    <string name="smv_application" msgid="3775183542777792638">"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="1398801497130695446">"„<xliff:g id="PROCESS">%1$s</xliff:g>“ procesas pažeidė savo vykdomą „StrictMode“ politiką."</string>
    <string name="android_upgrading_title" product="default" msgid="7279077384220829683">"Telefonas atnaujinamas…"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4268417249079938805">"Planšetinis kompiuteris atnaujinamas…"</string>
    <string name="android_upgrading_title" product="device" msgid="6774767702998149762">"Įrenginys atnaujinamas…"</string>
    <string name="android_start_title" product="default" msgid="4036708252778757652">"Telefonas paleidžiamas…"</string>
    <string name="android_start_title" product="automotive" msgid="7917984412828168079">"Paleidžiama „Android“…"</string>
    <string name="android_start_title" product="tablet" msgid="4429767260263190344">"Planšetinis kompiuteris paleidžiamas…"</string>
    <string name="android_start_title" product="device" msgid="6967413819673299309">"Įrenginys paleidžiamas…"</string>
    <string name="android_upgrading_fstrim" msgid="3259087575528515329">"Optimizuojama saugykla."</string>
    <string name="android_upgrading_notification_title" product="default" msgid="3509927005342279257">"Baigiama atnaujinti sistemą…"</string>
    <string name="app_upgrading_toast" msgid="1016267296049455585">"„<xliff:g id="APPLICATION">%1$s</xliff:g>“ naujovinama..."</string>
    <string name="android_upgrading_apk" msgid="1339564803894466737">"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_preparing_apk" msgid="589736917792300956">"Ruošiama „<xliff:g id="APPNAME">%1$s</xliff:g>“."</string>
    <string name="android_upgrading_starting_apps" msgid="6206161195076057075">"Paleidžiamos programos."</string>
    <string name="android_upgrading_complete" msgid="409800058018374746">"Užbaigiamas paleidimas."</string>
    <string name="heavy_weight_notification" msgid="8382784283600329576">"Vykdoma „<xliff:g id="APP">%1$s</xliff:g>“"</string>
    <string name="heavy_weight_notification_detail" msgid="6802247239468404078">"Palieskite, kad grįžtumėte į žaidimą"</string>
    <string name="heavy_weight_switcher_title" msgid="3861984210040100886">"Pasirinkite žaidimą"</string>
    <string name="heavy_weight_switcher_text" msgid="6814316627367160126">"Kad programa geriau veiktų, vienu metu galima atidaryti tik vieną iš šių žaidimų."</string>
    <string name="old_app_action" msgid="725331621042848590">"Grįžti į „<xliff:g id="OLD_APP">%1$s</xliff:g>“"</string>
    <string name="new_app_action" msgid="547772182913269801">"Atidaryti „<xliff:g id="NEW_APP">%1$s</xliff:g>“"</string>
    <string name="new_app_description" msgid="1958903080400806644">"„<xliff:g id="OLD_APP">%1$s</xliff:g>“ bus uždaryta neišsaugojus duomenų"</string>
    <string name="dump_heap_notification" msgid="5316644945404825032">"„<xliff:g id="PROC">%1$s</xliff:g>“ viršijo atminties limitą"</string>
    <string name="dump_heap_ready_notification" msgid="2302452262927390268">"„<xliff:g id="PROC">%1$s</xliff:g>“ atminties išklotinė parengta"</string>
    <string name="dump_heap_notification_detail" msgid="8431586843001054050">"Atminties išklotinės duomenys surinkti. Palieskite, jei norite bendrinti."</string>
    <string name="dump_heap_title" msgid="4367128917229233901">"Bendrinti atminties išklotinę?"</string>
    <string name="dump_heap_text" msgid="1692649033835719336">"Procesas „<xliff:g id="PROC">%1$s</xliff:g>“ viršijo <xliff:g id="SIZE">%2$s</xliff:g> atminties limitą. Atminties išklotinė pasiekiama, kad galėtumėte bendrinti su jos kūrėju. Būkite atsargūs: šioje atminties išklotinėje gali būti jūsų asmens informacijos, kurią gali pasiekti programa."</string>
    <string name="dump_heap_system_text" msgid="6805155514925350849">"Procesas „<xliff:g id="PROC">%1$s</xliff:g>“ viršijo <xliff:g id="SIZE">%2$s</xliff:g> atminties limitą. Galite bendrinti atminties išklotinę. Būkite atidūs: šioje atminties išklotinėje gali būti vykdant procesą pasiekiamos neskelbtinos asmens informacijos, kuri gali apimti įvestą tekstą."</string>
    <string name="dump_heap_ready_text" msgid="5849618132123045516">"Galite bendrinti proceso „<xliff:g id="PROC">%1$s</xliff:g>“ atminties išklotinę. Būkite atidūs: šioje atminties išklotinėje gali būti vykdant procesą pasiekiamos neskelbtinos asmens informacijos, kuri gali apimti įvestą tekstą."</string>
    <string name="sendText" msgid="493003724401350724">"Pasirinkite teksto veiksmą"</string>
    <string name="volume_ringtone" msgid="134784084629229029">"Skambučio garsumas"</string>
    <string name="volume_music" msgid="7727274216734955095">"Medijos garsumas"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="2614142915948898228">"Paleista naudojant „Bluetooth“"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="1514829655029062233">"Nustatytas tylus skambėjimo tonas"</string>
    <string name="volume_call" msgid="7625321655265747433">"Skambučio apimtis"</string>
    <string name="volume_bluetooth_call" msgid="2930204618610115061">"„Bluetooth“ skambučio garsumas"</string>
    <string name="volume_alarm" msgid="4486241060751798448">"Signalo garsumas"</string>
    <string name="volume_notification" msgid="6864412249031660057">"Pranešimo apimtis"</string>
    <string name="volume_unknown" msgid="4041914008166576293">"Garsumas"</string>
    <string name="volume_icon_description_bluetooth" msgid="7540388479345558400">"„Bluetooth“ garsumas"</string>
    <string name="volume_icon_description_ringer" msgid="2187800636867423459">"Skambėjimo tono garsumas"</string>
    <string name="volume_icon_description_incall" msgid="4491255105381227919">"Skambučio garsumas"</string>
    <string name="volume_icon_description_media" msgid="4997633254078171233">"Medijos garsumas"</string>
    <string name="volume_icon_description_notification" msgid="579091344110747279">"Pranešimo apimtis"</string>
    <string name="ringtone_default" msgid="9118299121288174597">"Numatytasis skambėjimo tonas"</string>
    <string name="ringtone_default_with_actual" msgid="2709686194556159773">"Numatytasis („<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>“)"</string>
    <string name="ringtone_silent" msgid="397111123930141876">"Nėra"</string>
    <string name="ringtone_picker_title" msgid="667342618626068253">"Skambėjimo tonai"</string>
    <string name="ringtone_picker_title_alarm" msgid="7438934548339024767">"Įspėjimų garsai"</string>
    <string name="ringtone_picker_title_notification" msgid="6387191794719608122">"Pranešimų garsai"</string>
    <string name="ringtone_unknown" msgid="5059495249862816475">"Nežinoma"</string>
    <string name="wifi_cannot_connect_with_randomized_mac_title" msgid="3638054829636549621">"Nepavyksta prisijungti prie „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_cannot_connect_with_randomized_mac_message" msgid="1660164954255520914">"Palieskite, kad pakeistumėte privatumo nustatymus, ir bandykite dar kartą"</string>
    <string name="wifi_disable_mac_randomization_dialog_title" msgid="2850303108790975442">"Keisti privatumo nustatymą?"</string>
    <string name="wifi_disable_mac_randomization_dialog_message" msgid="2434334967976496565">"„<xliff:g id="SSID_0">%1$s</xliff:g>“ gali norėti prisijungti naudodamas jūsų įrenginio MAC adresą – unikalų identifikatorių. Gali būti, kad tokiu atveju įrenginio vietovę galės stebėti netoliese esantys įrenginiai. \n\nJei tęsite, „<xliff:g id="SSID_1">%1$s</xliff:g>“ pakeis jūsų privatumo nustatymus ir bandys prisijungti iš naujo."</string>
    <string name="wifi_disable_mac_randomization_dialog_confirm_text" msgid="8206498512998282366">"Keisti nustatymą"</string>
    <string name="wifi_disable_mac_randomization_dialog_success" msgid="6654175395681450625">"Nustatymas atnaujintas. Bandykite prisijungti dar kartą."</string>
    <string name="wifi_disable_mac_randomization_dialog_failure" msgid="7028090406806909137">"Nepavyko pakeisti privatumo nustatymo"</string>
    <string name="wifi_disable_mac_randomization_dialog_network_not_found" msgid="6829886686837356040">"Tinklas nerastas"</string>
    <plurals name="wifi_available" formatted="false" msgid="7209257945504714015">
      <item quantity="one">Pasiekiami „Wi-Fi“ tinklai</item>
      <item quantity="few">Pasiekiami „Wi-Fi“ tinklai</item>
      <item quantity="many">Pasiekiami „Wi-Fi“ tinklai</item>
      <item quantity="other">Pasiekiami „Wi-Fi“ tinklai</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1104430011355500386">
      <item quantity="one">Pasiekiami atvirieji „Wi-Fi“ tinklai</item>
      <item quantity="few">Pasiekiami atvirieji „Wi-Fi“ tinklai</item>
      <item quantity="many">Pasiekiami atvirieji „Wi-Fi“ tinklai</item>
      <item quantity="other">Pasiekiami atvirieji „Wi-Fi“ tinklai</item>
    </plurals>
    <string name="wifi_available_title" msgid="722493260955778406">"Prisijunkite prie atviro „Wi‑Fi“ tinklo"</string>
    <string name="wifi_available_carrier_network_title" msgid="7740328884692643968">"Prisijungimas prie operatoriaus „Wi‑Fi“ tinklo"</string>
    <string name="wifi_available_title_connecting" msgid="5249247039230566878">"Jungiamasi prie „Wi-Fi“ tinklo"</string>
    <string name="wifi_available_title_connected" msgid="5892203664604121475">"Prisijungta prie „Wi-Fi“ tinklo"</string>
    <string name="wifi_available_title_failed_to_connect" msgid="5133141923288104331">"Nepavyko prisijungti prie „Wi‑Fi“ tinklo"</string>
    <string name="wifi_available_content_failed_to_connect" msgid="3555247614042954032">"Palieskite, jei norite matyti visus tinklus"</string>
    <string name="wifi_available_action_connect" msgid="924369499736631716">"Prisijungti"</string>
    <string name="wifi_available_action_all_networks" msgid="7759049005868147147">"Visi tinklai"</string>
    <string name="wifi_suggestion_title" msgid="5041459385180298879">"Leisti siūlomus „Wi‑Fi“ tinklus?"</string>
    <string name="wifi_suggestion_content" msgid="477311057093517127">"„<xliff:g id="NAME">%s</xliff:g>“ siūlomi tinklai. Įrenginys gali prisijungti automatiškai."</string>
    <string name="wifi_suggestion_action_allow_app" msgid="6292456946562368121">"Leisti"</string>
    <string name="wifi_suggestion_action_disallow_app" msgid="5544497236277666556">"Ne, ačiū"</string>
    <string name="wifi_wakeup_onboarding_title" msgid="2609831579583316922">"„Wi‑Fi“ bus įjungtas automatiškai"</string>
    <string name="wifi_wakeup_onboarding_subtext" msgid="6802089127390267217">"Kai būsite netoli išsaugoto aukštos kokybės tinklo"</string>
    <string name="wifi_wakeup_onboarding_action_disable" msgid="9093154721154555101">"Neįjunkite vėl"</string>
    <string name="wifi_wakeup_enabled_title" msgid="7983113075476310532">"„Wi‑Fi“ įjungtas automatiškai"</string>
    <string name="wifi_wakeup_enabled_content" msgid="5672823591753088037">"Esate netoli išsaugoto tinklo: <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</string>
    <string name="wifi_available_sign_in" msgid="381054692557675237">"Prisijungti prie „Wi-Fi“ tinklo"</string>
    <string name="network_available_sign_in" msgid="1520342291829283114">"Prisijungti prie tinklo"</string>
    <!-- no translation found for network_available_sign_in_detailed (7520423801613396556) -->
    <skip />
    <string name="wifi_no_internet" msgid="1386911698276448061">"„<xliff:g id="NETWORK_SSID">%1$s</xliff:g>“ negali pasiekti interneto"</string>
    <string name="wifi_no_internet_detailed" msgid="634938444133558942">"Palieskite, kad būtų rodomos parinktys."</string>
    <string name="captive_portal_logged_in_detailed" msgid="3897392681039344376">"Prisijungta"</string>
    <string name="network_partial_connectivity" msgid="4791024923851432291">"„<xliff:g id="NETWORK_SSID">%1$s</xliff:g>“ ryšys apribotas"</string>
    <string name="network_partial_connectivity_detailed" msgid="5741329444564575840">"Palieskite, jei vis tiek norite prisijungti"</string>
    <string name="wifi_softap_config_change" msgid="9101613252632264297">"Viešosios interneto prieigos taško nustatymų pakeitimai"</string>
    <string name="wifi_softap_config_change_summary" msgid="3818290044234944123">"Viešosios prieigos taško dažnio juosta pasikeitė."</string>
    <string name="wifi_softap_config_change_detailed" msgid="2531736378103873579">"Šiame įrenginyje nepalaikoma tik 5 GHz nuostata. Vietoj to šiame įrenginyje bus naudojama 5 GHz dažnio juosta, kai bus pasiekiama."</string>
    <string name="network_switch_metered" msgid="1531869544142283384">"Perjungta į tinklą <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="1358296010128405906">"Įrenginyje naudojamas kitas tinklas (<xliff:g id="NEW_NETWORK">%1$s</xliff:g>), kai dabartiniame tinkle (<xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g>) nėra interneto ryšio. Gali būti taikomi mokesčiai."</string>
    <string name="network_switch_metered_toast" msgid="501662047275723743">"Perjungta iš tinklo <xliff:g id="PREVIOUS_NETWORK">%1$s</xliff:g> į tinklą <xliff:g id="NEW_NETWORK">%2$s</xliff:g>"</string>
  <string-array name="network_switch_type_name">
    <item msgid="2255670471736226365">"mobiliojo ryšio duomenys"</item>
    <item msgid="5520925862115353992">"Wi-Fi"</item>
    <item msgid="1055487873974272842">"Bluetooth"</item>
    <item msgid="1616528372438698248">"Eternetas"</item>
    <item msgid="9177085807664964627">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="3665696841646851068">"nežinomas tinklo tipas"</string>
    <string name="wifi_watchdog_network_disabled" msgid="588755196559781297">"Nepavyko prisijungti prie „Wi-Fi“"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5469207538636315968">" turi prastą interneto ryšį."</string>
    <string name="wifi_connect_alert_title" msgid="2377999802455909057">"Leisti prisijungti?"</string>
    <string name="wifi_connect_alert_message" msgid="169228218944976720">"Programa „%1$s“ nori prisijungti prie „Wi-Fi“ tinklo „%2$s“"</string>
    <string name="wifi_connect_default_application" msgid="7577787709633050605">"Programa"</string>
    <string name="wifi_p2p_dialog_title" msgid="6334579064086920198">"Tiesioginis „Wi-Fi“ ryšys"</string>
    <string name="wifi_p2p_turnon_message" msgid="804818801818052402">"Paleiskite „Wi-Fi Direct“. Bus išjungta „Wi-Fi“ programa / viešosios interneto prieigos taškas."</string>
    <string name="wifi_p2p_failed_message" msgid="6296397512378755690">"Nepavyko paleisti „Wi-Fi Direct“."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="9128862563403191596">"„Wi-Fi Direct“ įjungta"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="5571179544720861510">"Palieskite, kad būtų rodomi nustatymai"</string>
    <string name="accept" msgid="5447154347815825107">"Sutikti"</string>
    <string name="decline" msgid="6490507610282145874">"Atmesti"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="355410493918793111">"Pakvietimas išsiųstas"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="8082524320754820762">"Pakvietimas prisijungti"</string>
    <string name="wifi_p2p_from_message" msgid="8288949679353111893">"Nuo:"</string>
    <string name="wifi_p2p_to_message" msgid="2841587668240064488">"Skirta:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="1020819021188731574">"Įveskite reikiamą PIN kodą:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="3598694912050152976">"PIN kodas:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="6006673840559201871">"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="tv" msgid="1081550817886390524">"TV bus laikinai atjungtas nuo „Wi-Fi“, kai bus prijungtas prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="5357599796604438547">"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="3352797107930786979">"Įterpti simbolį"</string>
    <string name="sms_control_title" msgid="4748684259903148341">"SMS pranešimų siuntimas"</string>
    <string name="sms_control_message" msgid="6574313876316388239">"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="4858845109269524622">"Leisti"</string>
    <string name="sms_control_no" msgid="4845717880040355570">"Uždrausti"</string>
    <string name="sms_short_code_confirm_message" msgid="1385416688897538724">"&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="2723725738333388351">"Taip "<b>"galite būti apmokestinti"</b>" mobiliojo ryšio operatoriaus."</string>
    <string name="sms_premium_short_code_details" msgid="1400296309866638111"><b>"Taip būsite apmokestinti mobiliojo ryšio operatoriaus."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="920477594325526691">"Siųsti"</string>
    <string name="sms_short_code_confirm_deny" msgid="1356917469323768230">"Atšaukti"</string>
    <string name="sms_short_code_remember_choice" msgid="1374526438647744862">"Atsiminti mano pasirinkimą"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="2620984439143080410">"Tai vėliau galėsite pakeisti skiltyje „Nustatymai“ &gt; „Programos“"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="2223014893129755950">"Visada leisti"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="2688828813521652079">"Niekada neleisti"</string>
    <string name="sim_removed_title" msgid="5387212933992546283">"SIM kortelė pašalinta"</string>
    <string name="sim_removed_message" msgid="9051174064474904617">"Mobilusis tinklas bus nepasiekiamas, kol nepaleisite iš naujo įdėję tinkamą SIM kortelę."</string>
    <string name="sim_done_button" msgid="6464250841528410598">"Atlikta"</string>
    <string name="sim_added_title" msgid="7930779986759414595">"SIM kortelė pridėta"</string>
    <string name="sim_added_message" msgid="6602906609509958680">"Jei norite pasiekti mobiliojo ryšio tinklą, reikia iš naujo paleisti įrenginį."</string>
    <string name="sim_restart_button" msgid="8481803851341190038">"Paleisti iš naujo"</string>
    <string name="install_carrier_app_notification_title" msgid="5712723402213090102">"Suaktyvinti mobiliojo ryšio paslaugą"</string>
    <string name="install_carrier_app_notification_text" msgid="2781317581274192728">"Atsisiųskite operatoriaus programą, kad suaktyvintumėte naują SIM"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="4086877327264106484">"Atsisiųskite programą „<xliff:g id="APP_NAME">%1$s</xliff:g>“, kad suaktyvintumėte naują SIM kortelę"</string>
    <string name="install_carrier_app_notification_button" msgid="6257740533102594290">"Atsisiųsti programą"</string>
    <string name="carrier_app_notification_title" msgid="5815477368072060250">"Įdėta nauja SIM kortelė"</string>
    <string name="carrier_app_notification_text" msgid="6567057546341958637">"Jei norite tai nustatyti, palieskite"</string>
    <string name="time_picker_dialog_title" msgid="9053376764985220821">"Nustatyti laiką"</string>
    <string name="date_picker_dialog_title" msgid="5030520449243071926">"Nustatyti datą"</string>
    <string name="date_time_set" msgid="4603445265164486816">"Nustatyti"</string>
    <string name="date_time_done" msgid="8363155889402873463">"Baigta"</string>
    <string name="perms_new_perm_prefix" msgid="6984556020395757087"><font size="12" fgcolor="#ff33b5e5">"NAUJAS: "</font></string>
    <string name="perms_description_app" msgid="2747752389870161996">"Pateikė „<xliff:g id="APP_NAME">%1$s</xliff:g>“."</string>
    <string name="no_permissions" msgid="5729199278862516390">"Nereikia leidimų"</string>
    <string name="perm_costs_money" msgid="749054595022779685">"tai gali kainuoti"</string>
    <string name="dlg_ok" msgid="5103447663504839312">"Gerai"</string>
    <string name="usb_charging_notification_title" msgid="1674124518282666955">"Šis įrenginys įkraunamas naudojant USB"</string>
    <string name="usb_supplying_notification_title" msgid="5378546632408101811">"Prijungtas įrenginys įkraunamas naudojant USB"</string>
    <string name="usb_mtp_notification_title" msgid="1065989144124499810">"USB failų perkėlimas įjungtas"</string>
    <string name="usb_ptp_notification_title" msgid="5043437571863443281">"PTP režimas naudojant USB įjungtas"</string>
    <string name="usb_tether_notification_title" msgid="8828527870612663771">"USB įrenginio kaip modemo naudojimas įjungtas"</string>
    <string name="usb_midi_notification_title" msgid="7404506788950595557">"MIDI režimas naudojant USB įjungtas"</string>
    <string name="usb_accessory_notification_title" msgid="1385394660861956980">"Prijungtas USB priedas"</string>
    <string name="usb_notification_message" msgid="4715163067192110676">"Palieskite, kad būtų rodoma daugiau parinkčių."</string>
    <string name="usb_power_notification_message" msgid="7284765627437897702">"Įkraunamas prijungtas įrenginys. Palieskite, jei reikia daugiau parinkčių."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="2335775548086533065">"Aptiktas analoginis garso priedas"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="1300168007129796621">"Prijungtas įrenginys nesuderinamas su šiuo telefonu. Palieskite, kad sužinotumėte daugiau."</string>
    <string name="adb_active_notification_title" msgid="408390247354560331">"USB derinimas prijungtas"</string>
    <string name="adb_active_notification_message" msgid="5617264033476778211">"Palieskite, kad išjungtumėte USB derinimą"</string>
    <string name="adb_active_notification_message" product="tv" msgid="6624498401272780855">"Pasirinkite, kas išjungtumėte USB derinimą."</string>
    <string name="test_harness_mode_notification_title" msgid="2282785860014142511">"Testavimo sistemos režimas įgalintas"</string>
    <string name="test_harness_mode_notification_message" msgid="3039123743127958420">"Atkurkite gamyklinius duomenis, kad išjungtumėte testavimo sistemos režimą."</string>
    <string name="usb_contaminant_detected_title" msgid="4359048603069159678">"USB prievade yra skysčių ar smulkių dalelių"</string>
    <string name="usb_contaminant_detected_message" msgid="7346100585390795743">"USB prievadas automatiškai išjungtas. Palieskite, kad sužinotumėte daugiau."</string>
    <string name="usb_contaminant_not_detected_title" msgid="2651167729563264053">"Saugu naudoti USB prievadą"</string>
    <string name="usb_contaminant_not_detected_message" msgid="892863190942660462">"Telefonas nebeaptinka skysčių ar smulkių dalelių."</string>
    <string name="taking_remote_bugreport_notification_title" msgid="1582531382166919850">"Pateikiamas pranešimas apie riktą…"</string>
    <string name="share_remote_bugreport_notification_title" msgid="6708897723753334999">"Bendrinti pranešimą apie riktą?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="3077385149217638550">"Bendrinamas pranešimas apie riktą..."</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="7325635795739260135">"Jūsų administratorius pateikė pranešimo apie riktą užklausą, kad galėtų padėti pašalinti triktis šiame įrenginyje. Programos ir duomenys gali būti bendrinami."</string>
    <string name="share_remote_bugreport_action" msgid="7630880678785123682">"BENDRINTI"</string>
    <string name="decline_remote_bugreport_action" msgid="4040894777519784346">"ATMESTI"</string>
    <string name="select_input_method" msgid="3971267998568587025">"Pasirinkite įvesties metodą"</string>
    <string name="show_ime" msgid="6406112007347443383">"Palikti ekrane, kol fizinė klaviatūra aktyvi"</string>
    <string name="hardware" msgid="1800597768237606953">"Rodyti virtualiąją klaviatūrą"</string>
    <string name="select_keyboard_layout_notification_title" msgid="4427643867639774118">"Fizinės klaviatūros konfigūravimas"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8835158247369158154">"Palieskite, kad pasirinktumėte kalbą ir išdėstymą"</string>
    <string name="fast_scroll_alphabet" msgid="8854435958703888376">" AĄBCČDEĘĖFGHIĮYJKLMNOPRSŠTUŲŪVZŽ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="2529539945421557329">" 0123456789AĄBCČDEĘĖFGHIĮYJKLMNOPRSŠTUŲŪVZŽ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="6063891141815714246">"Rodoma virš kitų programų"</string>
    <string name="alert_windows_notification_channel_name" msgid="3437528564303192620">"<xliff:g id="NAME">%s</xliff:g> rodomi virš kitų programų"</string>
    <string name="alert_windows_notification_title" msgid="6331662751095228536">"<xliff:g id="NAME">%s</xliff:g> rodomi virš kitų programų."</string>
    <string name="alert_windows_notification_message" msgid="6538171456970725333">"Jei nenorite, kad <xliff:g id="NAME">%s</xliff:g> naudotų šią funkciją, palietę atidarykite nustatymus ir išjunkite ją."</string>
    <string name="alert_windows_notification_turn_off_action" msgid="7805857234839123780">"Išjungti"</string>
    <string name="ext_media_checking_notification_title" msgid="8299199995416510094">"Tikrinama išorinė laikmena (<xliff:g id="NAME">%s</xliff:g>)…"</string>
    <string name="ext_media_checking_notification_message" msgid="2231566971425375542">"Peržiūrimas dabartinis turinys"</string>
    <string name="ext_media_new_notification_title" msgid="3517407571407687677">"Nauja laikmena (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="ext_media_new_notification_message" msgid="6095403121990786986">"Palieskite, kad nustatytumėte"</string>
    <string name="ext_media_ready_notification_message" msgid="777258143284919261">"Norint perkelti nuotraukas ir mediją"</string>
    <string name="ext_media_unmountable_notification_title" msgid="4895444667278979910">"Kilo problema dėl laikmenos (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="ext_media_unmountable_notification_message" msgid="3256290114063126205">"Palieskite ir ištaisykite tai"</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3003611129979934633">"<xliff:g id="NAME">%s</xliff:g> sugadinta. Pasirinkite, kad pataisytumėte."</string>
    <string name="ext_media_unsupported_notification_title" msgid="4358280700537030333">"Nepalaikoma saugykla (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="ext_media_unsupported_notification_message" msgid="917738524888367560">"Šis įrenginys nepalaiko šios <xliff:g id="NAME">%s</xliff:g>. Palieskite, kad nustatytumėte palaikomu formatu."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="7744945987775645685">"Šis įrenginys nepalaiko šios <xliff:g id="NAME">%s</xliff:g>. Pasirinkite ir nustatykite palaikomu formatu."</string>
    <string name="ext_media_badremoval_notification_title" msgid="4114625551266196872">"<xliff:g id="NAME">%s</xliff:g> netikėtai pašalinta"</string>
    <string name="ext_media_badremoval_notification_message" msgid="1986514704499809244">"Prieš šalindami išimkite laikmeną, kad neprarastumėte turinio"</string>
    <string name="ext_media_nomedia_notification_title" msgid="742671636376975890">"Laikmena (<xliff:g id="NAME">%s</xliff:g>) atjungta"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2832724384636625852">"Kai kurios funkcijos gali neveikti tinkamai. Įdėkite naują saugyklą."</string>
    <string name="ext_media_unmounting_notification_title" msgid="4147986383917892162">"Pašalinama laikmena (<xliff:g id="NAME">%s</xliff:g>)…"</string>
    <string name="ext_media_unmounting_notification_message" msgid="5717036261538754203">"Neatjunkite"</string>
    <string name="ext_media_init_action" msgid="2312974060585056709">"Nustatyti"</string>
    <string name="ext_media_unmount_action" msgid="966992232088442745">"Pašalinti"</string>
    <string name="ext_media_browse_action" msgid="344865351947079139">"Naršyti"</string>
    <string name="ext_media_seamless_action" msgid="8837030226009268080">"Išvesties perjungimas"</string>
    <string name="ext_media_missing_title" msgid="3209472091220515046">"Trūksta <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_missing_message" msgid="4408988706227922909">"Įdėkite įrenginį dar kartą"</string>
    <string name="ext_media_move_specific_title" msgid="8492118544775964250">"Perkeliama programa „<xliff:g id="NAME">%s</xliff:g>“"</string>
    <string name="ext_media_move_title" msgid="2682741525619033637">"Perkeliami duomenys"</string>
    <string name="ext_media_move_success_title" msgid="4901763082647316767">"Turinio perkėlimas baigtas"</string>
    <string name="ext_media_move_success_message" msgid="9159542002276982979">"Turinys perkeltas į saugyklą (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="ext_media_move_failure_title" msgid="3184577479181333665">"Turinio perkelti nepavyko"</string>
    <string name="ext_media_move_failure_message" msgid="4197306718121869335">"Bandykite perkelti turinį dar kartą"</string>
    <string name="ext_media_status_removed" msgid="241223931135751691">"Pašalinta"</string>
    <string name="ext_media_status_unmounted" msgid="8145812017295835941">"Pašalinta"</string>
    <string name="ext_media_status_checking" msgid="159013362442090347">"Tikrinama…"</string>
    <string name="ext_media_status_mounted" msgid="3459448555811203459">"Parengta"</string>
    <string name="ext_media_status_mounted_ro" msgid="1974809199760086956">"Tik skaitoma"</string>
    <string name="ext_media_status_bad_removal" msgid="508448566481406245">"Pašalinta nesaugiai"</string>
    <string name="ext_media_status_unmountable" msgid="7043574843541087748">"Sugadinta"</string>
    <string name="ext_media_status_unsupported" msgid="5460509911660539317">"Nepalaikoma"</string>
    <string name="ext_media_status_ejecting" msgid="7532403368044013797">"Pašalinama…"</string>
    <string name="ext_media_status_formatting" msgid="774148701503179906">"Formatuojama…"</string>
    <string name="ext_media_status_missing" msgid="6520746443048867314">"Neįdėta"</string>
    <string name="activity_list_empty" msgid="4219430010716034252">"Nerasta atitinkančios veiklos."</string>
    <string name="permlab_route_media_output" msgid="8048124531439513118">"nukreipti medijos išvestį"</string>
    <string name="permdesc_route_media_output" msgid="1759683269387729675">"Leidžiama programai nukreipti medijos išvestį į kitus išorinius įrenginius."</string>
    <string name="permlab_readInstallSessions" msgid="7279049337895583621">"skaityti diegimo sesijas"</string>
    <string name="permdesc_readInstallSessions" msgid="4012608316610763473">"Leidžiama programai skaityti diegimo seansus. Leidžiama peržiūrėti išsamią aktyvių paketų diegimo informaciją."</string>
    <string name="permlab_requestInstallPackages" msgid="7600020863445351154">"pateikti užklausą dėl diegimo paketų"</string>
    <string name="permdesc_requestInstallPackages" msgid="3969369278325313067">"Programai leidžiama pateikti užklausą dėl paketų diegimo."</string>
    <string name="permlab_requestDeletePackages" msgid="2541172829260106795">"paketo ištrynimo užklausa"</string>
    <string name="permdesc_requestDeletePackages" msgid="6133633516423860381">"Programai leidžiama pateikti užklausą dėl paketų ištrynimo."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="7646611326036631439">"prašyti nepaisyti akumuliatoriaus optimizavimo nustatymų"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="634260656917874356">"Programai leidžiama prašyti leidimo nepaisyti tai programai skirto akumuliatoriaus optimizavimo nustatymų."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1842872462124648678">"Bakstelėkite du kartus, kad valdytumėte mastelio keitimą"</string>
    <string name="gadget_host_error_inflating" msgid="2449961590495198720">"Nepavyko pridėti."</string>
    <string name="ime_action_go" msgid="5536744546326495436">"Pradėti"</string>
    <string name="ime_action_search" msgid="4501435960587287668">"Ieškoti"</string>
    <string name="ime_action_send" msgid="8456843745664334138">"Siųsti"</string>
    <string name="ime_action_next" msgid="4169702997635728543">"Kitas"</string>
    <string name="ime_action_done" msgid="6299921014822891569">"Atlikta"</string>
    <string name="ime_action_previous" msgid="6548799326860401611">"Perž."</string>
    <string name="ime_action_default" msgid="8265027027659800121">"Vykdyti"</string>
    <string name="dial_number_using" msgid="6060769078933953531">"Rinkti numerį \nnaudojant <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="6200708808003692594">"Sukurti adresatą\nnaudojant <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="5365733888842570481">"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="1886710210516246461">"Ar norite leisti šią užklausą?"</string>
    <string name="grant_permissions_header_text" msgid="3420736827804657201">"Užklausa dėl prieigos"</string>
    <string name="allow" msgid="6195617008611933762">"Leisti"</string>
    <string name="deny" msgid="6632259981847676572">"Atmesti"</string>
    <string name="permission_request_notification_title" msgid="1810025922441048273">"Pateikta užklausa dėl leidimo"</string>
    <string name="permission_request_notification_with_subtitle" msgid="3743417870360129298">"Pateikta leidimo užklausa\ndėl <xliff:g id="ACCOUNT">%s</xliff:g> paskyros"</string>
    <string name="forward_intent_to_owner" msgid="4620359037192871015">"Šią programą naudojate ne darbo profilyje"</string>
    <string name="forward_intent_to_work" msgid="3620262405636021151">"Šią programą naudojate darbo profilyje"</string>
    <string name="input_method_binding_label" msgid="1166731601721983656">"Įvesties būdas"</string>
    <string name="sync_binding_label" msgid="469249309424662147">"Sinchronizuoti"</string>
    <string name="accessibility_binding_label" msgid="1974602776545801715">"Pasiekiamumas"</string>
    <string name="wallpaper_binding_label" msgid="1197440498000786738">"Darbalaukio fonas"</string>
    <string name="chooser_wallpaper" msgid="3082405680079923708">"Keisti darbalaukio foną"</string>
    <string name="notification_listener_binding_label" msgid="2702165274471499713">"Pranešimų skaitymo priemonė"</string>
    <string name="vr_listener_binding_label" msgid="8013112996671206429">"Virtualiosios realybės apdorojimo priemonė"</string>
    <string name="condition_provider_service_binding_label" msgid="8490641013951857673">"Sąlygos teikėjas"</string>
    <string name="notification_ranker_binding_label" msgid="432708245635563763">"Pranešimų reitingavimo paslauga"</string>
    <string name="vpn_title" msgid="5906991595291514182">"VPN suaktyvintas"</string>
    <string name="vpn_title_long" msgid="6834144390504619998">"VPN suaktyvino „<xliff:g id="APP">%s</xliff:g>“"</string>
    <string name="vpn_text" msgid="2275388920267251078">"Jei norite valdyti tinklą, palieskite."</string>
    <string name="vpn_text_long" msgid="278540576806169831">"Prisijungta prie <xliff:g id="SESSION">%s</xliff:g>. Jei norite valdyti tinklą, palieskite."</string>
    <string name="vpn_lockdown_connecting" msgid="6096725311950342607">"Prisijungiama prie visada įjungto VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="2853127976590658469">"Prisijungta prie visada įjungto VPN"</string>
    <string name="vpn_lockdown_disconnected" msgid="5573611651300764955">"Atsijungta nuo visada įjungto VPN"</string>
    <string name="vpn_lockdown_error" msgid="4453048646854247947">"Prisijungti prie visada įjungto VPN nepavyko"</string>
    <string name="vpn_lockdown_config" msgid="8331697329868252169">"Keiskite tinklo arba VPN nustatymus"</string>
    <string name="upload_file" msgid="8651942222301634271">"Pasirinkti failą"</string>
    <string name="no_file_chosen" msgid="4146295695162318057">"Nepasirinktas joks failas"</string>
    <string name="reset" msgid="3865826612628171429">"Atstatyti"</string>
    <string name="submit" msgid="862795280643405865">"Pateikti"</string>
    <string name="car_mode_disable_notification_title" msgid="8450693275833142896">"Veikia vairavimo programa"</string>
    <string name="car_mode_disable_notification_message" msgid="8954550232288567515">"Palieskite, kad išeitumėte iš vairavimo programos."</string>
    <string name="tethered_notification_title" msgid="2700523927485687353">"Susietas ar aktyvus"</string>
    <string name="tethered_notification_message" msgid="6228080755828019453">"Palieskite, kad nustatytumėte."</string>
    <string name="disable_tether_notification_title" msgid="7158047514545848391">"Įrenginio kaip modemo naudojimas išjungtas"</string>
    <string name="disable_tether_notification_message" msgid="98281313984014775">"Jei reikia išsamios informacijos, susisiekite su administratoriumi"</string>
    <string name="back_button_label" msgid="4078224038025043387">"Atgal"</string>
    <string name="next_button_label" msgid="6040209156399907780">"Kitas"</string>
    <string name="skip_button_label" msgid="3566599811326688389">"Praleisti"</string>
    <string name="no_matches" msgid="6472699895759164599">"Nėra atitikčių"</string>
    <string name="find_on_page" msgid="5400537367077438198">"Ieškoti puslapyje"</string>
    <plurals name="matches_found" formatted="false" msgid="1101758718194295554">
      <item quantity="one"><xliff:g id="INDEX">%d</xliff:g> iš <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="few"><xliff:g id="INDEX">%d</xliff:g> iš <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="many"><xliff:g id="INDEX">%d</xliff:g> iš <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> iš <xliff:g id="TOTAL">%d</xliff:g></item>
    </plurals>
    <string name="action_mode_done" msgid="2536182504764803222">"Atlikta"</string>
    <string name="progress_erasing" msgid="6891435992721028004">"Ištrinama bendrinama saugykla…"</string>
    <string name="share" msgid="4157615043345227321">"Bendrinti"</string>
    <string name="find" msgid="5015737188624767706">"Ieškoti"</string>
    <string name="websearch" msgid="5624340204512793290">"Žiniat. paieška"</string>
    <string name="find_next" msgid="5341217051549648153">"Rasti kitą"</string>
    <string name="find_previous" msgid="4405898398141275532">"Rasti ankstesnį"</string>
    <string name="gpsNotifTicker" msgid="3207361857637620780">"Vietos užklausa iš <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="1590033371665669570">"Vietos užklausa"</string>
    <string name="gpsNotifMessage" msgid="7346649122793758032">"Užklausą pateikė <xliff:g id="NAME">%1$s</xliff:g> („<xliff:g id="SERVICE">%2$s</xliff:g>“)"</string>
    <string name="gpsVerifYes" msgid="3719843080744112940">"Taip"</string>
    <string name="gpsVerifNo" msgid="1671201856091564741">"Ne"</string>
    <string name="sync_too_many_deletes" msgid="6999440774578705300">"Viršytas ištrynimo apribojimas"</string>
    <string name="sync_too_many_deletes_desc" msgid="7409327940303504440">"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="5657871730315579051">"Ištrinti elementus"</string>
    <string name="sync_undo_deletes" msgid="5786033331266418896">"Anuliuoti ištrynimus"</string>
    <string name="sync_do_nothing" msgid="4528734662446469646">"Kol kas nieko nedaryti"</string>
    <string name="choose_account_label" msgid="5557833752759831548">"Pasirinkti paskyrą"</string>
    <string name="add_account_label" msgid="4067610644298737417">"Pridėti paskyrą"</string>
    <string name="add_account_button_label" msgid="322390749416414097">"Pridėti paskyrą"</string>
    <string name="number_picker_increment_button" msgid="7621013714795186298">"Padidinti"</string>
    <string name="number_picker_decrement_button" msgid="5116948444762708204">"Sumažinti"</string>
    <string name="number_picker_increment_scroll_mode" msgid="8403893549806805985">"<xliff:g id="VALUE">%s</xliff:g> palieskite ir palaikykite."</string>
    <string name="number_picker_increment_scroll_action" msgid="8310191318914268271">"Slinkite aukštyn, kad padidintumėte, ir žemyn, kad sumažintumėte."</string>
    <string name="time_picker_increment_minute_button" msgid="7195870222945784300">"Padidinti minučių skaičių"</string>
    <string name="time_picker_decrement_minute_button" msgid="230925389943411490">"Sumažinti minučių skaičių"</string>
    <string name="time_picker_increment_hour_button" msgid="3063572723197178242">"Padidinti valandų skaičių"</string>
    <string name="time_picker_decrement_hour_button" msgid="584101766855054412">"Sumažinti valandų skaičių"</string>
    <string name="time_picker_increment_set_pm_button" msgid="5889149366900376419">"Nustatyti po pusiaudienio"</string>
    <string name="time_picker_decrement_set_am_button" msgid="1422608001541064087">"Nustatyti prieš pusiaudienį"</string>
    <string name="date_picker_increment_month_button" msgid="3447263316096060309">"Padidinti mėnesių skaičių"</string>
    <string name="date_picker_decrement_month_button" msgid="6531888937036883014">"Sumažinti mėnesių skaičių"</string>
    <string name="date_picker_increment_day_button" msgid="4349336637188534259">"Padidinti dienų skaičių"</string>
    <string name="date_picker_decrement_day_button" msgid="6840253837656637248">"Sumažinti dienų skaičių"</string>
    <string name="date_picker_increment_year_button" msgid="7608128783435372594">"Padidinti metų skaičių"</string>
    <string name="date_picker_decrement_year_button" msgid="4102586521754172684">"Sumažinti metų skaičių"</string>
    <string name="date_picker_prev_month_button" msgid="3418694374017868369">"Ankstesnis mėnuo"</string>
    <string name="date_picker_next_month_button" msgid="4858207337779144840">"Kitas mėnuo"</string>
    <string name="keyboardview_keycode_alt" msgid="8997420058584292385">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="2134624484115716975">"Atšaukti"</string>
    <string name="keyboardview_keycode_delete" msgid="2661117313730098650">"Ištrinti"</string>
    <string name="keyboardview_keycode_done" msgid="2524518019001653851">"Atlikta"</string>
    <string name="keyboardview_keycode_mode_change" msgid="2743735349997999020">"Režimo keitimas"</string>
    <string name="keyboardview_keycode_shift" msgid="3026509237043975573">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="168054869339091055">"Įvesti"</string>
    <string name="activitychooserview_choose_application" msgid="3500574466367891463">"Pasirinkite programą"</string>
    <string name="activitychooserview_choose_application_error" msgid="6937782107559241734">"Nepavyko paleisti „<xliff:g id="APPLICATION_NAME">%s</xliff:g>“"</string>
    <string name="shareactionprovider_share_with" msgid="2753089758467748982">"Bendrinti su"</string>
    <string name="shareactionprovider_share_with_application" msgid="4902832247173666973">"Bendrinti su „<xliff:g id="APPLICATION_NAME">%s</xliff:g>“"</string>
    <string name="content_description_sliding_handle" msgid="982510275422590757">"Slydimo valdymas. Palieskite ir laikykite."</string>
    <string name="description_target_unlock_tablet" msgid="7431571180065859551">"Perbraukite pirštu, kad atrakintumėte."</string>
    <string name="action_bar_home_description" msgid="1501655419158631974">"Naršyti pagrindinį puslapį"</string>
    <string name="action_bar_up_description" msgid="6611579697195026932">"Naršyti į viršų"</string>
    <string name="action_menu_overflow_description" msgid="4579536843510088170">"Daugiau parinkčių"</string>
    <string name="action_bar_home_description_format" msgid="5087107531331621803">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="4346835454749569826">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="8490227947584914460">"Vidinė bendroji atmintis"</string>
    <string name="storage_sd_card" msgid="3404740277075331881">"SD kortelė"</string>
    <string name="storage_sd_card_label" msgid="7526153141147470509">"„<xliff:g id="MANUFACTURER">%s</xliff:g>“ SD kortelė"</string>
    <string name="storage_usb_drive" msgid="448030813201444573">"Atmintukas"</string>
    <string name="storage_usb_drive_label" msgid="6631740655876540521">"„<xliff:g id="MANUFACTURER">%s</xliff:g>“ atmintukas"</string>
    <string name="storage_usb" msgid="2391213347883616886">"USB atmintis"</string>
    <string name="extract_edit_menu_button" msgid="63954536535863040">"Redaguoti"</string>
    <string name="data_usage_warning_title" msgid="9034893717078325845">"Duomenų įspėjimas"</string>
    <string name="data_usage_warning_body" msgid="1669325367188029454">"Sunaudojote duomenų: <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="data_usage_mobile_limit_title" msgid="3911447354393775241">"Pasiek. mob. ryšio duom. limitas"</string>
    <string name="data_usage_wifi_limit_title" msgid="2069698056520812232">"Pasiektas „Wi-Fi“ duomenų apribojimas"</string>
    <string name="data_usage_limit_body" msgid="3567699582000085710">"Duomenų naudojimas pristabdytas iki jūsų ciklo pabaigos"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="101888478915677895">"Viršijote mob. r. duom. aprib."</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="1622359254521960508">"Viršijote „Wi-Fi“ duom. aprib."</string>
    <string name="data_usage_limit_snoozed_body" msgid="545146591766765678">"Viršijote nustatytą apribojimą (<xliff:g id="SIZE">%s</xliff:g>)"</string>
    <string name="data_usage_restricted_title" msgid="126711424380051268">"Apriboti foniniai duomenys"</string>
    <string name="data_usage_restricted_body" msgid="5338694433686077733">"Palieskite ir pašal. apribojimą."</string>
    <string name="data_usage_rapid_title" msgid="2950192123248740375">"Didelis mob. ryšio duom. naud."</string>
    <string name="data_usage_rapid_body" msgid="3886676853263693432">"Programos sunaudojo daugiau duomenų nei įprastai"</string>
    <string name="data_usage_rapid_app_body" msgid="5425779218506513861">"Programa „<xliff:g id="APP">%s</xliff:g>“ sunaudojo daugiau duomenų nei įprastai"</string>
    <string name="ssl_certificate" msgid="5690020361307261997">"Saugos sertifikatas"</string>
    <string name="ssl_certificate_is_valid" msgid="7293675884598527081">"Šis sertifikatas galioja."</string>
    <string name="issued_to" msgid="5975877665505297662">"Išduota:"</string>
    <string name="common_name" msgid="1486334593631798443">"Bendras pavadinimas:"</string>
    <string name="org_name" msgid="7526331696464255245">"Organizacija:"</string>
    <string name="org_unit" msgid="995934486977223076">"Organizacinis vienetas:"</string>
    <string name="issued_by" msgid="7872459822431585684">"Išdavė:"</string>
    <string name="validity_period" msgid="1717724283033175968">"Galiojimas:"</string>
    <string name="issued_on" msgid="5855489688152497307">"Išduota:"</string>
    <string name="expires_on" msgid="1623640879705103121">"Galiojimas baigiasi:"</string>
    <string name="serial_number" msgid="3479576915806623429">"Serijos numeris:"</string>
    <string name="fingerprints" msgid="148690767172613723">"Kontroliniai kodai"</string>
    <string name="sha256_fingerprint" msgid="7103976380961964600">"SHA-256 piršto antspaudas"</string>
    <string name="sha1_fingerprint" msgid="2339915142825390774">"SHA-1 piršto antspaudas"</string>
    <string name="activity_chooser_view_see_all" msgid="3917045206812726099">"Žr. viską"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="8880731437191978314">"Pasirinkti veiklą"</string>
    <string name="share_action_provider_share_with" msgid="1904096863622941880">"Bendrinti su"</string>
    <string name="sending" msgid="206925243621664438">"Siunčiama…"</string>
    <string name="launchBrowserDefault" msgid="6328349989932924119">"Paleisti naršyklę?"</string>
    <string name="SetupCallDefault" msgid="5581740063237175247">"Priimti skambutį?"</string>
    <string name="activity_resolver_use_always" msgid="5575222334666843269">"Visada"</string>
    <string name="activity_resolver_set_always" msgid="4142825808921411476">"Nustatyti parinktį „Visada atidaryti“"</string>
    <string name="activity_resolver_use_once" msgid="948462794469672658">"Tik kartą"</string>
    <string name="activity_resolver_app_settings" msgid="6758823206817748026">"Nustatymai"</string>
    <string name="activity_resolver_work_profiles_support" msgid="4071345609235361269">"%1$s nepalaiko darbo profilio"</string>
    <string name="default_audio_route_name" product="tablet" msgid="367936735632195517">"Planšetinis kompiuteris"</string>
    <string name="default_audio_route_name" product="tv" msgid="4908971385068087367">"TV"</string>
    <string name="default_audio_route_name" product="default" msgid="9213546147739983977">"Telefonas"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="1551166029093995289">"Doko garsiakalbiai"</string>
    <string name="default_audio_route_name_hdmi" msgid="5474470558160717850">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="6954070994792640762">"Ausinės"</string>
    <string name="default_audio_route_name_usb" msgid="895668743163316932">"USB"</string>
    <string name="default_audio_route_category_name" msgid="5241740395748134483">"Sistema"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="4214648773120426288">"„Bluetooth“ garsas"</string>
    <string name="wireless_display_route_description" msgid="8297563323032966831">"Belaidis rodymas"</string>
    <string name="media_route_button_content_description" msgid="2299223698196869956">"Perduoti"</string>
    <string name="media_route_chooser_title" msgid="6646594924991269208">"Prijungimas prie įrenginio"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3105906508794326446">"Perduoti ekraną į įrenginį"</string>
    <string name="media_route_chooser_searching" msgid="6119673534251329535">"Ieškoma įrenginių…"</string>
    <string name="media_route_chooser_extended_settings" msgid="2506352159381327741">"Nustatymai"</string>
    <string name="media_route_controller_disconnect" msgid="7362617572732576959">"Atjungti"</string>
    <string name="media_route_status_scanning" msgid="8045156315309594482">"Nuskaitoma..."</string>
    <string name="media_route_status_connecting" msgid="5845597961412010540">"Jungiama..."</string>
    <string name="media_route_status_available" msgid="1477537663492007608">"Pasiekiama"</string>
    <string name="media_route_status_not_available" msgid="480912417977515261">"Nepasiekiama"</string>
    <string name="media_route_status_in_use" msgid="6684112905244944724">"Naudojama"</string>
    <string name="display_manager_built_in_display_name" msgid="1015775198829722440">"Integruotas ekranas"</string>
    <string name="display_manager_hdmi_display_name" msgid="1022758026251534975">"HDMI ekranas"</string>
    <string name="display_manager_overlay_display_name" msgid="5306088205181005861">"Perdanga nr. <xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="1480158037150469170">"„<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="2810034719482834679">", saugu"</string>
    <string name="kg_forgot_pattern_button_text" msgid="406145459223122537">"Pamiršau atrakinimo piešinį"</string>
    <string name="kg_wrong_pattern" msgid="1342812634464179931">"Netinkamas atrakinimo piešinys"</string>
    <string name="kg_wrong_password" msgid="2384677900494439426">"Netinkamas slaptažodis"</string>
    <string name="kg_wrong_pin" msgid="3680925703673166482">"Netinkamas PIN kodas"</string>
    <plurals name="kg_too_many_failed_attempts_countdown" formatted="false" msgid="236717428673283568">
      <item quantity="one">Bandykite dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sekundės.</item>
      <item quantity="few">Bandykite dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sekundžių.</item>
      <item quantity="many">Bandykite dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sekundės.</item>
      <item quantity="other">Bandykite dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sekundžių.</item>
    </plurals>
    <string name="kg_pattern_instructions" msgid="8366024510502517748">"Nupieškite atrakinimo piešinį"</string>
    <string name="kg_sim_pin_instructions" msgid="6479401489471690359">"Įveskite SIM PIN kodą"</string>
    <string name="kg_pin_instructions" msgid="7355933174673539021">"Įveskite PIN kodą"</string>
    <string name="kg_password_instructions" msgid="7179782578809398050">"Įveskite slaptažodį"</string>
    <string name="kg_puk_enter_puk_hint" msgid="6696187482616360994">"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="8190982314659429770">"Įveskite pageidaujamą PIN kodą"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="6372557107414074580">"Patvirtinkite pageidaujamą PIN kodą"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8871937892678885545">"Atrakinama SIM kortelė…"</string>
    <string name="kg_password_wrong_pin_code" msgid="9013856346870572451">"Netinkamas PIN kodas."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="4821601451222564077">"Įveskite PIN kodą, sudarytą iš 4–8 skaičių."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="2539364558870734339">"PUK kodą turi sudaryti 8 skaičiai."</string>
    <string name="kg_invalid_puk" msgid="4809502818518963344">"Pakartotinai įveskite tinkamą PUK kodą. Pakartotinai bandant SIM bus neleidžiama visam laikui."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="4705368340409816254">"PIN kodai neatitinka"</string>
    <string name="kg_login_too_many_attempts" msgid="699292728290654121">"Per daug atrakinimo piešinių bandymų"</string>
    <string name="kg_login_instructions" msgid="3619844310339066827">"Jei norite atrakinti, prisijunkite naudodami „Google“ paskyrą."</string>
    <string name="kg_login_username_hint" msgid="1765453775467133251">"Naudotojo vardas (el. paštas)"</string>
    <string name="kg_login_password_hint" msgid="3330530727273164402">"Slaptažodis"</string>
    <string name="kg_login_submit_button" msgid="893611277617096870">"Prisijungti"</string>
    <string name="kg_login_invalid_input" msgid="8292367491901220210">"Netinkamas naudotojo vardas ar slaptažodis."</string>
    <string name="kg_login_account_recovery_hint" msgid="4892466171043541248">"Pamiršote naudotojo vardą ar slaptažodį?\nApsilankykite šiuo adresu: "<b>"google.com/accounts/recovery"</b></string>
    <string name="kg_login_checking_password" msgid="4676010303243317253">"Tikrinama paskyra…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="23741434207544038">"PIN kodą netinkamai įvedėte <xliff:g id="NUMBER_0">%1$d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%2$d</xliff:g> sek."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="3328686432962224215">"Neteisingai įvedėte slaptažodį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%2$d</xliff:g> sek."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="7357404233979139075">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. \n\nBandykite dar kartą po <xliff:g id="NUMBER_1">%2$d</xliff:g> sek."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="3479940221343361587">"<xliff:g id="NUMBER_0">%1$d</xliff:g> k. bandėte netinkamai atrakinti planšetinį kompiuterį. Po dar <xliff:g id="NUMBER_1">%2$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="tv" msgid="7525614240870652051">"Netinkamai bandėte atrakinti TV <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Dar po <xliff:g id="NUMBER_1">%2$d</xliff:g> nesėkming. bandym. bus atkurti gamykliniai TV nustatymai, o visi naudotojo duomenys bus prarasti."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="5955398963754432548">"<xliff:g id="NUMBER_0">%1$d</xliff:g> k. bandėte netinkamai atrakinti telefoną. Po dar <xliff:g id="NUMBER_1">%2$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="2299099385175083308">"<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="tv" msgid="5213981402777341134">"Netinkamai bandėte atrakinti TV <xliff:g id="NUMBER">%d</xliff:g> k. Dabar bus atkurti gamykliniai TV nustatymai."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="5043730590446071189">"<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="7086799295109717623">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%2$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">%3$d</xliff:g> sek."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="8057874855853116724">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Dar po <xliff:g id="NUMBER_1">%2$d</xliff:g> nesėkming. bandym. būsite paprašyti atrakinti TV naudodami el. pašto paskyrą.\n\n Bandykite dar kartą už <xliff:g id="NUMBER_2">%3$d</xliff:g> sek."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="5270861875006378092">"Netinkamai nupiešėte atrakinimo piešinį <xliff:g id="NUMBER_0">%1$d</xliff:g> k. Po dar <xliff:g id="NUMBER_1">%2$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">%3$d</xliff:g> sek."</string>
    <string name="kg_text_message_separator" product="default" msgid="4503708889934976866">" – "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="2034358143731750914">"Pašalinti"</string>
    <string name="safe_media_volume_warning" product="default" msgid="3751676824423049994">"Padidinti garsą daugiau nei rekomenduojamas lygis?\n\nIlgai klausydami dideliu garsu galite pažeisti klausą."</string>
    <string name="accessibility_shortcut_warning_dialog_title" msgid="4017995837692622933">"Naudoti spartųjį pritaikymo neįgaliesiems klavišą?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="8306239551412868396">"Kai spartusis klavišas įjungtas, spaudžiant abu garsumo mygtukus 3 sekundes bus paleista pritaikymo neįgaliesiems funkcija.\n\n Dabartinė pritaikymo neįgaliesiems funkcija:\n <xliff:g id="SERVICE_NAME">%1$s</xliff:g>„\n“\n Funkciją galite pakeisti skiltyje „Nustatymai“ &gt; „Pritaikymas neįgaliesiems“."</string>
    <string name="disable_accessibility_shortcut" msgid="5806091378745232383">"Išjungti spartųjį klavišą"</string>
    <string name="leave_accessibility_shortcut_on" msgid="6543362062336990814">"Naudoti spartųjį klavišą"</string>
    <string name="color_inversion_feature_name" msgid="326050048927789012">"Spalvų inversija"</string>
    <string name="color_correction_feature_name" msgid="3655077237805422597">"Spalvų taisymas"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="6141620395915529473">"Pritaikymo neįgaliesiems sparčiuoju klavišu buvo įjungta „<xliff:g id="SERVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="accessibility_shortcut_disabling_service" msgid="1287340429965172651">"Pritaikymo neįgaliesiems sparčiuoju klavišu buvo išjungta „<xliff:g id="SERVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="accessibility_shortcut_spoken_feedback" msgid="4228997042855695090">"Jei norite naudoti „<xliff:g id="SERVICE_NAME">%1$s</xliff:g>“, paspauskite abu garsumo klavišus ir palaikykite tris sekundes"</string>
    <string name="accessibility_button_prompt_text" msgid="1634298854002673171">"Pasirinkite paslaugą, kuri bus naudojama, kai paliesite pritaikomumo mygtuką:"</string>
    <string name="accessibility_gesture_prompt_text" msgid="3271927619707898924">"Pasirinkite paslaugą, kuri bus naudojama su pritaikomumo gestu (perbraukimas aukštyn dviem pirštais iš ekrano apačios):"</string>
    <string name="accessibility_gesture_3finger_prompt_text" msgid="218295923313037542">"Pasirinkite paslaugą, kuri bus naudojama su pritaikomumo gestu (perbraukimas aukštyn trimis pirštais iš ekrano apačios):"</string>
    <string name="accessibility_button_instructional_text" msgid="8523635009916665153">"Norėdami perjungti paslaugas, palieskite ir palaikykite pritaikomumo mygtuką."</string>
    <string name="accessibility_gesture_instructional_text" msgid="927882482331885974">"Norėdami perjungti paslaugas, perbraukite aukštyn dviem pirštais ir palaikykite."</string>
    <string name="accessibility_gesture_3finger_instructional_text" msgid="7527523742771203377">"Norėdami perjungti paslaugas, perbraukite aukštyn trimis pirštais ir palaikykite."</string>
    <string name="accessibility_magnification_chooser_text" msgid="1502075582164931596">"Didinimas"</string>
    <string name="user_switched" msgid="7249833311585228097">"Dabartinis naudotojas: <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="1912993630661332336">"Perjungiama į <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="user_logging_out_message" msgid="7216437629179710359">"Atsijungiama (<xliff:g id="NAME">%1$s</xliff:g>)…"</string>
    <string name="owner_name" msgid="8713560351570795743">"Savininkas"</string>
    <string name="error_message_title" msgid="4082495589294631966">"Klaida"</string>
    <string name="error_message_change_not_allowed" msgid="843159705042381454">"Administratorius neleidžia atlikti šio pakeitimo"</string>
    <string name="app_not_found" msgid="3429506115332341800">"Nerasta programa šiam veiksmui apdoroti"</string>
    <string name="revoke" msgid="5526857743819590458">"Anuliuoti"</string>
    <string name="mediasize_iso_a0" msgid="7039061159929977973">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="4063589931031977223">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="2779860175680233980">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3683469257246970630">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="752903572302658845">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3020439171949376572">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="6503671662530738180">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="8488649018955763878">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="3380506944389571030">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="7000627318995334730">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="4091511972200388310">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="2057859571254103889">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="4931975244795236924">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="4701978611340339483">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="3509735449039761603">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="486628178454656526">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="2507554073053511267">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="344189428571954711">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="7266158663658064799">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="5229204010533786299">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="2925910409602493256">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="8590530019536996218">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="6504734131385460314">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1751671704929443684">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="2935473413647925667">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="6835637985527663396">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="3000965043023118958">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="3846339505379333795">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8663097559661858303">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="4469290754678239705">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="1949330679635319183">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="3716843356839880581">"ISO S9"</string>
    <string name="mediasize_iso_c10" msgid="2113667674722450076">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="1947253006814499213">"Laiškas"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="4056220626420245955">"Oficialus laiškas"</string>
    <string name="mediasize_na_legal" msgid="8356233803828931150">"Teisinis"</string>
    <string name="mediasize_na_junior_legal" msgid="3398084874757748531">"Mažas teisinis"</string>
    <string name="mediasize_na_ledger" msgid="1819497882853940248">"Buhalterinis"</string>
    <string name="mediasize_na_tabloid" msgid="6792611672983574375">"Bulvarinė spauda"</string>
    <string name="mediasize_na_index_3x5" msgid="990821038991491710">"3 x 5 indekso kortelė"</string>
    <string name="mediasize_na_index_4x6" msgid="4414381976602032401">"4 x 6 indekso kortelė"</string>
    <string name="mediasize_na_index_5x8" msgid="4499341583361946948">"5 x 8 indekso kortelė"</string>
    <string name="mediasize_na_monarch" msgid="4396943937986136896">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="2119101847712239885">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="5011612828564394648">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="411670106572707544">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="7496706798725321898">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="946949835711037253">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="4704308592895046237">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1082996050478581675">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="7865122849174932948">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="852020506971633186">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3399567254628077606">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="2804330751361491000">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="7988760621340084314">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="90266288020939533">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7721316829399772162">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="7471455177845043180">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="6305242012782587594">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="8133982147973309032">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="5888548906612445289">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="6761433476186549691">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="6011047111717561836">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="1541865115368043069">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="8300341273885698803">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4329528623016980657">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="7340334955358311979">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="7403538361394953235">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="9024287678505132047">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="5151340021154579154">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="2709589944170908250">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="1209735840926222618">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="2137738196058117115">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="2533204016634398713">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="5976745918096025459">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="6841260581434101675">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="2112968853810337326">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="1575013107082530108">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="7290232592648122042">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="7477551750461028312">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="5552111912684384833">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3817016220446495613">"Nežinomas stačias"</string>
    <string name="mediasize_unknown_landscape" msgid="1584741567225095325">"Nežinomas gulsčias"</string>
    <string name="write_fail_reason_cancelled" msgid="2344081488493969190">"Atšaukta"</string>
    <string name="write_fail_reason_cannot_write" msgid="432118118378451508">"Klaida rašant turinį"</string>
    <string name="reason_unknown" msgid="5599739807581133337">"nežinoma"</string>
    <string name="reason_service_unavailable" msgid="5288405248063804713">"Spausdinimo paslauga neįgalinta"</string>
    <string name="print_service_installed_title" msgid="6134880817336942482">"Paslauga „<xliff:g id="NAME">%s</xliff:g>“ įdiegta"</string>
    <string name="print_service_installed_message" msgid="7005672469916968131">"Palieskite, kad įgalintumėte"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1199419462726962697">"Įveskite administratoriaus PIN kodą"</string>
    <string name="restr_pin_enter_pin" msgid="373139384161304555">"Įveskite PIN kodą"</string>
    <string name="restr_pin_incorrect" msgid="3861383632940852496">"Neteisingas"</string>
    <string name="restr_pin_enter_old_pin" msgid="7537079094090650967">"Dabartinis PIN kodas"</string>
    <string name="restr_pin_enter_new_pin" msgid="3267614461844565431">"Naujas PIN kodas"</string>
    <string name="restr_pin_confirm_pin" msgid="7143161971614944989">"Patvirtinti naują PIN kodą"</string>
    <string name="restr_pin_create_pin" msgid="917067613896366033">"Sukurti modifikavimo apribojimų PIN kodą"</string>
    <string name="restr_pin_error_doesnt_match" msgid="7063392698489280556">"PIN kodas neatitinka. Bandykite dar kartą."</string>
    <string name="restr_pin_error_too_short" msgid="1547007808237941065">"PIN kodas per trumpas. Jis turi būti bent 4 skaitmenų."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="4427486903285216153">
      <item quantity="one">Bandykite dar kartą po <xliff:g id="COUNT">%d</xliff:g> sekundės</item>
      <item quantity="few">Bandykite dar kartą po <xliff:g id="COUNT">%d</xliff:g> sekundžių</item>
      <item quantity="many">Bandykite dar kartą po <xliff:g id="COUNT">%d</xliff:g> sekundės</item>
      <item quantity="other">Bandykite dar kartą po <xliff:g id="COUNT">%d</xliff:g> sekundžių</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="5897719962541636727">"Vėliau bandykite dar kartą"</string>
    <string name="immersive_cling_title" msgid="2307034298721541791">"Peržiūrima viso ekrano režimu"</string>
    <string name="immersive_cling_description" msgid="7092737175345204832">"Jei norite išeiti, perbraukite žemyn iš viršaus."</string>
    <string name="immersive_cling_positive" msgid="7047498036346489883">"Supratau"</string>
    <string name="done_label" msgid="7283767013231718521">"Atlikta"</string>
    <string name="hour_picker_description" msgid="5153757582093524635">"Apskritas valandų šliaužiklis"</string>
    <string name="minute_picker_description" msgid="9029797023621927294">"Apskritas minučių šliaužiklis"</string>
    <string name="select_hours" msgid="5982889657313147347">"Pasirinkite valandas"</string>
    <string name="select_minutes" msgid="9157401137441014032">"Pasirinkite minutes"</string>
    <string name="select_day" msgid="2060371240117403147">"Pasirinkite mėnesį ir dieną"</string>
    <string name="select_year" msgid="1868350712095595393">"Pasirinkite metus"</string>
    <string name="deleted_key" msgid="9130083334943364001">"Ištrinta: <xliff:g id="KEY">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge" msgid="6762559569999499495">"Darbo <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_2" msgid="5673187309555352550">"2-asis darbo <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_3" msgid="6882151970556391957">"3-iasis darbo <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="lock_to_app_unlock_pin" msgid="3890940811866290782">"Prašyti PIN kodo prieš atsegant"</string>
    <string name="lock_to_app_unlock_pattern" msgid="2694204070499712503">"Prašyti atrakinimo piešinio prieš atsegant"</string>
    <string name="lock_to_app_unlock_password" msgid="9126722403506560473">"Prašyti slaptažodžio prieš atsegant"</string>
    <string name="package_installed_device_owner" msgid="7035926868974878525">"Įdiegė administratorius"</string>
    <string name="package_updated_device_owner" msgid="7560272363805506941">"Atnaujino administratorius"</string>
    <string name="package_deleted_device_owner" msgid="2292335928930293023">"Ištrynė administratorius"</string>
    <string name="confirm_battery_saver" msgid="5247976246208245754">"Gerai"</string>
    <string name="battery_saver_description_with_learn_more" msgid="1817385558636532621">"Kad akumuliatorius veiktų ilgiau, akumuliatoriaus tausojimo priemonė:\n·įjungia tamsiąją temą;\n·išjungia arba apriboja veiklą fone, kai kuriuos vaizdinius efektus ir kitas funkcijas, pvz., „Hey Google“.\n\n"<annotation id="url">"Sužinokite daugiau"</annotation></string>
    <string name="battery_saver_description" msgid="7618492104632328184">"Kad akumuliatorius veiktų ilgiau, akumuliatoriaus tausojimo priemonė:\n·įjungia tamsiąją temą;\n·išjungia arba apriboja veiklą fone, kai kuriuos vaizdinius efektus ir kitas funkcijas, pvz., „Hey Google“."</string>
    <string name="data_saver_description" msgid="4995164271550590517">"Kad padėtų sumažinti duomenų naudojimą, Duomenų taupymo priemonė neleidžia kai kurioms programoms siųsti ar gauti duomenų fone. Šiuo metu naudojama programa gali pasiekti duomenis, bet tai bus daroma rečiau. Tai gali reikšti, kad, pvz., vaizdai nebus pateikiami, jei jų nepaliesite."</string>
    <string name="data_saver_enable_title" msgid="7080620065745260137">"Įj. Duomenų taupymo priemonę?"</string>
    <string name="data_saver_enable_button" msgid="4399405762586419726">"Įjungti"</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="2877101784123058273">
      <item quantity="one">%1$d minutę (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d minutes (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d minutės (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d minučių (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="4230730310318858312">
      <item quantity="one">%1$d min. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d min. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d min. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d min. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="7725354244196466758">
      <item quantity="one">%1$d valandą (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d valandas (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d valandos (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d valandų (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="588719069121765642">
      <item quantity="one">%1$d val. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d val. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d val. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d val. (iki <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="1148568456958944998">
      <item quantity="one">%d minutę</item>
      <item quantity="few">%d minutes</item>
      <item quantity="many">%d minutės</item>
      <item quantity="other">%d minučių</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2742377799995454859">
      <item quantity="one">%d min.</item>
      <item quantity="few">%d min.</item>
      <item quantity="many">%d min.</item>
      <item quantity="other">%d min.</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="525401855645490022">
      <item quantity="one">%d valandą</item>
      <item quantity="few">%d valandas</item>
      <item quantity="many">%d valandos</item>
      <item quantity="other">%d valandų</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="7644653189680911640">
      <item quantity="one">%d val.</item>
      <item quantity="few">%d val.</item>
      <item quantity="many">%d val.</item>
      <item quantity="other">%d val.</item>
    </plurals>
    <string name="zen_mode_until" msgid="2250286190237669079">"Iki <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="7046911727540499275">"Iki <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (kitas signalas)"</string>
    <string name="zen_mode_forever" msgid="740585666364912448">"Kol išjungsite"</string>
    <string name="zen_mode_forever_dnd" msgid="3423201955704180067">"Kol neišjungsite režimo „Netrukdyti“"</string>
    <string name="zen_mode_rule_name_combination" msgid="7174598364351313725">"<xliff:g id="FIRST">%1$s</xliff:g> / <xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="8009920446193610996">"Sutraukti"</string>
    <string name="zen_mode_feature_name" msgid="3785547207263754500">"Netrukdyti"</string>
    <string name="zen_mode_downtime_feature_name" msgid="5886005761431427128">"Prastova"</string>
    <string name="zen_mode_default_weeknights_name" msgid="7902108149994062847">"Darbo dienos vakarą"</string>
    <string name="zen_mode_default_weekends_name" msgid="4707200272709377930">"Savaitgalį"</string>
    <string name="zen_mode_default_events_name" msgid="2280682960128512257">"Įvykis"</string>
    <string name="zen_mode_default_every_night_name" msgid="1467765312174275823">"Miegas"</string>
    <string name="muted_by" msgid="91464083490094950">"„<xliff:g id="THIRD_PARTY">%1$s</xliff:g>“ nutildo kai kuriuos garsus"</string>
    <string name="system_error_wipe_data" msgid="5910572292172208493">"Iškilo vidinė su jūsų įrenginiu susijusi problema, todėl įrenginys gali veikti nestabiliai, kol neatkursite gamyklinių duomenų."</string>
    <string name="system_error_manufacturer" msgid="703545241070116315">"Iškilo vidinė su jūsų įrenginiu susijusi problema. Jei reikia išsamios informacijos, susisiekite su gamintoju."</string>
    <string name="stk_cc_ussd_to_dial" msgid="3139884150741157610">"USSD užklausa pakeista į įprastą skambutį"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4826846653052609738">"USSD užklausa pakeista į SS užklausą"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="8343001461299302472">"Pakeista į naują USSD užklausą"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="429118590323618623">"USSD užklausa pakeista į vaizdo skambutį"</string>
    <string name="stk_cc_ss_to_dial" msgid="4087396658768717077">"SS užklausa pakeista į įprastą skambutį"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="1324194624384312664">"SS užklausa pakeista į vaizdo skambutį"</string>
    <string name="stk_cc_ss_to_ussd" msgid="8417905193112944760">"SS užklausa pakeista į USSD užklausą"</string>
    <string name="stk_cc_ss_to_ss" msgid="132040645206514450">"Pakeista į naują SS užklausą"</string>
    <string name="notification_work_profile_content_description" msgid="5296477955677725799">"Darbo profilis"</string>
    <string name="notification_alerted_content_description" msgid="6139691253611265992">"Įspėjimas išsiųstas"</string>
    <string name="expand_button_content_description_collapsed" msgid="3873368935659010279">"Išskleisti"</string>
    <string name="expand_button_content_description_expanded" msgid="7484217944948667489">"Sutraukti"</string>
    <string name="expand_action_accessibility" msgid="1947657036871746627">"perjungti išskleidimą"</string>
    <string name="usb_midi_peripheral_name" msgid="490523464968655741">"„Android“ USB išorinis prievadas"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7557148557088787741">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="2836276258480904434">"USB išorinis prievadas"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="2260297653578167367">"Daugiau parinkčių"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="3949818077708138098">"Uždaryti perpildymo sritį"</string>
    <string name="maximize_button_text" msgid="4258922519914732645">"Padidinti"</string>
    <string name="close_button_text" msgid="10603510034455258">"Uždaryti"</string>
    <string name="notification_messaging_title_template" msgid="772857526770251989">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g>: <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <plurals name="selected_count" formatted="false" msgid="3946212171128200491">
      <item quantity="one">Pasir. <xliff:g id="COUNT_1">%1$d</xliff:g> elem.</item>
      <item quantity="few">Pasir. <xliff:g id="COUNT_1">%1$d</xliff:g> elem.</item>
      <item quantity="many">Pasir. <xliff:g id="COUNT_1">%1$d</xliff:g> elem.</item>
      <item quantity="other">Pasir. <xliff:g id="COUNT_1">%1$d</xliff:g> elem.</item>
    </plurals>
    <string name="default_notification_channel_label" msgid="3697928973567217330">"Be kategorijos"</string>
    <string name="importance_from_user" msgid="2782756722448800447">"Galite nustatyti šių pranešimų svarbą."</string>
    <string name="importance_from_person" msgid="4235804979664465383">"Tai svarbu dėl susijusių žmonių."</string>
    <string name="user_creation_account_exists" msgid="2239146360099708035">"Leisti „<xliff:g id="APP">%1$s</xliff:g>“ kurti naują <xliff:g id="ACCOUNT">%2$s</xliff:g> naudotoją (šią paskyrą naudojantis naudotojas jau yra)?"</string>
    <string name="user_creation_adding" msgid="7305185499667958364">"Leisti „<xliff:g id="APP">%1$s</xliff:g>“ kurti naują <xliff:g id="ACCOUNT">%2$s</xliff:g> naudotoją?"</string>
    <string name="language_selection_title" msgid="52674936078683285">"Pridėkite kalbą"</string>
    <string name="country_selection_title" msgid="5221495687299014379">"Regiono nuostata"</string>
    <string name="search_language_hint" msgid="7004225294308793583">"Įveskite kalbos pav."</string>
    <string name="language_picker_section_suggested" msgid="6556199184638990447">"Siūloma"</string>
    <string name="language_picker_section_all" msgid="1985809075777564284">"Visos kalbos"</string>
    <string name="region_picker_section_all" msgid="756441309928774155">"Visi regionai"</string>
    <string name="locale_search_menu" msgid="6258090710176422934">"Paieška"</string>
    <string name="app_suspended_title" msgid="888873445010322650">"Programa nepasiekiama"</string>
    <string name="app_suspended_default_message" msgid="6451215678552004172">"Programa „<xliff:g id="APP_NAME_0">%1$s</xliff:g>“ šiuo metu nepasiekiama. Tai tvarkoma naudojant programą „<xliff:g id="APP_NAME_1">%2$s</xliff:g>“."</string>
    <string name="app_suspended_more_details" msgid="211260942831587014">"Sužinoti daugiau"</string>
    <string name="work_mode_off_title" msgid="5503291976647976560">"Įjungti darbo profilį?"</string>
    <string name="work_mode_off_message" msgid="8417484421098563803">"Darbo programos, pranešimai, duomenys ir kitos darbo profilio funkcijos bus išjungtos"</string>
    <string name="work_mode_turn_on" msgid="3662561662475962285">"Įjungti"</string>
    <string name="deprecated_target_sdk_message" msgid="5203207875657579953">"Ši programa sukurta naudoti senesnės versijos sistemoje „Android“ ir gali tinkamai neveikti. Pabandykite patikrinti, ar yra naujinių, arba susisiekite su kūrėju."</string>
    <string name="deprecated_target_sdk_app_store" msgid="8456784048558808909">"Tikrinti, ar yra naujinių"</string>
    <string name="new_sms_notification_title" msgid="6528758221319927107">"Turite naujų pranešimų"</string>
    <string name="new_sms_notification_content" msgid="3197949934153460639">"Atidaryti SMS programą, norint peržiūrėti"</string>
    <string name="profile_encrypted_title" msgid="9001208667521266472">"Kai kurios funkcijos ribojamos"</string>
    <string name="profile_encrypted_detail" msgid="5279730442756849055">"Darbo profilis užrakintas"</string>
    <string name="profile_encrypted_message" msgid="1128512616293157802">"Paliesk., kad atr. darbo prof."</string>
    <string name="usb_mtp_launch_notification_title" msgid="774319638256707227">"Prisijungta prie „<xliff:g id="PRODUCT_NAME">%1$s</xliff:g>“"</string>
    <string name="usb_mtp_launch_notification_description" msgid="6942535713629852684">"Palieskite, kad peržiūrėtumėte failus"</string>
    <string name="pin_target" msgid="8036028973110156895">"Prisegti"</string>
    <string name="unpin_target" msgid="3963318576590204447">"Atsegti"</string>
    <string name="app_info" msgid="6113278084877079851">"Programos informacija"</string>
    <string name="negative_duration" msgid="1938335096972945232">"–<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="6577581216125805905">"Paleidžiama demonstracinė versija…"</string>
    <string name="demo_restarting_message" msgid="1160053183701746766">"Įrenginys nustatomas iš naujo…"</string>
    <string name="suspended_widget_accessibility" msgid="6331451091851326101">"Išj. valdiklis „<xliff:g id="LABEL">%1$s</xliff:g>“"</string>
    <string name="conference_call" msgid="5731633152336490471">"Konferencinis skambutis"</string>
    <string name="tooltip_popup_title" msgid="7863719020269945722">"Patarimas"</string>
    <string name="app_category_game" msgid="4534216074910244790">"Žaidimai"</string>
    <string name="app_category_audio" msgid="8296029904794676222">"Muzika ir garso įrašai"</string>
    <string name="app_category_video" msgid="2590183854839565814">"Filmai ir vaizdo įrašai"</string>
    <string name="app_category_image" msgid="7307840291864213007">"Nuotraukos ir vaizdai"</string>
    <string name="app_category_social" msgid="2278269325488344054">"Socialiniai tinklai ir ryšiai"</string>
    <string name="app_category_news" msgid="1172762719574964544">"Naujienos ir žurnalai"</string>
    <string name="app_category_maps" msgid="6395725487922533156">"Žemėlapiai ir navigacija"</string>
    <string name="app_category_productivity" msgid="1844422703029557883">"Produktyvumas"</string>
    <string name="device_storage_monitor_notification_channel" msgid="5164244565844470758">"Įrenginio saugykla"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="4764046459631031496">"USB derinimas"</string>
    <string name="time_picker_hour_label" msgid="4208590187662336864">"valanda"</string>
    <string name="time_picker_minute_label" msgid="8307452311269824553">"minutė"</string>
    <string name="time_picker_header_text" msgid="9073802285051516688">"Laiko nustatymas"</string>
    <string name="time_picker_input_error" msgid="8386271930742451034">"Įveskite tinkamą laiką"</string>
    <string name="time_picker_prompt_label" msgid="303588544656363889">"Įveskite laiką"</string>
    <string name="time_picker_text_input_mode_description" msgid="4761160667516611576">"Laiko įvestį pateikti perjungus į teksto įvesties režimą."</string>
    <string name="time_picker_radial_mode_description" msgid="1222342577115016953">"Laiko įvestį pateikti perjungus į laikrodžio režimą."</string>
    <string name="autofill_picker_accessibility_title" msgid="4425806874792196599">"Automatinio pildymo parinktys"</string>
    <string name="autofill_save_accessibility_title" msgid="1523225776218450005">"Išsaugoti Automatinio pildymo paslaugoje"</string>
    <string name="autofill_error_cannot_autofill" msgid="6528827648643138596">"Turinio negalima pildyti automatiškai"</string>
    <string name="autofill_picker_no_suggestions" msgid="1076022650427481509">"Nėra jokių automatinio pildymo pasiūlymų"</string>
    <plurals name="autofill_picker_some_suggestions" formatted="false" msgid="6651883186966959978">
      <item quantity="one"><xliff:g id="COUNT">%1$s</xliff:g> automatinio pildymo pasiūlymas</item>
      <item quantity="few"><xliff:g id="COUNT">%1$s</xliff:g> automatinio pildymo pasiūlymai</item>
      <item quantity="many"><xliff:g id="COUNT">%1$s</xliff:g> automatinio pildymo pasiūlymo</item>
      <item quantity="other"><xliff:g id="COUNT">%1$s</xliff:g> automatinio pildymo pasiūlymų</item>
    </plurals>
    <string name="autofill_save_title" msgid="7719802414283739775">"Išsaugoti paslaugoje "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_type" msgid="3002460014579799605">"Išsaugoti <xliff:g id="TYPE">%1$s</xliff:g> paslaugoje "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_2types" msgid="3783270967447869241">"Išsaugoti <xliff:g id="TYPE_0">%1$s</xliff:g> ir <xliff:g id="TYPE_1">%2$s</xliff:g> paslaugoje "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_3types" msgid="6598228952100102578">"Išsaugoti <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> ir <xliff:g id="TYPE_2">%3$s</xliff:g> paslaugoje "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title" msgid="3630695947047069136">"Atnaujinti paslaugoje "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_type" msgid="5264152633488495704">"Atnaujinti <xliff:g id="TYPE">%1$s</xliff:g> paslaugoje "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_2types" msgid="1797514386321086273">"Atnaujinti <xliff:g id="TYPE_0">%1$s</xliff:g> ir <xliff:g id="TYPE_1">%2$s</xliff:g> paslaugoje "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_3types" msgid="1312232153076212291">"Atnaujinti šiuos elementus paslaugoje "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>": <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> ir <xliff:g id="TYPE_2">%3$s</xliff:g> ?"</string>
    <string name="autofill_save_yes" msgid="8035743017382012850">"Išsaugoti"</string>
    <string name="autofill_save_no" msgid="9212826374207023544">"Ne, ačiū"</string>
    <string name="autofill_update_yes" msgid="4608662968996874445">"Atnaujinti"</string>
    <string name="autofill_save_type_password" msgid="5624528786144539944">"slaptažodį"</string>
    <string name="autofill_save_type_address" msgid="3111006395818252885">"adresą"</string>
    <string name="autofill_save_type_credit_card" msgid="3583795235862046693">"kredito kortelę"</string>
    <string name="autofill_save_type_username" msgid="1018816929884640882">"naudotojo vardas"</string>
    <string name="autofill_save_type_email_address" msgid="1303262336895591924">"el. pašto adresas"</string>
    <string name="etws_primary_default_message_earthquake" msgid="8401079517718280669">"Nesijaudinkite ir ieškokite prieglobsčio netoliese."</string>
    <string name="etws_primary_default_message_tsunami" msgid="5828171463387976279">"Nedelsdami pasitraukite nuo pakrančių ir paupių. Eikite į saugią vietą, pvz., vietą, kuri yra aukštai."</string>
    <string name="etws_primary_default_message_earthquake_and_tsunami" msgid="4888224011071875068">"Nesijaudinkite ir ieškokite prieglobsčio netoliese."</string>
    <string name="etws_primary_default_message_test" msgid="4583367373909549421">"Kritinės padėties pranešimo bandymas"</string>
    <string name="notification_reply_button_accessibility" msgid="5235776156579456126">"Atsakyti"</string>
    <string name="etws_primary_default_message_others" msgid="7958161706019130739"></string>
    <string name="mmcc_authentication_reject" msgid="4891965994643876369">"SIM kortelė neleidžiama naudojant balso paslaugas"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="227760698553988751">"SIM kortelė neteikiama naudojant balso paslaugas"</string>
    <string name="mmcc_illegal_ms" msgid="7509650265233909445">"SIM kortelė neleidžiama naudojant balso paslaugas"</string>
    <string name="mmcc_illegal_me" msgid="6505557881889904915">"Telefonas neleidžiamas naudojant balso paslaugas"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="4480853038909922153">"SIM kortelė <xliff:g id="SIMNUMBER">%d</xliff:g> neleidžiama"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="3688508325248599657">"SIM kortelė <xliff:g id="SIMNUMBER">%d</xliff:g> neteikiama"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="832644375774599327">"SIM kortelė <xliff:g id="SIMNUMBER">%d</xliff:g> neleidžiama"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="4802735138861422802">"SIM kortelė <xliff:g id="SIMNUMBER">%d</xliff:g> neleidžiama"</string>
    <string name="popup_window_default_title" msgid="6907717596694826919">"Iššokantysis langas"</string>
    <string name="slice_more_content" msgid="3377367737876888459">"Dar <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="9206301954024286063">"Grąžinta ankstesnė programos versija arba versija nesuderinama su šiuo sparčiuoju klavišu"</string>
    <string name="shortcut_restore_not_supported" msgid="4763198938588468400">"Nepavyko atkurti sparčiojo klavišo, nes programa nepalaiko atsarginės kopijos kūrimo ir atkūrimo funkcijų"</string>
    <string name="shortcut_restore_signature_mismatch" msgid="579345304221605479">"Nepavyko atkurti sparčiojo klavišo, nes programos parašas neatitinka"</string>
    <string name="shortcut_restore_unknown_issue" msgid="2478146134395982154">"Nepavyko atkurti sparčiojo klavišo"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="753074793553599166">"Spartusis klavišas išjungtas"</string>
    <string name="harmful_app_warning_uninstall" msgid="6472912975664191772">"PAŠALINTI"</string>
    <string name="harmful_app_warning_open_anyway" msgid="5963657791740211807">"VIS TIEK ATIDARYTI"</string>
    <string name="harmful_app_warning_title" msgid="8794823880881113856">"Aptikta žalinga programa"</string>
    <string name="slices_permission_request" msgid="3677129866636153406">"„<xliff:g id="APP_0">%1$s</xliff:g>“ nori rodyti „<xliff:g id="APP_2">%2$s</xliff:g>“ fragmentus"</string>
    <string name="screenshot_edit" msgid="7408934887203689207">"Redaguoti"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="2055927873175228519">"Skambučiai ir pranešimai vibruos"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="1011246774949993783">"Skambučiai ir pranešimai bus nutildyti"</string>
    <string name="notification_channel_system_changes" msgid="2462010596920209678">"Sistemos pakeitimai"</string>
    <string name="notification_channel_do_not_disturb" msgid="7832584281883687653">"Netrukdymo režimas"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="2001148984371968620">"Naujiena: naudojant netrukdymo režimą pranešimai slepiami"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="3683314609114134946">"Palieskite, kad sužinotumėte daugiau ir pakeistumėte."</string>
    <string name="zen_upgrade_notification_title" msgid="8198167698095298717">"Netrukdymo režimas pakeistas"</string>
    <string name="zen_upgrade_notification_content" msgid="5228458567180124005">"Palieskite, kad patikrintumėte, kas blokuojama."</string>
    <string name="notification_app_name_system" msgid="3045196791746735601">"Sistema"</string>
    <string name="notification_app_name_settings" msgid="9088548800899952531">"Nustatymai"</string>
    <string name="notification_appops_camera_active" msgid="8177643089272352083">"Fotoaparatas"</string>
    <string name="notification_appops_microphone_active" msgid="581333393214739332">"Mikrofonas"</string>
    <string name="notification_appops_overlay_active" msgid="5571732753262836481">"rodo virš kitų programų jūsų ekrane"</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2986926422100223328">"Veiksmų sekos režimo informacijos pranešimas"</string>
    <string name="dynamic_mode_notification_title" msgid="9205715501274608016">"Akumuliatoriaus energija gali išsekti prieš įprastą įkrovimą"</string>
    <string name="dynamic_mode_notification_summary" msgid="4141614604437372157">"Akumuliatoriaus tausojimo priemonė suaktyvinta, kad akumuliatorius veiktų ilgiau"</string>
    <string name="battery_saver_notification_channel_name" msgid="3918243458067916913">"Akumuliatoriaus tausojimo priemonė"</string>
    <string name="battery_saver_sticky_disabled_notification_title" msgid="616803848887159814">"Akumuliatoriaus tausojimo priemonė nebus iš naujo suaktyvinta, kol akumuliatorius vėl beveik išseks"</string>
    <string name="battery_saver_sticky_disabled_notification_summary" msgid="9091127514013090563">"Pasiektas tinkamas akumuliatoriaus įkrovimo lygis. Akumuliatoriaus tausojimo priemonė nebus iš naujo suaktyvinta, kol akumuliatorius vėl beveik išseks."</string>
    <string name="battery_saver_charged_notification_title" product="default" msgid="3323003634503470433">"Telefono įkrovimo lygis: <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="tablet" msgid="7917739170436791596">"Planšetinio kompiuterio įkrovimo lygis: <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="device" msgid="6316898726189914805">"Įrenginio įkrovimo lygis: <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_notification_summary" msgid="8489738830261291526">"Akumuliatoriaus tausojimo priemonė išjungta. Funkcijos neberibojamos."</string>
    <string name="battery_saver_off_alternative_notification_summary" msgid="8875240624827898671">"Akumuliatoriaus tausojimo priemonė išjungta. Funkcijos neberibojamos."</string>
    <string name="mime_type_folder" msgid="2203536499348787650">"Aplankas"</string>
    <string name="mime_type_apk" msgid="3168784749499623902">"„Android“ programa"</string>
    <string name="mime_type_generic" msgid="4606589110116560228">"Failas"</string>
    <string name="mime_type_generic_ext" msgid="9220220924380909486">"<xliff:g id="EXTENSION">%1$s</xliff:g> failas"</string>
    <string name="mime_type_audio" msgid="4933450584432509875">"Garso įrašas"</string>
    <string name="mime_type_audio_ext" msgid="2615491023840514797">"<xliff:g id="EXTENSION">%1$s</xliff:g> garso įrašas"</string>
    <string name="mime_type_video" msgid="7071965726609428150">"Vaizdo įrašas"</string>
    <string name="mime_type_video_ext" msgid="185438149044230136">"<xliff:g id="EXTENSION">%1$s</xliff:g> vaizdo įrašas"</string>
    <string name="mime_type_image" msgid="2134307276151645257">"Vaizdas"</string>
    <string name="mime_type_image_ext" msgid="5743552697560999471">"<xliff:g id="EXTENSION">%1$s</xliff:g> vaizdas"</string>
    <string name="mime_type_compressed" msgid="8737300936080662063">"Archyvas"</string>
    <string name="mime_type_compressed_ext" msgid="4775627287994475737">"<xliff:g id="EXTENSION">%1$s</xliff:g> archyvas"</string>
    <string name="mime_type_document" msgid="3737256839487088554">"Dokumentas"</string>
    <string name="mime_type_document_ext" msgid="2398002765046677311">"<xliff:g id="EXTENSION">%1$s</xliff:g> dokumentas"</string>
    <string name="mime_type_spreadsheet" msgid="8188407519131275838">"Skaičiuoklė"</string>
    <string name="mime_type_spreadsheet_ext" msgid="8720173181137254414">"<xliff:g id="EXTENSION">%1$s</xliff:g> skaičiuoklė"</string>
    <string name="mime_type_presentation" msgid="1145384236788242075">"Pristatymas"</string>
    <string name="mime_type_presentation_ext" msgid="8761049335564371468">"<xliff:g id="EXTENSION">%1$s</xliff:g> pristatymas"</string>
    <string name="car_loading_profile" msgid="8219978381196748070">"Įkeliama"</string>
    <plurals name="file_count" formatted="false" msgid="7063513834724389247">
      <item quantity="one">„<xliff:g id="FILE_NAME_2">%s</xliff:g>“ ir <xliff:g id="COUNT_3">%d</xliff:g> failas</item>
      <item quantity="few">„<xliff:g id="FILE_NAME_2">%s</xliff:g>“ ir <xliff:g id="COUNT_3">%d</xliff:g> failai</item>
      <item quantity="many">„<xliff:g id="FILE_NAME_2">%s</xliff:g>“ ir <xliff:g id="COUNT_3">%d</xliff:g> failo</item>
      <item quantity="other">„<xliff:g id="FILE_NAME_2">%s</xliff:g>“ ir <xliff:g id="COUNT_3">%d</xliff:g> failų</item>
    </plurals>
    <string name="chooser_no_direct_share_targets" msgid="492542066060841139">"Tiesioginio bendrinimo funkcija nepasiekiama"</string>
    <string name="chooser_all_apps_button_label" msgid="3230427756238666328">"Programų sąrašas"</string>
</resources>
