<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 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="yes" msgid="4676390750360727396">"Taip"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Kurti"</string>
    <string name="allow" msgid="3349662621170855910">"Leisti"</string>
    <string name="deny" msgid="6947806159746484865">"Atmesti"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Nežinomas"</string>
  <plurals name="show_dev_countdown">
    <item quantity="one" msgid="5295687242294085452">"Liko atlikti <xliff:g id="STEP_COUNT">%1$d</xliff:g> veiksm. ir būsite kūrėjas."</item>
    <item quantity="other" msgid="6722953419953594148">"Liko atlikti <xliff:g id="STEP_COUNT">%1$d</xliff:g> veiksm. ir būsite kūrėjas."</item>
  </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Dabar esate kūrėjas!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nereikia, jūs jau esate kūrėjas."</string>
    <string name="header_category_wireless_networks" msgid="4944823405420438623">"BEVIELIS RYŠYS IR TINKLAI"</string>
    <string name="header_category_device" msgid="5781174212691167553">"ĮRENGINYS"</string>
    <string name="header_category_personal" msgid="6225932173498802187">"ASMENIŠKA"</string>
    <string name="header_category_system" msgid="2073558547468647128">"SISTEMA"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Įjungti radiją"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Išjungti radiją"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Įjungti SMS per IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Išjungti SMS per IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Būtina įjungti IMS registraciją"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Būtina išjungti IMS registraciją"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Įjungti ilgalaikės raidos laisvosios prieigos atminties išklotinę"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Išjungti ilgalaikės raidos laisvosios prieigos atminties išklotinę"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Žiūrėti SIM kortelės adresų knygą"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Žiūrėti fiksuoto rinkimo numerius"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Žiūrėti paslaugos renkamus numerius"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Gauti PDP sąrašą"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"Aptarnaujama"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Paslaugos neteikiamos"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Tik pagalbos skambučiai"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Radijas išjungtas"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Tarptinklinis ryšys"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Neveikia tarptinklinis ryšys"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Nėra"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Skamba"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Vykdomas skambutis"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Atsijungęs (-usi)"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Jungiama"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Prisijungta"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Pristabdyta"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"nežinomas"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pakuotės"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"baitai"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Atjungti USB atmintinę"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Išimti SD kortelę"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Ištrinti USB atmintinę"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Ištrinti SD kortelę"</string>
    <string name="small_font" msgid="2295331917424072635">"Mažas"</string>
    <string name="medium_font" msgid="2068475425515133701">"Vidutinis"</string>
    <string name="large_font" msgid="599055175160971446">"Didelis"</string>
    <string name="font_size_save" msgid="3450855718056759095">"Gerai"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"USB atmintinė"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"SD kortelė"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Akumuliatoriaus būsena:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Maitinimo lizdas:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Akumuliatoriaus skalė"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Akumuliatoriaus lygis:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Akumuliatoriaus būklė:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Akumuliatoriaus technologija:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Akumuliatoriaus įtampa:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Akumuliatoriaus temperatūra:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"°C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Laikas nuo įkrovos:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Veikimo laikas akumuliatoriuje:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Veikimo laikas įkraunant:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Ekrane ĮJUNGTAS laikas:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Nežinomas"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Kraunasi..."</string>
    <string name="battery_info_status_charging_ac" msgid="5874340256342956252">"(AC)"</string>
    <string name="battery_info_status_charging_usb" msgid="4059070156126770959">"(USB)"</string>
    <string name="battery_info_status_charging_wireless" msgid="1822125795446772771">"(belaidis)"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Nekraunama"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Nekraunama"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Visiškai įkrautas"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Neįjungtas į lizdą"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"AC"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"belaidis"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"AC ir USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Nežinomas"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Nežinomas"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Gera"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Perkaito"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Išsikrovęs"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Kita įtampa"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Nežinoma klaida"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Neveikiantis"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Matoma visiems netol. esant. „Bluetooth“ įr. (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Matoma visiems netoliese esan. „Bluetooth“ įreng."</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nematoma kitiems „Bluetooth“ įrenginiams"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Matoma tik suporuotiems įrenginiams."</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Baigėsi skirtasis matomumo laikas"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Užrakinti numerio rinkimą balsu"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Neleisti naudoti „Bluetooth“ numerio rinkiklio, kai ekranas užrakintas"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"„Bluetooth“ įrenginiai"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Įrenginio pavadinimas"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Įrenginio nustatymai"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Profilio nustatymai"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nenustatytas pavadinimas, naudojamas paskyros pavadinimas"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Nuskaityti ieškant įrenginių"</string>
    <string name="bluetooth_rename_device" product="tablet" msgid="787970073150631155">"Pervardyti planšet. kompiuterį"</string>
    <string name="bluetooth_rename_device" product="default" msgid="6267987985556136749">"Pervardyti telefoną"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Pervardyti"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Atsijungti?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Tai nutrauks ryšį su:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Neleisti profilio?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Neleis:&lt;br&gt;&lt;b&gt;„<xliff:g id="PROFILE_NAME">%1$s</xliff:g>“&lt;/b&gt;&lt;br&gt;&lt;br&gt;iš:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_connected" msgid="6038755206916626419">"Prisijungta"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Prijungta (be telefono)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Prijungta (be laikmenos)"</string>
    <string name="bluetooth_connected_no_map" msgid="6504436917057479986">"Prisijungta (be prieigos prie pranešimų)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Prijungta (be telefono ar laikmenos)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Atsijungęs (-usi)"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Atjungiama..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Jungiama…"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Susiejama..."</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"„Bluetooth“ įrenginys be pavadinimo"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Ieškoma"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Nerasta netol. esanč. „Bluetooth“ įreng."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"„Bluetooth“ susiejimo užklausa"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Susiejimo užklausa"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Jei norite susieti su „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“, palieskite."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Rodyti gautus failus"</string>
    <string name="device_picker" msgid="8398232791303186677">"„Bluetooth“ įrenginio pasirinkimo priemonė"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"„Bluetooth“ leidimo užklausa"</string>
    <string name="bluetooth_ask_enablement" msgid="637355677176904990">"Programa nori įjungti „Bluetooth“."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Programa nori padaryti planšetinį kompiuterį <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. aptinkamą kitų „Bluetooth“ įrenginių."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Programa nori padaryti telefoną <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. aptinkamą kitų „Bluetooth“ įrenginių."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Programa nori padaryti planšetinį kompiuterį matomą kitų „Bluetooth“ įrenginių. Tai galėsite vėliau pakeisti „Bluetooth“ nustatymuose."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Programa nori padaryti telefoną matomą kitų „Bluetooth“ įrenginių. Tai galėsite vėliau pakeisti „Bluetooth“ nustatymuose."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Programa nori įjungti „Bluetooth“ ir padaryti planšetinį kompiuterį <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. matomą kitų įrenginių."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Programa nori įjungti „Bluetooth“ ir padaryti telefoną <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. matomą kitų įrenginių."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Programa nori įjungti „Bluetooth“ ir padaryti planšetinį kompiuterį matomą kitų įrenginių. Tai galėsite vėliau pakeisti „Bluetooth“ nustatymuose."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Programa nori įjungti „Bluetooth“ ir padaryti telefoną matomą kitų įrenginių. Tai galėsite vėliau pakeisti „Bluetooth“ nustatymuose."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Įjungti „Bluetooth“?"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"„Bluetooth“ išjungiamas…"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Automatiškai prisijungti"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"„Bluetooth“ ryšio užklausa"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Palieskite, kad prisijungtumėte prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Ar norite prisijungti prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Prieigos prie telefonų knygos užklausa"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s nori pasiekti jūsų kontaktus ir skambučių istoriją. Suteikti prieigą %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6198284561603824931">"Daugiau neklausti"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Daugiau neklausti"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Prieigos prie pranešimų užklausa"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s nori pasiekti jūsų pranešimus. Suteikti prieigą %2$s?"</string>
    <string name="date_and_time" msgid="4114084177056654663">"Datos ir laiko nustatymai"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Pasirinkite laiko juostą"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Pagal vietovę (<xliff:g id="DATE">%s</xliff:g>)"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Peržiūra:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Šrifto dydis:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Siųsti <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Pradėti <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Paskyra:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Tarpinis serveris"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Išvalyti"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Tarpinio serverio prievadas"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Išjungti įgaliotąjį serverį, skirtą"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com, mycomp.test.com, localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Atkurti numatytuosius nustatymus"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Atlikta"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Tarpinio serverio prieglobos pavadinimas"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Dėmesio"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"Gerai"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Įvestas prieglobos serverio pavadinimas netinkamas."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Įvestas išimčių sąrašas netinkamai suformatuotas. Įveskite kableliais atskirtą išskirtų domenų sąrašą."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Turite užpildyti prievado lauką."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Prievado laukas turi būti tuščias, jei tuščias prieglobos laukas."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Prievadas, kurį įvedėte, netinkamas."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"HTTP įgaliotąjį serverį naudoja naršyklė, bet jo negali naudoti kitos programos."</string>
    <string name="proxy_url" msgid="2523518669129974654">"PAC URL: "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Vieta:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"Šalia esantis CID:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"Mob. tel. informacija:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Duomenų bandymai:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"GPRS paslauga:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Tarptinklinis ryšys:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Skambučio peradresavimas:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"PPP nustatymų iš naujo skaičius po įkrovos:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"GSM atjungimai:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Dabartinis tinklas:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Duomenų sėkmė:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"PPP gauta:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"GSM paslauga:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Signalo stiprumas:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Skambučio būsena:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"PPP išsiųsta:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Radijo nustatymai iš naujo:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Laukiantis pranešimas:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Telefono numeris:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Pasirinkti radijo dažnių juostą"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Tinklo tipas:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Nustatyti pageidaujamą tinklo tipą:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Pingo „IpAddr“:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Pingo prieglobos pavadinimas (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"HTTP kliento bandymas:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Paleisti pingo bandymą"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Naujinimas"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Atnaujinti"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Kaitalioti DNS tikrinimą"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"OEM būdinga informacija / nustatymai"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Nustatyti GSM / UMTS juostą"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Įkeliamas juostų sąrašas..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Nustatyti"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Nesėkminga"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Sėkmingas"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Pakeitimai įsigalioja, kai USB laidas prijungiamas iš naujo."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Įgalinti nuolatinį USB saugojimą"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Iš viso baitų:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"USB atmintis neįdėta."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Nėra SD kortelės."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Galimi baitai:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB atm. naud. kaip did. įren."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"SD kortelė naudojama kaip didelės talpos atminties įrenginys"</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Dabar saugu pašal. USB atmint."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Dabar saugu pašalinti SD kortelę."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB atm. pašal. jai veikiant!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"SD kortelė buvo pašalinta tuo metu, kai buvo naudojama!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Panaudota baitų:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Ieškoma medijos USB atm..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Nuskaitoma SD kortelės medija..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Įdėta tik skait. USB atmin."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Įdėta tik skait. SD kortelė."</string>
    <string name="skip_label" msgid="47510779345218297">"Praleisti"</string>
    <string name="next_label" msgid="4693520878012668114">"Kitas"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Kalba"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Pasirinkti veiklą"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Įrenginio informacija"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Akumuliatoriaus informacija"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekranas"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Planšetinio kompiuterio informacija"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Telefono informacija"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"USB atmintinė"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"SD kortelė"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Tarpinio serverio nustatymai"</string>
    <string name="cancel" msgid="6859253417269739139">"Atšaukti"</string>
    <string name="settings_label" msgid="1626402585530130914">"Nustatymai"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Nustatymai"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Spartusis nustatymų klavišas"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Lėktuvo režimas"</string>
    <string name="radio_controls_title" msgid="6889937359495515769">"Daugiau…"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bevielis ryšys ir tinklai"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Tvarkyti „Wi-Fi“, „Bluetooth“, lėktuvo režimą, mobiliuosius tinklus ir VPN"</string>
    <string name="roaming" msgid="3596055926335478572">"Tarptinklinis duomenų ryšys"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Veikiant tarptinkliniam ryšiui, prisijungti prie duomenų paslaugų"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Veikiant tarptinkliniam ryšiui, prisijungti prie duomenų paslaugų"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Praradote duomenų jungiamumą, nes pagrindinį tinklą palikote išjungę tarptinklinį ryšį."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Įjungti"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Leisdami tarptinklinį duomenų ryšį, galite būti apmokestinti nemažais tarptinklinio ryšio mokesčiais!"</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Kai leidžiate tarptinklinį duomenų ryšį, gali būti taikomi dideli tarptinklinio ryšio mokesčiai.\n\nŠis nustatymas turi įtakos visiems šio planšetinio kompiuterio naudotojams."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Kai leidžiate tarptinklinį duomenų ryšį, gali būti taikomi dideli tarptinklinio ryšio mokesčiai.\n\nŠis nustatymas turi įtakos visiems šio telefono naudotojams."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Leisti tarptinklinį duomenų ryšį?"</string>
    <string name="networks" msgid="6333316876545927039">"Operatoriaus pasirinkimas"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Pasirinkite tinklo operatorių"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Data ir laikas"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Nustatyti datą ir laiką"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Nustatyti datą, laiką, laiko juostą ir formatus"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Automatinė data ir laikas"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Naudoti tinklo pateiktą laiką"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Naudoti tinklo pateiktą laiką"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automatinė laiko juosta"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Naudoti tinklo pateiktą laiko juostą"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Naudoti tinklo pateiktą laiko juostą"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Naudoti 24 val. formatą"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Nustatyti laiką"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Pasirinkti laiko zoną"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Nustatyti datą"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Pasirinkite datos formatą"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Rūšiuoti pagal abėcėlę"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Rūšiuoti pagal laiko zoną"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Data"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Laikas"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Patobulinti veido atitikimą"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Tikrinimas, ar matomas veidas"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Atrakinant reikalauti mirksėti"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automatiškai užrakinti"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po miego režimo"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Rodyti savininko informaciją užrakinimo ekrane"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Savininko informac."</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Įgalinti valdiklius"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Išjungė administratorius"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Įveskite tekstą, pateiktiną užrakinimo ekrane"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Rodyti naudotojo informaciją užrakinimo ekrane"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Naudotojo inform."</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Rodyti profilio informaciją užrakinimo ekrane"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Profilio informacija"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Vietovė"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Sauga"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Nustatyti mano vietą, ekrano atrakinimą, SIM kortelės užraktą, įgaliojimų saugyklos užraktą"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Nustatyti mano vietą, ekrano atrakinimą, įgaliojimų saugyklos užraktą"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Slaptažodžiai"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifruotė"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifruoti planšetinį kompiuterį"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifruoti telefoną"</string>
    <string name="crypt_keeper_encrypt_summary" product="tablet" msgid="6291564408810586">"Reikalauti skaitinio PIN kodo ar slaptažodžio, norint iššifruoti planšetinį kompiuterį kaskart jį įjungus"</string>
    <string name="crypt_keeper_encrypt_summary" product="default" msgid="514138079795442371">"Reikalauti skaitinio PIN kodo ar slaptažodžio, norint iššifruoti telefoną kaskart jį įjungus"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifruotas"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="3839235202103924154">"Galite užšifruoti paskyras, nustatymus, atsisiųstas programas ir jų duomenis, mediją ir kitus failus. Užšifravę planšetinį kompiuterį turėsite įvesti skaitinį PIN kodą arba slaptažodį, kad iššifruotumėte jį kiekvieną kartą įjungę. Planšetinio kompiuterio iššifruoti negalite, išskyrus atvejus, kai atkuriate gamyklinius duomenis, ištrindami visus turimus duomenis.\n\nŠifravimas trunka valandą ar daugiau. Turite pradėti darbą naudodami įkrautą akumuliatorių ir laikyti planšetinį kompiuterį prijungtą prie maitinimo tinklo, kol šifravimas bus baigtas. Pertraukus šifravimo procesą bus prarasti kai kurie arba visi duomenys."</string>
    <string name="crypt_keeper_desc" product="default" msgid="7663118199519229502">"Galite užšifruoti paskyras, nustatymus, atsisiųstas programas ir jų duomenis, mediją ir kitus failus. Užšifravę telefoną turėsite įvesti skaitinį PIN kodą arba slaptažodį, kad iššifruotumėte jį kiekvieną kartą įjungę. Telefono iššifruoti negalite, išskyrus atvejus, atkuriate gamyklinius duomenis, ištrindami visus turimus duomenis.\n\nŠifravimas trunka valandą ar daugiau. Turite pradėti darbą naudodami įkrautą akumuliatorių ir laikyti telefoną prijungtą prie maitinimo tinklo, kol šifravimas bus baigtas. Pertraukus šifravimo procesą bus prarasti kai kurie arba visi duomenys."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifruoti planšetinį kompiuterį"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifruoti telefoną"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Įkraukite akumuliatorių ir bandykite dar kartą."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Įjunkite kroviklį į lizdą ir bandykite dar kartą."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nėra ekrano užrakto PIN kodo ar slaptažodžio"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Prieš pradėdami šifravimo procesą turite nustatyti ekrano užrakto PIN kodą arba slaptažodį."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Užšifruoti?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Šifravimo operacijos anuliuoti negalima ir, jei ją pertrauksite, prarasite duomenis. Šifravimas trunka valandą ar ilgiau; jam vykstant planšetinis kompiuteris kelis kartus bus paleidžiamas iš naujo."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Šifravimo operacijos anuliuoti negalima ir, jei ją pertrauksite, prarasite duomenis. Šifravimas trunka valandą ar ilgiau; jam vykstant telefonas kelis kartus bus paleidžiamas iš naujo."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Šifruojama"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Palaukite, kol šifruojamas planšetinis kompiuteris. Baigta <xliff:g id="PERCENT">^1</xliff:g> %."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Palaukite, kol šifruojamas telefonas. Baigta <xliff:g id="PERCENT">^1</xliff:g> %."</string>
    <string name="crypt_keeper_cooldown" msgid="685210918307862395">"Bandyti dar kartą po <xliff:g id="DELAY">^1</xliff:g> sek."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Įveskite slaptažodį"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifruotė nepavyko"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Šifravimas buvo pertrauktas ir negali būti užbaigtas. Todėl duomenys planšetiniame kompiuteryje nebepasiekiami. \n\n Jei norite vėl naudoti planšetinį kompiuterį, turite iš naujo nustatyti gamyklinius nustatymus. Kai iš naujo nustatę nustatysite planšetinį kompiuterį, galėsite atkurti visus duomenis, kurių atsarginės kopijos buvo sukurtos „Google“ paskyroje."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Šifravimas buvo pertrauktas ir negali būti užbaigtas. Todėl duomenys telefone nebepasiekiami. \n\nJei norite vėl naudoti telefoną, turite iš naujo nustatyti gamyklinius nustatymus. Kai iš naujo nustatę nustatysite telefoną, galėsite atkurti visus duomenis, kurių atsarginės kopijos buvo sukurtos „Google“ paskyroje."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Perjungti įvesties metodą"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Pasir. ekrano užrak."</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Pasirinkti atsarginį užrakinimą"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Ekrano užraktas"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Pakeisti užrak. ekraną"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Keisti ar išjungti modelio, PIN kodo ar slaptažodžio saugą"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Pasirinkite ekrano užrakinimo metodą"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Kai Atrakinimo pagal veidą programa nemato jūsų, kaip norite atrakinti?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Nėra"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="2871898266296656162">"Slinkti"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Nesaugoma"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Atrakinimas pgl. veidą"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Žemas saugos lygis, bandomasis"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Modelis"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Vidutinis saugos lygis"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Vidutinis–aukštas saugos lygis"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Slaptažodis"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Aukštas saugos lygis"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Neleido: administr., šifrav. polit. ar įgalioj. atmint."</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Nėra"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5660014471997663139">"Slinkti"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Atrakinimas pagal veidą"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Šablonas"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN kodas"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Slaptažodis"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Išjungti ekrano užraktą"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Pašalinti atrakinimo modelį"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Pašalinti atrakinimo PIN kodą"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Pašalinti atrakinimo slaptažodį"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Keisti atrakinimo modelį"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Pakeisti atrakinimo PIN kodą"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Pakeisti atrakinimo slaptažodį"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Slaptažodį turi sudaryti mažiausiai %d simboliai."</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"PIN kodą turi sudaryti mažiausiai %d skaitm."</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Atlikę spustelėkite „Tęsti“"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Tęsti"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Slaptažodį turi sudaryti mažiau nei <xliff:g id="NUMBER">%d</xliff:g> simboliai (-ių)."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"PIN kodą turi sudaryti mažiau nei <xliff:g id="NUMBER">%d</xliff:g> skaitmenys (-ų)."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"PIN kodas turi būti sudarytas tik iš skaitmenų 0–9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Įrenginio administratorius neleidžia naudoti pastarojo PIN kodo."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Slaptažodyje yra neleistinas simbolis."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Slaptažodyje turi būti bent viena raidė."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Slaptažodyje turi būti bent vienas skaitmuo."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Slaptažodį turi sudaryti bent vienas simbolis."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Slaptažodyje turi būti bent 1 raidė."</item>
    <item quantity="other" msgid="8186027808415585970">"Slaptažodyje turi būti bent %d raidės (-ių)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Slaptažodyje turi būti bent 1 mažoji raidė."</item>
    <item quantity="other" msgid="2693910942679679225">"Slaptažodyje turi būti bent %d mažosios (-ųjų) raidės (-ių)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Slaptažodyje turi būti bent 1 didžioji raidė."</item>
    <item quantity="other" msgid="3030801209112209245">"Slaptažodyje turi būti bent %d didžiosios (-iųjų) raidės (-ių)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Slaptažodyje turi būti bent 1 skaičius."</item>
    <item quantity="other" msgid="4703982391407595924">"Slaptažodyje turi būti bent %d skaičiai (-ių)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Slaptažodyje turi būti bent 1 specialus simbolis."</item>
    <item quantity="other" msgid="1221290525051187757">"Slaptažodyje turi būti bent %d specialūs (-ių) simboliai (-ių)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Slaptažodyje turi būti bent 1 neraidinis simbolis."</item>
    <item quantity="other" msgid="3952508584649046404">"Slaptažodyje turi būti bent %d neraidiniai (-ių) simboliai (-ių)."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Įrenginio administratorius neleidžia naudoti pastarojo slaptažodžio."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"Gerai"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Atšaukti"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Atšaukti"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Kitas"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Sąranka baigta."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Įrenginio administravimas"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Įrenginio administratoriai"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Žiūrėti arba išaktyvinti įrenginio administratorius"</string>
    <string name="manage_notification_access" msgid="5799781079264981979">"Prieiga prie pranešimų"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Programos negali skaityti pranešimų"</string>
  <plurals name="manage_notification_access_summary_nonzero">
    <item quantity="one" msgid="8344183614159211585">"%d programa gali skaityti pranešimus"</item>
    <item quantity="other" msgid="980049191810249052">"%d program. gali skaityti pranešimus"</item>
  </plurals>
    <string name="no_notification_listeners" msgid="2767405417723149879">"Neįdiegta pranešimų skaitymo priemonių."</string>
    <string name="notification_listener_security_warning_title" msgid="6494221261778885893">"Įgalinti „<xliff:g id="SERVICE">%1$s</xliff:g>“?"</string>
    <string name="notification_listener_security_warning_summary" msgid="2780319203595885564">"„<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>“ galės skaityti visus sistemos ar įdiegtų programų skelbiamus pranešimus, kuriuose gali būti asmeninės informacijos, pavyzdžiui, kontaktų vardų ir jums atsiųstų pranešimų teksto. Ji taip pat galės atsisakyti šių pranešimų arba jose paliečiamų mygtukų veiksmų."</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Įjungti „Bluetooth“"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Valdyti ryšius, nustatyti įrenginio pavadinimą ir atrandamumą"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"„Bluetooth“ susiejimo užklausa"</string>
    <string name="bluetooth_enter_pin_msg" msgid="5698297871117529185">"Susieti su: <xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g> Įveskite įrenginio reikalaujamą PIN kodą:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="2220143735340367939">"Susieti su: <xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g> Įveskite įrenginio reikalaujamą prieigos raktą:"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN kodą sudaro raidės arba simboliai"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Paprastai 0000 arba 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Galbūt reikės šį PIN kodą įvesti kitame įrenginyje."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Galbūt reikės šį prieigos raktą įvesti kitame įrenginyje."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Jei norite suporuoti su:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Įsitikinkite, kad jame rodomas šis prieigos raktas:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Iš:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Poruoti su šiuo įrenginiu?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Susieti su: <xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g> Įveskite: <xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, tada paspauskite „Grįžti“ arba „Enter“."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Susieti"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Atšaukti"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Nepavyko susieti su „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Nepavyko susieti su „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ dėl netinkamo PIN kodo ar prieigos rakto."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Nepavyksta užmegzti ryšio su „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Susiejimą atmetė <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Nepavyko prisijungti prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Nuskaityti ieškant įrenginių"</string>
    <string name="bluetooth_search_for_devices" msgid="5957007154213560390">"Ieškoti įrenginių"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Ieškoma…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Įrenginių nustatymai"</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Susieti įrenginiai"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Galimi įrenginiai"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Prijungti"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Atjungti"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Susieti ir jungti"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Panaikinti susiejimą"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Atjungti ir atsieti"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Parinktys…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Išplėst. nust."</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Išplėst. „Bluetooth“ nust."</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="4793562956642282639">"Jei norite peržiūrėti įrenginius, įjunkite „Bluetooth“."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Prijungti prie..."</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Laikmenos garsas"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Telefono garsas"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Failo perkėlimas"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Įvesties įrenginys"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Prieiga prie interneto"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Interneto ryšio bendrinimas"</string>
    <string name="bluetooth_profile_map" msgid="5465271250454324383">"Prieiga prie pranešimų"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus atjungtas nuo medijos garso."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus atjungtas nuo laisvų rankų įrangos garso."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus atjungtas nuo įvesties įrenginio."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Prieiga prie interneto naudojant „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus išjungta."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus išjungtas šio planšetinio kompiuterio interneto ryšio bendrinimas."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus išjungtas šio telefono interneto ryšio bendrinimas."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Susietas „Bluetooth“ įrenginys"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Prijungti"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Prijungti prie „Bluetooth“ įrenginio"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="3764437426089639639">"Profiliai"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Pervadinti"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Leisti gaunamų failų perdavimą"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Prijungta prie medijos garso įrašo"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Prijungta prie telefono garso"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Prijungta prie failų perkėlimo serverio"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="8191407438851351713">"Prisijungta prie žemėlapio"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Neprijungta prie failų perkėlimo serverio"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Prisijungta prie įvesties įrenginio."</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Pr. prie įr., kad gaut. pr. prie int."</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Bendr. vt. int. ryš. su įr."</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Naudoti medijos garsui"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Naudoti telefono garso įrašui"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Naudoti failų perkėlimui"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Naudoti įvedant"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Naudoti interneto prieigai"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="5154200119919927434">"Naudoti žemėlapyje"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Doko nustatymai"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Naudoti doką garsui"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kaip kalbėtojo telefonas"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Muzikai ir medijai"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Atsiminti nustatymus"</string>
    <string name="wifi_display_settings_title" msgid="2925465988657380522">"Perduoti ekraną"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Įgalinti belaidį rodymą"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Nerasta netoliese esančių įrenginių."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Jungiama"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Prijungta"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Naudojama"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nepasiekiamas"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Pateikties nustatymai"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Belaidžio rodymo parinktys"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Pamiršti"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Atlikta"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Pavadinimas"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Leisti keistis duomenimis, kai planšetinis kompiuteris aptinka kitą įrenginį"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Leisti keistis duomenimis, kai telefonas paliečia kitą įrenginį"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Parengta perduoti programos turinį naudojant ALR"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Išjungta"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Negalima, nes išjungtas ALR"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Kai ši funkcija įjungta, galite programos turinį perduoti į kitą ALR palaikantį įrenginį laikydami du įrenginius šalia. Pavyzdžiui, galite perduoti Naršyklės puslapius, „YouTube“ vaizdo įrašus, žmonių kontaktus ir daugiau.\n\nTiesiog sudėkite du įrenginius vieną šalia kito (suglaudę galinėmis dalimis) ir palieskite ekraną. Programa nustato, kas bus perduodama."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Tinklo paslaugos aptikimas"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Leisti kitų įrenginių programoms aptikti šio įrenginio programas"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Įjungti „Wi-Fi“"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"„Wi-Fi“ nustatymai"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Nustatyti ir valdyti bevielius prieigos taškus"</string>
    <string name="wifi_setup_wizard_title" msgid="8242230950011819054">"Rinktis „Wi-Fi“"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"„Wi-Fi“ įjungiama…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"„Wi-Fi“ išjungiama…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Klaida"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Veikia lėktuvo režimu"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Nepavyksta nuskaityti tinklų"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Tinklo įspėjimas"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3038290727701553612">"Pranešti, kai bus galimas atviras tinklas"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Vengti prasto ryšio"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7843672905900544785">"Nenaudoti „Wi-Fi“ tinklo, jei jo interneto ryšys nėra geras"</string>
    <string name="wifi_scan_always_available" msgid="3470564139944368030">"Nuskaitymas visada pasiekiamas"</string>
    <string name="wifi_scan_always_available_summary" msgid="7768204638882691453">"Leisti „Google“ vietovių paslaugai ir kitoms programoms nuskaityti tinklus, net kai „Wi-Fi“ išjungtas"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Įdiegti sertifikatus"</string>
    <string name="wifi_scan_notify_text_location_on" msgid="8135076005488914200">"Kad patobulintumėte vietovių tikslumą ir kitais tikslais, leiskite „Google“ vietovių paslaugai ir kitoms programoms ieškoti netoliese esančių „Wi-Fi“ tinklų, net jei „Wi-Fi“ išjungtas. Jei nenorite, kad būtų ieškoma, eikite į skiltį „Išplėstiniai“ &gt; „Visada galima ieškoti“."</string>
    <string name="wifi_scan_notify_text_location_off" msgid="6323983741393280935">"Programos gali ieškoti netoliese esančių tinklų, net kai „Wi-Fi“ yra išjungtas. Jei nenorite, kad būtų ieškoma, eikite į skiltį „Išplėstiniai“ &gt; „Visada galima ieškoti“."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="5340097010842405981">"Daugiau neberodyti"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Išlaikyti „Wi-Fi“ įjungtą, kai veikia miego režimas"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Keičiant nustatymą kilo problemų"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"„Wi-Fi“ optimizavimas"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Sumažinti akumuliatoriaus naudojimą, kai „Wi-Fi“ įjungta"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Pridėti tinklą"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"„Wi-Fi“ tinklai"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"WPS paspaudimo mygt."</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Daugiau parinkčių"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"WPS PIN kodo įrašas"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Tiesiog. „Wi-Fi“ r."</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Nuskaityti"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Išplėstinis"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Prijungti prie tinklo"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Pamiršti tinklą"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Keisti tinklą"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Kad peržiūrėt. galimus tinklus, įjunkite „Wi-Fi“."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Ieškoma „Wi-Fi“ tinklų…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="8280257225419947565">"Neturite leidimo keisti „Wi‑Fi“ tinklą."</string>
    <string name="wifi_other_network" msgid="1048006316504242214">"Kitas tinklas…"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Daugiau"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automatinė sąranka (WPS)"</string>
    <string name="wifi_required_info_text" msgid="4080969509965288881">"Kad užbaigtumėte sąranką, planšetiniam kompiuteriui turi būti suteikta prieiga prie „Wi-Fi“. Baigę sąranką galėsite perjungti iš mobiliojo ryšio duomenų į „Wi-Fi“ ir atvirkščiai."</string>
    <string name="wifi_show_advanced" msgid="1793703023711426246">"Rodyti išplėstines parinktis"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Apsaugota „Wi-Fi“ sąranka"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Pradedama WPS…"</string>
    <string name="wifi_wps_onstart_pbc" msgid="5940801028985255304">"Maršruto parinktuve paspauskite apsaugotos „Wi-Fi“ sąrankos mygtuką. Jis gali būti pavadintas WPS arba nurodytas šiuo simboliu:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Įveskite „Wi-Fi“ maršruto parinktuvo PIN kodą <xliff:g id="NUMBER">%1$s</xliff:g>. Sąranka gali užtrukti iki dviejų minučių."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"WPS pavyko. Prisijungiama prie tinklo…"</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Prisijungta prie „Wi-Fi“ tinklo „<xliff:g id="NETWORK_NAME">%s</xliff:g>“"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS jau vykdoma ir gali užtrukti iki dviejų minučių, kol bus baigta."</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"WPS neįvykdyta. Po kelių minučių bandykite dar kartą."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Belaidžio maršruto parinktuvo saugos nustatymas (WEP) nepalaikomas"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Belaidžio maršruto parinktuvo saugos nustatymas (TKIP) nepalaikomas"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Nepavyko autentifikuoti. Bandykite dar kartą."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Aptikta kita WPS sesija. Po kelių minučių bandykite dar kartą."</string>
    <string name="wifi_ssid" msgid="641393708309146745">"Tinklo SSID"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Įveskite SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Sauga"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Signalo stiprumas"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Būsena"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Susiejimo greitis"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP adresas"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"EAP būdas"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"2 tapatybės nustatymo fazė"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"CA sertifikatas"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Naudotojo sertifikatas"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Tapatybė"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anoniminė tapatybė"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Slaptažodis"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Rodyti slaptažodį"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP nustatymai"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nepakeista)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(nenurodyta)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Išsaugotas"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Neleidžiama"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"Išvengta prasto interneto ryšio"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Autentifikavimo problema"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Ne diapazone"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"Galima WPS"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (galima WPS)"</string>
    <string name="wifi_secured_first_item" msgid="4072076186051083451">"Saugoma „<xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>“"</string>
    <string name="wifi_secured_second_item" msgid="1326000076939056265">", saugoma „<xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>“"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Nėra"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Siekiant tiksliau nustatyti vietą ir dėl kitų priežasčių, „<xliff:g id="APP_NAME">%1$s</xliff:g>“ prašo leidimo nuskaityti tinklus, net kai „Wi-Fi“ yra išjungtas.\n\nAr norite suteikti leidimą nuskaityti visoms to prašančioms programoms?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Leisti"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Atmesti"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Prijungti"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Jungiantis prie tinklo įvyko klaida."</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Pamiršti"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Ištrinant tinklą įvyko klaida."</string>
    <string name="wifi_save" msgid="3331121567988522826">"Išsaugoti"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Išsaugant tinklą įvyko klaida."</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Atšaukti"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Vis tiek praleisti"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Nepraleisti"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="3335132188969450252">"ĮSPĖJIMAS: gali būti taikomi papildomi operatoriaus duomenų mokesčiai.\n\nNustatant planšetinį kompiuterį gali reikėti daug naudoti tinklą."</string>
    <string name="wifi_skipped_message" product="default" msgid="1192848364146401759">"ĮSPĖJIMAS: gali būti taikomi papildomi operatoriaus duomenų mokesčiai.\n\nNustatant telefoną gali reikėti daug naudoti tinklą."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="6161024589991810940">"ĮSPĖJIMAS: planšetinis kompiuteris galės patvirtinti, kad naudojama naujausia programinė įranga, tik kai bus pasiekiamas interneto ryšys."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="3773473163264984767">"ĮSPĖJIMAS: telefonas galės patvirtinti, kad naudojama naujausia programinė įranga, tik kai bus pasiekiamas interneto ryšys."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Planšetiniam kompiuteriui nepavyko prisijungti prie šio „Wi-Fi“ tinklo."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefonui nepavyko prisijungti prie šio „Wi-Fi“ tinklo."</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Išplėstinis „Wi-Fi“"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"„Wi-Fi“ dažnių juosta"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Nurodyti veikimo dažnumą"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Nustatant dažnių juostą iškilo problema."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC adresas"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP adresas"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"IP nustatymai"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Išsaugoti"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Atšaukti"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Įveskite galiojantį IP adresą."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Įveskite galiojantį tinklų sietuvo adresą."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Įveskite galiojantį DNS adresą."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Įveskite 0–32 simbolių tinklo kodą."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Tinklų sietuvas"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Tinklo kodo ilgis"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Tiesiog. „Wi-Fi“ r."</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Įrenginio informacija"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Atsiminti šį ryšį"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Ieškoti įrenginių"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Ieškoma…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Pervardyti įrenginį"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Lygiaverčiai įrenginiai"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Įsimintos grupės"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Nepavyko prijungti."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Nepavyko pervardyti įrenginio."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Atsijungti?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Atsijungus, bus nutrauktas ryšys su „<xliff:g id="PEER_NAME">%1$s</xliff:g>“."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Atsijungus, bus nutrauktas ryšys su „<xliff:g id="PEER_NAME">%1$s</xliff:g>“ ir <xliff:g id="PEER_COUNT">%2$s</xliff:g> kitais (-ų) įrenginiais (-ių)."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Atšaukti kvietimą?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Ar norite atšaukti kvietimą prisijungti prie <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Pamiršti šią grupę?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Kilnojamasis „Wi-Fi“ viešosios interneto prieigos taškas"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Įjungiamas viešosios interneto prieigos taškas…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Išjungiamas viešosios interneto prieigos taškas…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Perkeliama aktyvioji sritis <xliff:g id="NETWORK_SSID">%1$s</xliff:g> aktyvi"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Kilnojamojo „Wi-Fi“ viešosios interneto prieigos taško klaida"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Nustatyti „Wi-Fi“ viešosios interneto prieigos tašką"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g> kilnojamasis „Wi-Fi“ viešosios interneto prieigos taškas"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"„AndroidHotspot“"</string>
    <string name="home_settings" msgid="212375129455718176">"Pagrindinis"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Ekranas"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Garsas"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Telefono skambėjimo tonas"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Garsumas"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Muzikos efektai"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Skambučio garsumas"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibruoti, kai veikia tyliuoju režimu"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Numatytasis pranešimo garsas"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Pulsuojanti įspėjimo šviesa"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Skambėjimo tonas"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Įspėjimas"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Įspėjimams naudoti gaunamų skambučių garsumą"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Numatytasis pranešimo garsas"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Medija"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Nustatyti muzikos ir vaizdo įrašų garsumą"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Signalas"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Pridėtos piktogramų juostos garso nustatymai"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Numerio rinkimo planšetinio komp. lietimo tonas"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Lietimo garsai"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Ekrano užrakto nustatymai"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Palietus vibruoti"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Triukšmo atšaukimas"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muzika, vaizdo įrašai, žaidimai ir kita medija"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Skambėjimo tonas ir pranešimai"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Pranešimai"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Įspėjamieji signalai"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Nutildyti skambėjimo toną ir pranešimus"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Nutildyti muziką ir kitą mediją"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Nutildyti pranešimus"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Nutildyti signalus"</string>
    <string name="vibrate_when_ringing_title" msgid="3885857358303178029">"Vibruoti, kai skambina"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Piktogramų juosta"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Doko nustatymai"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Garso įrašas"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Pridėtos darbalaukio piktogramų juostos nustatymai"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Pridėto automobilinio stovo nustatymai"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Planšetinis kompiuteris neįstatytas"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefonas neprijungtas"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Pridėtos piktogramų juostos nustatymai"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dokas nerastas"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Prieš nustatydami prijungimo garso įrašą turėsite prijungti planšetinį kompiuterį."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Prieš nustatydami prijungimo garso įrašą turėsite prijungti telefoną."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Doko įstatymo garsas"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Paleisti garsą įdedant planšetinį kompiuterį į doką ar jį pašalinant"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Paleisti garsą, kai telefonas įdedamas ar pašalinamas iš dėklo"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Nepaleisti garso įdedant planšetinį kompiuterį į doką ar jį pašalinant"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Nepaleisti garso įterpiant ar pašalinant telefoną iš dėklo"</string>
    <string name="account_settings" msgid="6403589284618783461">"Paskyros"</string>
    <string name="search_settings" msgid="1910951467596035063">"Ieškoti"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Valdyti paieškos nustatymus ir istoriją"</string>
    <string name="display_settings" msgid="7965901687241669598">"Ekranas"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Automatiškai sukti ekraną"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Sukant planšetinį kompiuterį automatiškai perjungti orientaciją"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Perjungti padėtį automatiškai, kai sukamas telefonas"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Sukant planšetinį kompiuterį automatiškai perjungti orientaciją"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Perjungti padėtį automatiškai, kai sukamas telefonas"</string>
    <string name="brightness" msgid="2354961343555249270">"Ryškumas"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Reguliuoti ekrano ryškumą"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Užmigti"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neveiklumo"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Darbalaukio fonas"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Pasirinkti darbalaukio foną iš"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Svajonė"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Kai yra doke arba kai veikia miego režimas ir kraunamas akumuliatorius"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Abiem atvejais"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Įkraunant"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kai yra doke"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Išjungta"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Jei norite valdyti, kas vyksta, kai telefonas yra doke ir (arba) veikia miego režimu, įjunkite funkciją „Svajonės“."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Kada svajoti"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Pradėti dabar"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Nustatymai"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatinis ryškumas"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Šrifto dydis"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Šrifto dydis"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"SIM kortelės užrakto nustatymai"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Nustatyti SIM kortelės užraktą"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"SIM kortelės užraktas"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Užrakinti SIM kortelę"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Norint naudoti planšetinį kompiuterį, reikia PIN kodo"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Reikalauti PIN kodo, kad būtų galima naudoti telefoną"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Norint naudoti planšetinį kompiuterį, reikia PIN kodo"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Reikalauti PIN kodo, kad būtų galima naudoti telefoną"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Pakeisti SIM kortelės PIN kodą"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"SIM kortelės PIN kodas"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Užrakinti SIM kortelę"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Atrakinti SIM kortelę"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Senas SIM kortelės PIN kodas"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Naujas SIM kortelės PIN kodas"</string>
    <string name="sim_reenter_new" msgid="3178510434642201544">"Iš naujo įveskite naują PIN kodą"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"SIM kortelės PIN kodas"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Netinkamas PIN kodas"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"PIN kodai neatitinka"</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Nepavyksta pakeisti PIN kodo.\nTikriausiai netinkamas PIN kodas."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"SIM kortelės PIN kodas sėkmingai pakeistas"</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Neįmanoma pakeisti SIM kortelės užrakto būsenos.\nTikriausiai netinkamas PIN kodas."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"Gerai"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Atšaukti"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Netinkamas SIM kortelės PIN kodas. Reikės susisiekti su operatoriumi, kad atrakintų įrenginį."</string>
  <plurals name="wrong_pin_code">
    <item quantity="one" msgid="4840607930166101114">"Netinkamas SIM kortelės PIN kodas. Jums liko <xliff:g id="NUMBER">%d</xliff:g> band. Paskui reikės susisiekti su operatoriumi, kad jis atrakintų įrenginį."</item>
    <item quantity="other" msgid="77103619544346451">"Netinkamas SIM kortelės PIN kodas, liko <xliff:g id="NUMBER">%d</xliff:g> band."</item>
  </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Nepavyko atlikti SIM kortelės PIN kodo operacijos."</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Planšetinio kompiuterio būsena"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Telefono būsena"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Sistemos naujiniai"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"„Android“ versija"</string>
    <string name="model_number" msgid="3765737700545384794">"Modelio numeris"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"Įrangos ID"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Nemoduliuojamo perdavimo versija"</string>
    <string name="kernel_version" msgid="9192574954196167602">"„Kernel“ versija"</string>
    <string name="build_number" msgid="3075795840572241758">"Versijos numeris"</string>
    <string name="selinux_status" msgid="6212165375172061672">"„SELinux“ būsena"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Negalima"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Būsena"</string>
    <string name="device_status" msgid="607405385799807324">"Būsena"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Akumuliatoriaus, tinklo būsena ir kita informacija"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefono numeris, signalas ir kt."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Atmintinė"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Atmintinės nustatymai"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Atjungti USB atmintinę, žiūrėti pasiekiamą atmintinę"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Išimti SD kortelę, žiūrėti galimą saugyklą"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Mano telefono numeris"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN."</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"PRL versija"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="3279383550222116235">"Mobilaus tinklo tipas"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Operatoriaus informacija"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Mobiliojo tinklo būsena"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Paslaugos būsena"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Signalo stiprumas"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Tarptinklinis ryšys"</string>
    <string name="status_operator" msgid="2274875196954742087">"Tinklas"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"„Wi-Fi“ MAC adresas"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"„Bluetooth“ adresas"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Serijos numeris"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Užimtas (-a)"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Veikimo laikas"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Veikimo laikas"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Vidinė atmint."</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"USB atmintinė"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"SD kortelė"</string>
    <string name="memory_available" msgid="5052397223077021181">"Pasiekiama"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Pasiekiama (tik skaitoma)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Visa vieta"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Skaičiuojama..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Programos (programų duomenys ir medijos turinys)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Medija"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Atsisiuntimai"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Paveikslėliai, vaizdo įrašai"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Garso įr. (muzika, skamb. tonai, tinklal. ir kt.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Įvairūs"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Talpykloje saugomi duomenys"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Atjung. bendrin. atmint."</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Išimti SD kortelę"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Atjungti vidinę USB atmintinę"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Atjunkite SD kortelę, kad galėtumėte ją saugiai pašalinti"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Įdėti prijung. USB atmint."</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Įdėti SD kortelę, kad ji būtų įmontuota"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Prijungti USB atmintinę"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Įdėti SD kortelę"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Ištrinti USB atmintinę"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Ištrinti SD kortelę"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Ištrinami visi vidinės USB atmint. duomenys, pvz., muzikos failai ir nuotraukos"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Ištrinami visi SD kortelės duomenys, pvz., muzikos failai ir nuotraukos"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Išvalyti talpykloje saugomus duomenis?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Bus išval. visų progr. talpykl. saugomi duomen."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"MTP ar PTP funkcija aktyvi"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Pašalinti USB atmintį?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Išimti SD kortelę?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Jei pašalinsite USB atmintį, kai kurios naudojamos programos bus sustabdytos ir gali būti nepasiekiamos, kol iš naujo ją įrengsite."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Jei išimsite SD kortelę, kai kurios naudojamos programos bus sustabdytos ir gali būti nepasiekiamos, kol iš naujo įdėsite SD kortelę."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"Nepavyko pašalinti USB atminties. Vėliau bandykite dar kartą."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Nepavyko išimti SD kortelės. Vėliau bandykite dar kartą."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"USB atmintinė bus atjungta."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"SD kortelė bus atjungta."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Išėmimas"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Vykdomas išėmimas"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Mažėja laisvos saugyklos vietos"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Kai kurios sistemos funkcijos, pvz., sinchronizavimas, gali neveikti tinkamai. Pabandykite atlaisvinti vietos ištrynę ar atsegę elementus, pvz., programas ar medijos turinį."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"USB kompiuterio jungtis"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"USB kompiuterio jungtis"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Prisijungti kaip"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Medijos įrenginys (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Leidžia perduoti failus „Windows“ ar „Mac“ naudojant „Android File Transfer“ (žr. šiuo adresu: www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparatas (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Galite perduoti nuotraukas naudodami fotoaparato programinę įrangą ir perduoti bet kokius failus MTP nepalaikančiuose kompiuteriuose"</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Įdiegti failų perdavimo įrankius"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Kiti naudotojai"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Akumuliatoriaus būsena"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Akumuliatoriaus lygis"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Redaguoti prieigos tašką"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nenustatyta"</string>
    <string name="apn_name" msgid="4115580098369824123">"Pavadinimas"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Tarpinis serveris"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Prievadas"</string>
    <string name="apn_user" msgid="455637547356117761">"Naudotojo vardas"</string>
    <string name="apn_password" msgid="5412301994998250968">"Slaptažodis"</string>
    <string name="apn_server" msgid="2436185314756372858">"Serveris"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"MMS tarpinis serveris"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"MMS prievadas"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MKC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Tapatybės nustatymo tipas"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Nėra"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP arba CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"APN tipas"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"APN protokolas"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"APN tarptinklinio ryšio protokolas"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Įgalinti / neleisti APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN įgalinta"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN neleidžiama"</string>
    <string name="bearer" msgid="594270280031923558">"Nešiklis"</string>
    <string name="mvno_type" msgid="2543253857818336421">"MVNO tipas"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"MVNO vertė"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Ištrinti APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Naujas APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Išsaugoti"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Atmesti"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Pavadinimo laukas negali būti tuščias."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"APN negali būti tuščias."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MKC lauke turi būti įvesti 3 skaitmenys."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"MNC lauke turi būti įvesti 2 ar 3 skaitmenys."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Atkuriami numatytieji APN nustatymai."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Nustatyti iš naujo į numatytuosius nustatymus"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Numatytųjų APN nustatymų nustatymas iš naujo baigtas."</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Gamyklos duomenų nustatymas iš naujo"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Ištrinami visi planšetinio kompiuterio duomenys"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Ištrina visus telefono duomenis"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"Taip bus ištrinti visi duomenys iš planšetinio kompiuterio "<b>"vidinės atminties"</b>", įskaitant:\n\n"<li>"„Google“ paskyrą"</li>\n<li>"Sistemos ir programų duomenis bei nustatymus"</li>\n<li>"Atsisiųstas programas"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"Taip bus ištrinti visi duomenys iš telefono "<b>"vidinės atminties"</b>", įskaitant:\n\n"<li>"„Google“ paskyrą"</li>\n<li>"Sistemos ir programų duomenis bei nustatymus"</li>\n<li>"Atsisiųstas programas"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Šiuo metu esate prisijungę prie šių paskyrų:\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muzika"</li>\n<li>"Nuotraukos"</li>\n<li>"Kiti naudotojo duomenys"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Norint išvalyti muzikos failus, paveikslėlius bei kitus naudotojo duomenis, reikia ištrinti "<b>"USB atmintį"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Norint išvalyti muzikos failus, paveikslėlius ir kitus naudotojo duomenis, reikia ištrinti "<b>"SD kortelę"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Ištrinti USB atmintinę"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Ištrinti SD kortelę"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Ištrinti visus vidinės USB atminties duomenis, pvz., muzikos failus ar nuotraukas"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Ištrinti visus SD kortelės duomenis, pvz., muzikos failus ar nuotraukas"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Iš naujo nustatyti planšetinį kompiuterį"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Iš naujo nustatyti telefoną"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Ištrinti visą asmeninę informaciją ir atsisiųstas programas? Šio veiksmo negalėsite atšaukti!"</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Ištrinti viską"</string>
    <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Nustatyti atrakinimo modelį"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Kad patvirtintumėte gamyklinių duomenų nustatymą iš naujo, turite nubrėžti atrakinimo šabloną."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Nebuvo nustatyta iš naujo, nes paslauga „Sistemos išvalymas“ nepasiekiama."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Nustatyti iš naujo?"</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Ištrinti USB atmintinę"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Ištrinti SD kortelę"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Ištrin. visi USB atm. duomenys"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Ištrina visus SD kortelės duomenis"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Ištrinti visą USB atmintį? Prarasite "<b>"visus"</b>" saugomus duomenis!"</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Ištrinti SD kortelę? Prarasite "<b>"visus"</b>" joje esančius duomenis!"</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Ištrinti USB atmintinę"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Ištrinti SD kortelę"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Ištrinti USB atmintinę ištrinant visus joje saugomus failus? Šio veiksmo negalėsite atšaukti!"</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Ištrinti SD kortelę ištrinant visus joje saugomus failus? Šio veiksmo negalėsite atšaukti!"</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Ištrinti viską"</string>
    <string name="media_format_gesture_prompt" msgid="3109349468816856670">"Nustatyti atrakinimo modelį"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Kad patvirtintumėte, jog norite ištrinti USB atmintinę, turite nubrėžti atrakinimo šabloną."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Kad patvirtintumėte, jog norite ištrinti SD kortelę, turite nubrėžti atrakinimo šabloną."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Skambinimo nustatymai"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Nustatyti balso paštą, skambučio peradresavimą, skambučio laukimą, skambintojo ID"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"USB susiejimas"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Perkeliama aktyvioji sritis"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"„Bluetooth“ susiejimas"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Susiejimas"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Susiej. ir perk. vieš. int. pr. tašk."</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"USB susiejimas"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"USB prijungtas, pažymėkite, kad susietų"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Susieta"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Negalima įrenginio naudoti kaip modemo, kai naudojama USB atmintinė"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB neprijungtas"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"USB susiejimo klaida"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"„Bluetooth“ susiejimas"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Bendrinamas šio planšetinio komp. interneto ryšys"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Bendrinamas šio telefono interneto ryšys"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Bendrinamas šio planš. komp. interneto ryšys su 1 įrenginiu"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Bendrinamas šio telefono interneto ryšys su 1 įrenginiu"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Bendrinamas šio planš. komp. interneto ryšys su <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> įreng."</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Bendrinamas šio tel. intern. ryšys su <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> įrenginiais (-ių)"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Nebendrinamas šio planš. komp. interneto ryšys"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Nebendrinamas šio telefono interneto ryšys"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Įrenginys nenaudojamas kaip modemas"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Negalima daugiau nei <xliff:g id="MAXCONNECTION">%1$d</xliff:g> įrenginių (-io) naudoti kaip modemo (-ų)."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ bus atsietas."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pagalba"</string>
    <string name="network_settings_title" msgid="7967552516440151852">"Mobilūs tinklai"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Mobiliojo ryšio planas"</string>
    <string name="sms_application_title" msgid="6134351177937015839">"Numatytoji SMS programa"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Pakeisti SMS programą?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Naudoti „<xliff:g id="NEW_APP">%s</xliff:g>“ kaip SMS programą vietoj „<xliff:g id="CURRENT_APP">%s</xliff:g>“?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Naudoti „<xliff:g id="NEW_APP">%s</xliff:g>“ kaip SMS programą?"</string>
    <string name="mobile_unknown_sim_operator" msgid="9101230468757324260">"Nežinomas SIM operatorius"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"„%1$s“ neturi aprūpinimo svetainės"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Įdėkite SIM kortelę ir paleiskite iš naujo"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Prisijunkite prie interneto"</string>
    <string name="location_title" msgid="1029961368397484576">"Mano vieta"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Režimas"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Didelis tikslumas"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Akumuliatoriaus tausojimas"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Tik įrenginys"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Vietovė išjungta"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Pastarosios vietovės užklausos"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Nė viena programa pastaruoju metu nepateikė užklausų dėl vietovės"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Vietovės nustatymo paslaugos"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Naudoja daug akum. energijos"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Naudoja mažai akum. energijos"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Vietovės režimas"</string>
    <string name="location_mode_high_accuracy_description" msgid="6418936349431602808">"Vietovę nustatyti naudojant GPS, „Wi‑Fi“ ir mobiliojo ryšio tinklus"</string>
    <string name="location_mode_battery_saving_description" msgid="1728668969743485109">"Vietovę nustatyti naudojant „Wi‑Fi“ ir mobiliojo ryšio tinklus"</string>
    <string name="location_mode_sensors_only_description" msgid="7178415350457794366">"Vietovę nustatyti naudojant GPS"</string>
    <string name="location_loading_injected_setting" msgid="4238574500081976654">"Nuskaitoma…"</string>
    <string name="location_network_based" msgid="9134175479520582215">"„Wi-Fi“ ir mob. tinklo vietovė"</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"Leisti programoms naud. „Google“ viet. pasl., kad viet. būtų nustatoma greičiau. Anonim. viet. duom. bus renk. ir siunč. „Google“."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Vietą nustatė „Wi-Fi“"</string>
    <string name="location_gps" msgid="8392461023569708478">"GPS palydovai"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Leisti programoms naudoti GPS planšetiniame kompiuteryje jūsų vietovei nustatyti"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Leisti programoms naudoti GPS telefone jūsų vietovei nustatyti"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Naudoti pagalbos GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Naudoti serverį norint padėti GPS (panaikinkite žymėjimą, jei norite sumažinti tinklo naudojimą)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Naudoti serverį norint padėti GPS (panaikinkite žymėjimą, jei norite patobulinti GPS našumą)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Vieta ir „Google“ paieška"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Leisti „Google“ naudoti jūsų vietą paieškos rezultatams ir kitoms paslaugoms tobulinti"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Mano vietovės prieiga"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Leisti programoms, paprašiusioms leidimo, naudoti vietovės informaciją"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Vietovės šaltiniai"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Apie planšetinį kompiuterį"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Apie telefoną"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Žiūrėti teisinę informaciją, būseną, programinės įrangos versiją"</string>
    <string name="legal_information" msgid="5769301644270604095">"Teisinė informacija"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Pagalbininkai"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Reguliuojam. informacija"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorių teisės"</string>
    <string name="license_title" msgid="1990487604356037871">"Licencija"</string>
    <string name="terms_title" msgid="7697580845616764642">"Taisyklės ir nuostatos"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Atvirojo šaltinio licencijos"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Įkeliant licencijas iškilo problema."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Įkeliama…"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Saugos informacija"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Saugos informacija"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Nėra duomenų ryšio. Jei norite dabar peržiūrėti šią informaciją, bet kuriuo prie interneto prijungtu kompiuteriu eikite į %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Įkeliama…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Pasirinkite slaptažodį"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Pasirinkite šabloną"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Pasirinkite PIN kodą"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Patvirtinkite slaptažodį"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Patvirtinkite šabloną"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Patvirtinkite savo PIN kodą"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Slaptažodžiai neatitinka"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"PIN kodai neatitinka"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Atrakinti pasirinkimą"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Slaptažodis nustatytas"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"PIN kodas nustatytas"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Modelis nustatytas"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Ekrano sauga"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Keisti atrakinimo modelį"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Pakeisti atrakinimo PIN kodą"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Patvirtinti išsaugotą modelį"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Bandykite dar kartą:"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Nustatyti atrakinimo modelį"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Jei norite gauti pagalbos, paspauskite „Meniu“."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Baigę atleiskite pirštą"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Sujunkite mažiausiai <xliff:g id="NUMBER">%d</xliff:g> tašk. Bandykite dar kartą."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Piešinys įrašytas"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Dar kartą nubrėžkite piešinį, kad patvirtintumėte"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Naujas atrakinimo piešinys"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Patvirtinti"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Nustatyti iš naujo"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Bandyti dar kartą"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Tęsti"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Atrakinimo modelis"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Reikalauti modelio"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Jei norite atrakinti ekraną, reikia nustatyti modelį"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Padaryti šabloną matomą"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibruoti palietus"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Maitin. myg. iškart užrakin."</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Nustatyti atrakinimo modelį"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Keisti atrakinimo modelį"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kaip nustatyti atrakinimo modelį"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Per daug neteisingų bandymų!"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Bandyti dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sek."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Programa jūsų telefone neįdiegta."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Valdyti programas"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Tvarkykite ir pašalinkite įdiegtas programas"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Programos"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Valdyti programas, nustatyti greitojo paleidimo sparčiuosius klavišus"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Programos nustatymai"</string>
    <string name="install_applications" msgid="4872012136210802181">"Nežinomi šaltiniai"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Leisti diegti programas iš nežinomų šaltinių"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Planšetinis kompiuteris ir asmeniniai duomenys prastai apsaugoti nuo programų iš nežinomų šaltinių atakų. Sutinkate, kad tik jūs atsakote už visus planšetinio kompiuterio pažeidimus ar duomenų praradimą naudojant šias programas."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Telefonas ir asmeniniai duomenys prastai apsaugoti nuo programų iš nežinomų šaltinių atakų. Sutinkate, kad tik jūs atsakote už visus telefono pažeidimus ar duomenų praradimą naudojant šias programas."</string>
    <string name="verify_applications" msgid="2959359554974828518">"Patvirtinti programas"</string>
    <string name="verify_applications_summary" msgid="6737505521913263792">"Neleisti arba įspėti prieš diegiant programas, kurios gali būti kenksmingos"</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Išplėstiniai nustatymai"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Įgalinti daugiau nustatymų parinkčių"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Programos informacija"</string>
    <string name="storage_label" msgid="8700867073480107253">"Saugykla"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Paleisti pagal numatytuosius nustatymus"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Numatytieji"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Ekrano suderinamumas"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Leidimai"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Talpykla"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Išvalyti talpyklą"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Talpykla"</string>
    <string name="controls_label" msgid="7611113077086853799">"Valdikliai"</string>
    <string name="force_stop" msgid="7435006169872876756">"Sustabdyti"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Iš viso"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Programa"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"USB atminties programa"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Duomenys"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"USB atminties duomenys"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"SD kortelė"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Pašalinti"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Pašalinti visiems naudotojams"</string>
    <string name="install_text" msgid="884360662922471113">"Įdiegti"</string>
    <string name="disable_text" msgid="6544054052049395202">"Neleisti"</string>
    <string name="enable_text" msgid="9217362512327828987">"Įgalinti"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Išvalyti duomenis"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Pašalinti naujinius"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Pasirinkote pagal numatytuosius nustatymus paleisti šią programą atliekant tam tikrus veiksmus."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Pasirinkote leisti šiai programai kurti valdiklius ir pasiekti jų duomenis."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nenustatyti jokie numatytieji nustatymai."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Išvalyti numatytuosius nustatymus"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ši programa gali būti nepritaikyta jūsų ekranui. Čia galite valdyti jos pritaikymą pagal ekraną."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Paklausti, kai paleidžiama"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Keisti programos mastelį"</string>
    <string name="unknown" msgid="1592123443519355854">"Nežinomas"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Rūšiuoti pagal pavadinimą"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Rūšiuoti pagal dydį"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Rodyti vykdomas paslaugas"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Rodyti padėtus procesus"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Iš naujo nustat. nuostat."</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Iš naujo nust. nuostat.?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Bus iš naujo nustatytos visos toliau nurodytų objektų nuostatos:\n\n "<li>"Išjungtos programos"</li>\n" "<li>"Išjungtų programų pranešimai"</li>\n" "<li>"Numatytosios veiksmų programos"</li>\n" "<li>"Programų foninių duomenų apribojimai"</li>\n" "<li>"Visi leidimų apribojimai"</li>\n\n" Neprarasite jokių programų duomenų."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Iš naujo nustat. program."</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Valdyti vietą"</string>
    <string name="filter" msgid="2018011724373033887">"Filtruoti"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Pasirinkti filtro parinktis"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Visi"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Neleidžiama"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Atsisiųsta"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Vykdoma"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"USB atmintinė"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"SD kortelėje"</string>
    <string name="disabled" msgid="9206776641295849915">"Neleidžiama"</string>
    <string name="not_installed" msgid="1475144352069281880">"Neįdiegta"</string>
    <string name="no_applications" msgid="7336588977497084921">"Nėra programų"</string>
    <string name="internal_storage" msgid="1584700623164275282">"Vidinė atmint."</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"USB atmintinė"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"SD kort. atm."</string>
    <string name="recompute_size" msgid="7722567982831691718">"Iš naujo apskaičiuojamas dydis..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Ištrinti programos duomenis?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Visi šios programos duomenys bus visam laikui ištrinti. Tai taikoma visiems failams, nustatymams, paskyroms, duomenims ir kt."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"Gerai"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Atšaukti"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Programa nerasta įdiegtų programų sąraše."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Nepavyko išvalyti programos duomenų."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Pašalinti naujinius?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Visi šios „Android“ sistemos programos naujiniai bus pašalinti."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Išvalyti duomenis"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Nepavyko išvalyti programos duomenų."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Ši programa planšetiniame kompiuteryje gali pasiekti:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Ši programa telefone gali pasiekti:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Ši programa gali pasiekti nurodytus elementus planšetiniame kompiuteryje. Siekiant padidinti našumą ir sumažinti atminties naudojimą, kai kurie iš šių leidimų pasiekiami „<xliff:g id="BASE_APP_NAME">%1$s</xliff:g>“, nes ji veikia ta pačia eiga kaip „<xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>“:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Ši programa gali pasiekti nurodytus elementus telefone. Siekiant padidinti našumą ir sumažinti atminties naudojimą, kai kurie iš šių leidimų pasiekiami „<xliff:g id="BASE_APP_NAME">%1$s</xliff:g>“, nes ji veikia ta pačia eiga kaip „<xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>“:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> ir <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> ir <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Naudodami šią programą galite būti apmokestinti:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Siųsti brangesnį SMS"</string>
    <string name="computing_size" msgid="1599186977475211186">"Apskaičiuojama..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Nepavyko apskaičiuoti paketo dydžio."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Neturite įdiegtų trečiosios šalies programų."</string>
    <string name="version_text" msgid="9189073826278676425">"<xliff:g id="VERSION_NUM">%1$s</xliff:g> versija"</string>
    <string name="move_app" msgid="5042838441401731346">"Perkelti"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Perkelti į planšetinį kompiuterį"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Perkelti į telefoną"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Perkelti į USB atmintinę"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Perkelti į SD kortelę"</string>
    <string name="moving" msgid="6431016143218876491">"Perkėlimas"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nėra pakankamai vietos atmintinėje."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Programos nėra."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Programa apsaugota nuo kopijavimo."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Diegimo vieta netinkama."</string>
    <string name="system_package" msgid="6222593098063037137">"Sistemos naujinių negalima įdiegti išorinėje medijoje."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Priverstinai sustabdyti?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Jei priverstinai sustabdysite programą, ji gali neveikti tinkamai."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Nepavyko perkelti programos. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Pageidaujama diegimo vieta"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Pakeisti pageidaujamą naujų programų diegimo vietą"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Neleisti integruotos programos?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Jei neleisite integruotos programos, kitos programos gali neveikti tinkamai."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Ištrinti duomenis ir neleisti programos?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Jei neleisite integruotos programos, kitos programos gali veikti netinkamai. Be to, duomenys bus ištrinti."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Išjungti pranešimus?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Jei išjungsite šios programos pranešimus, galite praleisti svarbius įspėjimus ir naujinius."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Programos operacijos"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Vykdoma"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Niekada nenaudota)"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Atmintinės naudojimas"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Žiūrėti programų naudojamą atmintinę"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Vykdomos paslaugos"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Žiūrėti ir valdyti dabar vykdomas paslaugas"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Paleidžiama iš naujo"</string>
    <string name="cached" msgid="1059590879740175019">"Padėtas fono procesas"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Niekas nevykdoma."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Paleista programos."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> laisva"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"Panaudota <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Naudotojas: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Pašalintas naudotojas"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesas ir <xliff:g id="NUMSERVICES">%2$d</xliff:g> paslauga"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesas ir <xliff:g id="NUMSERVICES">%2$d</xliff:g> paslaugos (-ų)"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesai (-ų) ir <xliff:g id="NUMSERVICES">%2$d</xliff:g> paslauga"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesai (-ų) ir <xliff:g id="NUMSERVICES">%2$d</xliff:g> paslaugos (-ų)"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Vykdoma programa"</string>
    <string name="no_services" msgid="7133900764462288263">"Neaktyvu"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Paslaugos"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesai"</string>
    <string name="service_stop" msgid="6369807553277527248">"Sustabdyti"</string>
    <string name="service_manage" msgid="1876642087421959194">"Nustatymai"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ši paslauga buvo pradėta jos programos. Ją sustabdžius gali atsirasti programos trikčių."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Šios programos negalima saugiai sustabdyti. Jei ją sustabdysite, galite prarasti dalį esamo darbo."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"Tai senas programos procesas, kuris vis dar vykdomas, jei jo vėl prireiktų. Įprastai nėra priežasčių jį sustabdyti."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"„<xliff:g id="CLIENT_NAME">%1$s</xliff:g>“: šiuo metu naudojama. Jei norite valdyti, palieskite „Nustatymai“."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Pagrindinis naudojamas procesas."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"„<xliff:g id="COMP_NAME">%1$s</xliff:g>“ paslauga naudojama."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"„<xliff:g id="COMP_NAME">%1$s</xliff:g>“ teikėjas naudojamas."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Sustabdyti sistemos aptarnavimą?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Jei sustabdysite šią paslaugą, kai kurios planšetinio kompiuterio funkcijos gali tinkamai nebeveikti, kol jį išjungsite ir vėl įjungsite."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Jei sustabdysite šią paslaugą, kai kurios telefono funkcijos gali tinkamai nebeveikti, kol jį išjungsite ir vėl įjungsite."</string>
    <string name="language_settings" msgid="5292716747264442359">"Kalba ir įvestis"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Kalba ir įvestis"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Kalbos nustatymai"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klaviatūra ir įvesties metodai"</string>
    <string name="phone_language" msgid="8870144109924299673">"Kalba"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automatiškai pakeisti"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Taisyti blogai įvestus žodžius"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Automatinis didžiųjų raidžių rašymas"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Pirmą sakinių raidę rašyti iš didžiosios"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatiškai dėti skyrybos ženklus"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Fiziniai klaviatūros nustatymai"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Du kartus paspauskite tarpo klavišą, kad įterptumėte „.“"</string>
    <string name="show_password" msgid="3001113966880559611">"Padaryti slaptažodžius matomus"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Naudojant šį įvesties metodą galima rinkti visą įvedamą tekstą, įskaitant asmeninius duomenis, pvz., slaptažodžius ir kredito kortelių numerius. Jis pateikiamas naudojant programą „<xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>“. Naudoti šį įvesties metodą?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Naudojant šią rašybos tikrinimo programą galima rinkti visą įvedamą tekstą, įskaitant asmeninius duomenis, pvz., slaptažodžius ir kredito kortelių numerius. Ji pateikiama naudojant programą „<xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>“. Naudoti šią rašybos tikrinimo programą?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Nustatymai"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Kalba"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Nepavyko atidaryti „<xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g>“ nustatymų"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Pelė / jutiklinis kilimėlis"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Žymiklio greitis"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Žaidimų valdiklis"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Naudoti vibravimą"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Nukreipkite vibravimą į žaidimų valdiklį, kai jis prijungtas."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Pasirinkite klaviatūros išdėstymą"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Nustatyti klaviatūros išdėstymus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Kad perj., pasp. vald. ir tarpo kl."</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Numatytasis"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Klaviatūros išdėstymai"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Asmeninis žodynas"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Pridėti"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Pridėti prie žodyno"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Frazė"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Daugiau parink."</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Mažiau parink."</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"Gerai"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Žodis:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Spartusis klavišas:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Kalba:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Įveskite žodį"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Pasirenkamas spartusis klavišas"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Redaguoti žodį"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Redaguoti"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Ištrinti"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"Neturite jokių žodžių naudotojo žodyne. Žodį galite pridėti paliesdami mygtuką „Pridėti“ (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Visos kalbos"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Daugiau kalbų..."</string>
    <string name="testing" msgid="6584352735303604146">"Bandymas"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Planšetinio kompiuterio informacija"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Telefono informacija"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Akumuliatoriaus informacija"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Greitasis paleidimas"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Nustatyti sparčiuosius klavišus, skirtus programoms paleisti"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Priskirti programą"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Nėra sparčiojo klavišo"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Ieškoti + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Išvalyti"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Bus išvalytas spartusis <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) klavišas."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"Gerai"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Atšaukti"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Programos"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Spartieji klavišai"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Teksto įvestis"</string>
    <string name="input_method" msgid="5434026103176856164">"Įvesties metodas"</string>
    <string name="current_input_method" msgid="234072873286056438">"Numatytasis"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Įvesties metodo pasirink. priemonė"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatinis"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Visada rodyti"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Visada slėpti"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Nustatykite įvesties metodus"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Nustatymai"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Nustatymai"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktyvūs įvesties metodai"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Naudoti sistemos kalbą"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"<xliff:g id="IME_NAME">%1$s</xliff:g> nustatymai"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Pasirink. aktyvius įvesties metodus"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Ekraninės klaviatūros nustatymai"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fizinė klaviatūra"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Fizinės klaviatūros nustatymai"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Kūrėjo parinktis"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Nustatyti programos kūrimo parinktis"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Kūrėjo parinktys negalimos šiam naudotojui"</string>
    <string name="enable_adb" msgid="7982306934419797485">"USB perkrova"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Derinimo režimas, kai prijungtas USB"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Panaikinti USB derinimo prieigos teises"</string>
    <string name="bugreport_in_power" msgid="4548816486587403971">"Įjungimo meniu pranešimai apie triktis"</string>
    <string name="bugreport_in_power_summary" msgid="5764234382355067053">"Įtraukti parinktį į įjungimo meniu, kad būtų galima pranešti apie triktį"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Veikti"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Kraunant ekranas niekada neveiks miego režimu"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Įgalinti „Bluetooth“ HCI šnipinėjimo žurnalą"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Užfiksuoti visus faile esančius „Bluetooth“ HCI paketus"</string>
    <string name="select_runtime_title" msgid="649783802363155346">"Pasirinkti vykdymo laiką"</string>
    <string name="select_runtime_dialog_title" msgid="5314872813037493958">"Pasirinkti vykdymo laiką"</string>
    <string name="select_runtime_warning_message" msgid="1937574953265648165">"Įkelti iš naujo, kad vykdymo laikas būtų pakeistas iš <xliff:g id="OLD">%1$s</xliff:g> į <xliff:g id="NEW">%2$s</xliff:g>?"</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Belaidžio rodymo sertifikavimas"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Rodyti belaidžio rodymo sertifikavimo parinktis"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Leisti imituoti vietas"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Leisti imituoti vietas"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Leisti USB perkrovimą?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"USB derinimas skirtas naudoti tik kūrimo tikslais. Jis gali būti naudojamas norint kopijuoti duomenis iš kompiuterio į įrenginį ir atvirkščiai, įdiegti programas įrenginyje be pranešimo ir skaityti žurnalo duomenis."</string>
    <string name="adb_keys_warning_message" msgid="6932230298032192937">"Panaikinti visų kompiuterių, kuriems anksčiau suteikėte prieigos teisę, prieigą prie USB derinimo?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Leisti kūrėjų nustatymus?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Šie nustatymai skirti tik kūrėjams. Nustačius juos įrenginys ir jame naudojamos programos gali nustoti veikti arba veikti netinkamai."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Patvirtinti progr. naudojant USB"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Patikrinkite, ar programų, įdiegtų naudojant ADB / ADT, veikimas nėra žalingas."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Apsaugoti USB atmintį"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Programos turi prašyti leidimo skaityti USB atmintį"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Apsaugoti USB atmintį?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Jei USB atmintis yra apsaugota, programos turi prašyti leidimo skaityti išorinėje atmintinėje esančius duomenis.\n\nKai kurios programos gali neveikti, kol jų neatnaujins kūrėjai."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Apsaugoti SD kortelę"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Programos turi prašyti leidimo skaityti SD kortelę"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Apsaugoti SD kortelę?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Jei SD kortelė yra apsaugota, programos turi prašyti leidimo skaityti išorinėje atmintinėje esančius duomenis.\n\nKai kurios programos gali neveikti, kol jų neatnaujins kūrėjai."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Vietinis terminalas"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Įgal. terminalo progr., siūlančią prieigą prie viet. apvalkalo"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Pasirinkti programėlę"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Pasirinkti valdiklį"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Sukurti valdiklį ir leisti prieigą?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Sukūrus valdiklį, „<xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>“ gali pasiekti visus jame pateikiamus duomenis."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Visada leisti „<xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>“ kurti valdiklius ir pasiekti jų duomenis"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> d. <xliff:g id="HOURS">%2$d</xliff:g> val. <xliff:g id="MINUTES">%3$d</xliff:g> min. <xliff:g id="SECONDS">%4$d</xliff:g> sek."</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> val. <xliff:g id="MINUTES">%2$d</xliff:g> min. <xliff:g id="SECONDS">%3$d</xliff:g> sek."</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> min. <xliff:g id="SECONDS">%2$d</xliff:g> sek."</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> sek."</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> d. <xliff:g id="HOURS">%2$d</xliff:g> val. <xliff:g id="MINUTES">%3$d</xliff:g> min."</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> val. <xliff:g id="MINUTES">%2$d</xliff:g> min."</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min."</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Naudojimo statistika"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Naudojimo statistika"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Rūšiuoti pagal:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Programa"</string>
    <string name="launch_count_label" msgid="4019444833263957024">"Suskaičiavimas"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Naudojimo laikas"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Pasiekiamumas"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Pasiekiamumo nustatymai"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Paslaugos"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Sistema"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Antraštės"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Didinimo gestai"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"Kai ši funkcija įjungta, galite artinti ir tolinti tris kartus palietę ekraną.\n\nKai priartinate, galite:\n"<ul><li>"Iš lėto apžvelgti: mažiausiai dviem pirštais vilkite ekranu."</li>\n<li>"Koreguoti priartinimo lygį: suimkite mažiausiai dviem pirštais arba išskėskite juos."</li></ul>\n\n"Be to, galite laikinai padidinti tai, kas po pirštu, tris kartus palietę ir laikydami. Esant šiai padidinto vaizdo būsenai galite vilkti pirštu, jei norite naršyti skirtingas ekrano dalis. Pakelkite pirštą, kad grįžtumėte į ankstesnę būseną.\n\nPastaba: palietimo tris kartus, kad būtų padidinta, funkcija veikia visur, išskyrus klaviatūrą ir naršymo juostą."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Spart. pritaikymo neįgal. įjungimas"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Įjungta"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Išjungta"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Kai ši funkcija įjungta, galite greitai įgalinti pritaikymo neįgaliesiems funkcijas šiais dviem veiksmais:\n\n1 veiksmas: paspauskite ir laikykite paspaudę maitinimo mygtuką, kol išgirsite garsą ar pajusite vibraciją.\n\n2 veiksmas: palieskite ir laikykite palietę dviem pirštais, kol išgirsite patvirtinamąjį garso pranešimą\n\nJei įrenginį naudoja keli naudotojai, užrakinimo ekrane įjungus šią funkciją laikinai bus įgalintas pritaikymas neįgaliesiems, kol įrenginys bus atrakintas."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Didelis tekstas"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Ekrano didinimas"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Automat. atnaujinti ekrano didinimą"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Atnaujinti ekrano didinimą perkeliant programas"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Maitinimo mygt. baig. skamb."</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Sakyti slaptažodžius"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"„Paliesti ir laikyti“ delsa"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nustatymai"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Įjungta"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Išjungta"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Peržiūra"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standartinės parinktys"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Kalba"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Teksto dydis"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Antraštės stilius"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Tinkintos parinktys"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Fono spalva"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Fono nepermatomumas"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Teksto spalva"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Krašto spalva"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Krašto tipas"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Šriftų grupė"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Antraštės atrodys taip"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Numatytoji"</string>
    <string name="color_none" msgid="3475640044925814795">"Nėra"</string>
    <string name="color_white" msgid="8045195170201590239">"Balta"</string>
    <string name="color_gray" msgid="9192312087142726313">"Pilka"</string>
    <string name="color_black" msgid="7517353520909872561">"Juoda"</string>
    <string name="color_red" msgid="4949354900304125428">"Raudona"</string>
    <string name="color_green" msgid="5537717328428845841">"Žalia"</string>
    <string name="color_blue" msgid="7731984529016953223">"Mėlyna"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Žalsvai mėlyna"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Geltona"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Purpurinė"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Naudoti „<xliff:g id="SERVICE">%1$s</xliff:g>“?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"„<xliff:g id="SERVICE">%1$s</xliff:g>“ reikia:"</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Stebėti jūsų veiksmus"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="2095111008854376237">"Gauti pranešimus, kai sąveikaujate su programa."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Sustabdyti „<xliff:g id="SERVICE">%1$s</xliff:g>“?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Palietus „Gerai“ bus sustabdyta „<xliff:g id="SERVICE">%1$s</xliff:g>“."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nėra įdiegta jokių paslaugų"</string>
    <string name="accessibility_service_no_apps_title" msgid="5124097563864109821">"Reikia ekrano skaitytuvo?"</string>
    <string name="accessibility_service_no_apps_message" msgid="7751662416377046539">"„TalkBack“ teikia atsiliepimus žodžiu, kad padėtų akliems ir sutrikusio regėjimo naudotojams. Ar norite nemokamai įdiegti šią funkciją iš „Android“ prekyvietės?"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nepateikta jokių aprašų."</string>
    <string name="settings_button" msgid="3006713718908152930">"Nustatymai"</string>
    <string name="print_settings" msgid="4742428530112487843">"Spausdinimas"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Spausdinimo paslaugos"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Naudoti „<xliff:g id="SERVICE">%1$s</xliff:g>“?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Siunčiant į spausdintuvą dokumentas gali būti perduodamas per kelis serverius."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nėra įdiegta jokių paslaugų"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nerasta jokių spausdintuvų"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Nustatymai"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Pridėti spausdintuvų"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Įjungta"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Išjungta"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Pridėti paslaugą"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Pridėti spausdintuvą"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Paieška"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Ieškoma spausdintuvų"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Paslauga neleidžiama"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Spausdinimo užduotys"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Spausdinimo užduotis"</string>
    <string name="print_restart" msgid="8373999687329384202">"Paleisti iš naujo"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Atšaukti"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Spausdinama: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Atšaukiama: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Spausdintuvo klaida: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Spausdintuvas užblokavo <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Paieškos laukelis rodomas"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Paieškos laukelis paslėptas"</string>
  <plurals name="print_search_result_count_utterance">
    <item quantity="one" msgid="1322401991353603285">"Rasta spausdintuvų: <xliff:g id="COUNT">%1$s</xliff:g>"</item>
    <item quantity="other" msgid="460211409510874128">"Rasta spausdintuvų: <xliff:g id="COUNT">%1$s</xliff:g>"</item>
  </plurals>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Baterija"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Kas naudojo akumuliatorių"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Akum. naudoj. duom. nepasiek."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Akumuliatoriaus naudojimas po to, kai buvo ištrauktas iš lizdo"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Akumuliatoriaus naudojimas po nustatymo iš naujo"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> akumuliatoriaus"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> po to, kai buvo ištrauktas iš lizdo"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Kraunama"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Ekranas įjungtas"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GSP įjungta"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Pažadinti"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Mob. ryšio tinklo signal."</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Įrenginio veikimo laikas"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"„Wi-Fi“ laiku"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"„Wi-Fi“ laiku"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> – <xliff:g id="NUMBER">%2$s</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Istorijos informacija"</string>
    <string name="details_title" msgid="3792801565213935385">"Išsami naudojimo informacija"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Išsami naudojimo informacija"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Reguliuoti maitinimo naudojimą"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Įtraukti paketai"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekranas"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Mobilusis telefonas veikia laukimo režimu"</string>
    <string name="power_phone" msgid="5392641106474567277">"Balso skambučiai"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Planšetinis kompiuteris neveikos būsenos"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefonas veikia laukimo režime"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Visas CPU laikas"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU aktyvusis langas"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Neužmigdyti"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"„Wi-Fi“ vykdoma"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Planšetinis kompiuteris"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefonas"</string>
    <string name="usage_type_data_send" msgid="3875198715268918671">"Mob. tinklo duomenys išsiųsti"</string>
    <string name="usage_type_data_recv" msgid="6694951443404021754">"Mobiliojo tinklo duomenys gauti"</string>
    <string name="usage_type_data_wifi_send" msgid="7178327382353096029">"„Wi‑Fi“ tinklo duomenys išsiųsti"</string>
    <string name="usage_type_data_wifi_recv" msgid="7822328607564241372">"„Wi‑Fi“ tinklo duomenys gauti"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Garso įrašas"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Vaizdo įrašas"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Laikas, kai buvo įjungta"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Laikas be signalo"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Sustabdyti"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Programos informacija"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Programos nustatymai"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Ekrano nustatymai"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"„Wi-Fi“ nustatymai"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"„Bluetooth“ nustatymai"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Balso skambučių akumuliatoriaus naudojimas"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Akumuliatorius naudojamas, kai planšetinis kompiuteris yra neveikos būsenos"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Sunaudota akumuliatoriaus, kai telefonas yra laukimo būsenoje"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Mobilaus radijo naudojamas akumuliatorius"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Pereiti prie lėktuvo režimo, norint taupyti energiją srityse, kuriose nėra"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Akumuliatorių naudoja pateiktis ir foninis apšvietimas"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Sumažinti ekrano šviesumą ir (arba) ekrano skirtąjį laiką"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"„Wi-Fi“ naudojamas akumuliatorius"</string>
    <string name="battery_sugg_wifi" msgid="3355461362094706957">"Išjungti „Wi-Fi“, kai nenaudojama arba nepasiekiama"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"„Bluetooth“ naudojamas akumuliatorius"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Išjungti „Bluetooth“, kai nenaudojate"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Bandyti prisijungti prie kito „Bluetooth“ įrenginio"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Programos naudojamas akumuliatorius"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Stabdyti ar pašalinti programą"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Pasirinkite akumuliatoriaus tausojimo režimą"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Programa gali pasiūlyti nustatymus, kad būtų išeikvojama mažiau akumuliatoriaus energijos"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Naudotojo sunaudota akumuliatoriaus energija"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> po to, kai buvo ištrauktas iš lizdo"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Kai paskutinį kartą buvo ištrauktas iš lizdo <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Visas naudojimas"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Atnaujinti"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"„Android“ OS"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Medijos serveris"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Procesų statistika"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Entuziastų pateikta statistika apie vykstančius procesus"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Naudojama atmintis"</string>
    <string name="process_stats_total_duration" msgid="1869761515101180444">"Tipo <xliff:g id="TYPE">%1$s</xliff:g> programos per <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Fonas"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Priekinis planas"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Išsaugota talpykloje"</string>
    <string name="process_stats_memory_status" msgid="4251599550196193093">"Įrenginio atmintis šiuo metu yra <xliff:g id="MEMSTATE">%1$s</xliff:g>"</string>
    <string name="process_stats_avg_ram_use" msgid="6972943528929394396">"Vidutinis laisvosios prieigos atminties naudojimas"</string>
    <string name="process_stats_max_ram_use" msgid="3273876448926689261">"Maksimalus laisvosios prieigos atminties naudojimas"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Rodymo laikas"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Paslaugos"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Trukmė"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 val."</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 val."</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 val."</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 d."</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Rodyti sistemos procesus"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Naudoti USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Statistikos tipas"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Fonas"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Priekinis planas"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Išsaugota talpykloje"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Balso įvestis ir išvestis"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Balso įvesties ir išvesties nustatymai"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Balso paieška"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"„Android“ klaviatūra"</string>
    <string name="voice_category" msgid="1430370497125803904">"Kalba"</string>
    <string name="recognizer_title" msgid="3231385184559054457">"Balso atpažinimo priemonė"</string>
    <string name="recognizer_settings_title" msgid="432493301215113154">"Paieška balsu"</string>
    <string name="recognizer_settings_summary" msgid="4472287934134546902">"„<xliff:g id="RECOGNIZER_NAME">%s</xliff:g>“ nustatymai"</string>
    <string name="tts_settings" msgid="8186971894801348327">"„Teksto į kalbą“ nustatymai"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"„Teksto į kalbą“ išvestis"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Visada naudoti mano nustatymus"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Toliau pateikti numatytieji nustatymai atšaukia programos nustatymus"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Numatytieji nustatymai"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Numatytasis variklis"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Nustato kalbos sintezės variklį, kuris bus naudojamas sakomam tekstui"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Kalbėjimo greitis"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Greitis, kuriuo sakomas tekstas"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Garso aukštis"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Daro poveikį sakomo teksto tonui"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Kalba"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Kalba nepasirinkta"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Nustato konkrečiai kalbai būdingą sakomo teksto balsą"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Klausytis pavyzdžio"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Paleisti trumpą kalbos sintezės demonstraciją"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Įdiegti balso duomenis"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Įdiegti balso duomenis, reikalingus kalbos sintezei"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Balsai, reikalingi kalbos sintezei, jau tinkamai įdiegti"</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Jūsų nustatymai pasikeitė. Tai pavyzdys, kaip jie turėtų skambėti."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Nepavyksta paleisti pasirinkto variklio."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Konfigūruoti"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Pasirinkite kitą variklį"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Šis kalbos sintezės variklis gali rinkti visą įvedamą tekstą, įskaitant asmeninius duomenis, pvz., kredito kortelės numerius, išskyrus slaptažodžius. Tai vyksta dėl variklio <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Įgalinti šio kalbos sintezės variklio naudojimą?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Pasirinkus šią kalbą, teksto vertimo kalba išvesčiai būtinas veikiantis tinklo ryšys."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Tai yra kalbos sintezės pavyzdys"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Numatytoji kalbos būsena"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"<xliff:g id="LOCALE">%1$s</xliff:g> visiškai palaikoma"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"<xliff:g id="LOCALE">%1$s</xliff:g> būtinas tinklo ryšys"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"<xliff:g id="LOCALE">%1$s</xliff:g> nepalaikoma"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Tikrinama..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Varikliai"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> nustatymai"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> įgalinta"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> išjungta"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Variklio nustatymai"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"„<xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>“ nustatymai"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Kalbos ir balsai"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Įdiegta"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Neįdiegta"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Moteris"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Vyras"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Kalbos sintezės variklis įdiegtas"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Prieš naud. įgal. nauj. varik."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Paleisti variklio nustatymus"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Pageidaujamas variklis"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Bendra"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Maitinimo valdymas"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Atnaujinamas „Wi-Fi“ nustatymas"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Atnaujinamas „Bluetooth“ nustatymas"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"įjungta"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"išjungta"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"įjungiama"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"išjungiama"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Vietovė"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sinchronizavimas"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Skaistis <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automatinis"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"visiškas"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"pusinis"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"išjungta"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Įgaliojimų atmintinė"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Įdiegti iš atmintinės"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Įdiegti iš SD kortelės"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Įdiegti sertifikatus iš atmintinės"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Įdiegti sertifikatus iš SD kortelės"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Valyti įgaliojimus"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Pašalinti visus sertifikatus"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Patikimi įgaliojimai"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Rodyti patikimus CA sertifikatus"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Atmintinės tipas"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Atsarginė kopija saugoma įrenginio vidinėje atmintyje"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Saugoma tik programinėje įrangoje"</string>
    <string name="credentials_install_gesture_prompt" msgid="2207390278112395082">"Nubrėžti atrakinimo piešinį"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Kad patvirtintumėte kredencialų diegimą, turite nubrėžti atrakinimo piešinį."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Įveskite kredencialų atmintinės slaptažodį."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Dabartinis slaptažodis:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Pašalinti visą turinį?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Slaptažodį turi sudaryti mažiausiai 8 simboliai."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Neteisingas slaptažodis."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Neteisingas slaptažodis. Dar galite bandyti vieną kartą, paskui įgaliojimų atmintinė bus ištrinta."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Neteisingas slaptažodis. Dar galite bandyti <xliff:g id="NUMBER">%1$d</xliff:g> k., paskui įgaliojimų atmintinė bus ištrinta."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Įgaliojimų atmintinė ištrinta."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Nepavyko ištr. kreden. atmint."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Įgaliojimų saugykla įgalinta."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Jei norite naudoti kredencialų atmintinę, pirmiausia turite nustatyti ekrano užrakto PIN kodą arba slaptažodį."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Pagalbos tonas"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Nustatyti elgesį, kai skambinama pagalbos numeriu"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Kurti atsarginę kopiją ir nustatyti iš naujo"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Kurti atsarginę kopiją ir nustatyti iš naujo"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Kurti atsarginę kopiją ir atkurti"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Asmeniniai duomenys"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Kurti atsarginę duomenų kopiją"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"„Google“ serveriuose kurti atsargines programos duomenų, „Wi-Fi“ slaptažodžių ir kitų nustatymų kopijas"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Atsarg. kopijos paskyra"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Šiuo metu jokioje paskyroje nesaugomi atsarginės kopijos duomenys"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatinis atkūrimas"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Iš naujo įdiegdami programą atkurkite nustatymus ir duomenis, kurių atsarginės kopijos buvo sukurtos"</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Viet. atsrg. kop. slapt."</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Šiuo metu visos vietinės atsarginės kopijos neapsaugotos"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Jei norite pakeisti ar pašalinti visų vietinių atsarginių kopijų slaptažodį, palieskite"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Nustatytas naujas atsarginis slaptažodis"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Naujas slaptažodis ir patvirtinimas neatitinka"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Nustatant atsarginį slaptažodį įvyko klaida"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Nebekurti atsarginių „Wi-Fi“ slaptažodžių, žymių, kitų nustatymų ir programų duomenų kopijų ir ištrinti visas „Google“ serveriuose esančias kopijas?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Įrenginio administravimo nustatymai"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Įrenginio administratorius"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Išaktyvinti"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Įrenginio administratoriai"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Nėra galimų įrenginio administratorių"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Suaktyvinti įrenginio administratorių?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Aktyvinti"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Įrenginio administratorius"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Suaktyvinus šį administratorių „<xliff:g id="APP_NAME">%1$s</xliff:g>“ programai bus leidžiama atlikti nurodytas operacijas:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Administratorius aktyvus ir leidžia programai „<xliff:g id="APP_NAME">%1$s</xliff:g>“ atlikti šias operacijas:"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Be pavadinimo"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Bendras"</string>
    <string name="sound_category_notification_title" msgid="3502115998790286943">"Įspėjimai"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Skambinimo tonas ir vibracija"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sistema"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"„Wi-Fi“ sąranka"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Prisijungti prie „Wi-Fi“ tinklo „<xliff:g id="NETWORK_NAME">%s</xliff:g>“"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Prisijungiama prie „Wi-Fi“ tinklo „<xliff:g id="NETWORK_NAME">%s</xliff:g>“…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Prisijungta prie „Wi-Fi“ tinklo „<xliff:g id="NETWORK_NAME">%s</xliff:g>“"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Pridėti tinklą"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Neprijungta"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Pridėti tinklą"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Atnaujinti sąrašą"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Praleisti"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Kitas"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Atgal"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Išsami tinklo inf."</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Prijungti"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Pamiršti"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Išsaugoti"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Atšaukti"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Nuskaitomi tinklai…"</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Palieskite tinklą, kad prie jo prisijungtumėte"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Prisijungti prie esamo tinklo"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Prisijungti prie neapsaugoto tinklo"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Įvesti tinklo konfigūraciją"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Prisijungti prie tinklo"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Prisijungiama…"</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Atlikite kitą veiksmą"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"EAP nepalaikoma."</string>
    <string name="wifi_setup_eap_not_supported" msgid="1955087534276570962">"Negalite konfigūruoti EAP „Wi-Fi“ ryšio, kai vykdoma sąranka. Po sąrankos tai galėsite padaryti skiltyje „Nustatymai“ &gt; „Belaidis ryšys ir tinklai“."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Prisijungimas gali užtrukti kelias minutes…"</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Palieskite "<b>"Kitas"</b>", kad tęstumėte sąranką.\n\nPalieskite "<b>"Atgal"</b>", kad prisijungtumėte prie kito „Wi-Fi“ tinklo."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinchronizavimas įgalintas"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sinchronizavimas neleidžiamas"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Sinchronizavimo klaida."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Įvyko sinchronizavimo klaida"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinchronizavimas aktyvus"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinchronizavimas"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Šiuo metu iškilo sinchronizavimo problemų. Greitai jis vėl vyks."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Pridėti paskyrą"</string>
    <string name="background_data" msgid="5779592891375473817">"Foniniai duomenys"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Programos gali bet kada sinchron., siųsti ir gauti duomenis"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Neleisti fon. duom.?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Neleidžiant foninių duomenų pailgėja akumuliatoriaus naudojimo trukmė ir sumažėja duomenų naudojimas. Kai kurios programos vis tiek gali naudoti foninių duomenų ryšį."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Autom. sinchron. programos duomenis"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinchroniz. įjungtas"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinchron. IŠJUNGTAS"</string>
    <string name="sync_error" msgid="5060969083117872149">"Sinchronizav. klaida"</string>
    <string name="last_synced" msgid="4242919465367022234">"Pastarąjį kartą sinchronizuota <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sinchronizuojama dabar…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Atsarginės kopijos kūrimo nustatymai"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Kurti atsarginę nustatymų kopiją"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinchronizuoti dabar"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Atšaukti sinchronizavimą"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Palieskite, kad būtų dabar sinchronizuojama<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendorius"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontaktai"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Sveiki! Tai – „Google“ sinchronizavimas!"</font>" \nTai yra „Google“ požiūris į duomenų sinchronizavimą, kad būtų galima pasiekti kontaktus, susitikimus ir dar daugiau, nesvarbu, kur būtumėte."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Programos sinchronizavimo nustatymai"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Duomenys ir sinchronizavimas"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Keisti slaptažodį"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Paskyros nustatymai"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Pašalinti paskyrą"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Pridėti paskyrą"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Užbaigti"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Pašalinti paskyrą?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Pašalinus šią paskyrą iš planšetinio kompiuterio bus ištrinti visi pranešimai, kontaktai ir kiti duomenys!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Pašalinus šią paskyrą iš telefono bus ištrinti visi jos pranešimai, kontaktai ir kiti duomenys!"</string>
    <string name="remove_account_failed" product="tablet" msgid="3086620478225952725">"Ši paskyra reikalinga kelioms programoms. Ją galite pašalinti tik iš naujo nustatę numatytuosius gamyklinius planšetinio kompiuterio nustatymus (taip bus ištrinti visi asmeniniai duomenys) skiltyje „Nustatymai“ &gt; „Kurti atsarginę kopiją ir nustatyti iš naujo“."</string>
    <string name="remove_account_failed" product="default" msgid="6217238709175617517">"Ši paskyra reikalinga kelioms programoms. Ją galite pašalinti tik iš naujo nustatę numatytuosius gamyklinius telefono nustatymus (taip bus ištrinti visi asmeniniai duomenys) skiltyje „Nustatymai“ &gt; „Kurti atsarginę kopiją ir nustatyti iš naujo“."</string>
    <string name="provider_label" msgid="7724593781904508866">"Paspauskite „Prenumeratos“"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Negalima sinchronizuoti rankiniu būdu"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Šiuo metu šio elemento sinchronizavimas neleidžiamas. Jei norite pakeisti šį nustatymą, laikinai įjunkite foninius duomenis ir automatinį sinchronizavimą."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"4G MAC adresas"</string>
    <string name="enter_password" msgid="4131758584074246224">"Kad iššifruotumėte atmintinę, įveskite slaptažodį"</string>
    <string name="try_again" msgid="4272075051293936921">"Bandykite dar kartą."</string>
    <string name="delete" msgid="4219243412325163003">"Ištrinti"</string>
    <string name="misc_files" msgid="6720680815969643497">"Įvairūs failai"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"pasirinkti (-a) <xliff:g id="NUMBER">%1$d</xliff:g> iš <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> iš <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Pasirinkti viską"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"HDCP tikrinimas"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Nust. HDCP tikrin. elgs."</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Derinimas"</string>
    <string name="debug_app" msgid="8349591734751384446">"Pasirinkite derinimo programą"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Nenustatyta jokia derinimo programa"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Derinimo programa: „<xliff:g id="APP_NAME">%1$s</xliff:g>“"</string>
    <string name="select_application" msgid="5156029161289091703">"Pasirinkti programą"</string>
    <string name="no_application" msgid="2813387563129153880">"Nieko"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Laukti derintuvės"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Derinta progr. laukia derint., kad galėtų tęsti."</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Įvestis"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Atvaizdavimas"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Aparatinės įrangos paspartintas pateikimas"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Stebėjimas"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Įgal. griežtas režimas"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Ekr. blyksės, kai pr. atl. ilgus proc. pgr. gijoje"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Žymiklio vieta"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Ekrano perdanga rodo dabartinius lietimo duomenis"</string>
    <string name="show_touches" msgid="1356420386500834339">"Rodyti palietimus"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Rodyti vaizdinius palietimų atsiliepimus"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Rodyti paviršiaus naujin."</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Naujinant mirginti visus langų paviršius"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Rodyt GPU rodinių naujin."</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"„Flash“ rodiniai languose atvaizduojant su GPU"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Rod. apar. įr. sl. nauj."</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Kai atsin. apar. įr. sl., rod. juos blyks. ž. sp."</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Derinti GPU perdangą"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Neleisti HW perdangų"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Komponuojant ekraną visada naudoti GPU"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Įgalinti „OpenGL“ pėdsak."</string>
    <string name="debug_layout" msgid="5981361776594526155">"Rodyti išdėstymo ribas"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Rodyti iškarpų ribas, kraštines ir t. t."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Išdėst. iš dešin. į kairę"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Nust. visų lokalių ekran. išdėst. iš deš. į kairę"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Rodyti centr. proc. naud."</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Ekrano perdanga rodo dabartinį centr. proc. naud."</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Priverst. GPU atvaizd."</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Priverstinai naudoti GPU atvaizduojant 2D formatą"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Priverst. vykdyti 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Įgalinti 4x MSAA „OpenGL ES 2.0“ programose"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Derinti ne stačiakampio klipo operacijas"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profiliuotas GPU atvaizd."</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Lango animacijos mast."</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Animuoto perėjimo mast."</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Animator. trukmės skalė"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Imituoti antrin. ekranus"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Programos"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Nesaugoti veiklos"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Sunaikinti visą veiklą, kai naud. iš jos išeina"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Fono procesų apribojimas"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Rodyti visus ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Fon. programose rodyti dialogo langą „Neatsako“"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Duomenų naudojimas"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Duomenų naudojimo ciklas"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Tarptinklinis duomenų ryšys"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Fono duomenų ribojimas"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Atskirti 4G naudojimą"</string>
    <string name="data_usage_menu_show_wifi" msgid="5056401102877964564">"Rodyti „Wi-Fi“ naudojimą"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Rodyti eterneto naudojimą"</string>
    <string name="data_usage_menu_metered" msgid="5056695223222541863">"Mob. vieš. inter. prieig. tšk."</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatinis duomenų sinchronizavimas"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Keisti ciklą…"</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Mėnesio diena, kai iš naujo nustatomas naudojimo ciklas:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Šiuo laikotarpiu jokios program. nenaudojo duom."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Priekinis planas"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Fonas"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"ribotas"</string>
    <string name="data_usage_disable_mobile" msgid="5211007048880167438">"Neleisti duomenų mobiliesiems?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Nustatyti mobiliųjų duomenų apribojimą"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Nustatyti 4G duomenų apribojimą"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Nustatyti 2G–3G duomenų apribojimą"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Nust. „Wi-Fi“ duom. aprib."</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Eternetas"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobilieji"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G–3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobilusis"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Nėra"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobilieji duomenys"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"2G–3G duomenys"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"4G duomenys"</string>
    <string name="data_usage_app_settings" msgid="8430240158135453271">"Žiūrėti programos nustatymus"</string>
    <string name="data_usage_app_restrict_background" msgid="9149728936265100841">"Fono duomenų ribojimas"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="518658001418490405">"Nel. fon. duom. mob. tinkl. Ne mob. tinkl. bus naud., jei pas."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Kad aprib. šios progr. fon. duom., pirm. nustat. mob. duom. apr."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Apriboti foninius duomenis?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Dėl šios funkcijos, kai pasiekiami tik mobilieji tinklai, gali neveikti programos, kurių veikimas priklauso nuo foninių duomenų.\n\nProgramos nustatymuose galite rasti tinkamesnių duomenų naudojimo valdiklių."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="7086969103661420799">"Apriboti foninius duomenis galima tik nustačius mobiliojo ryšio duomenų apribojimą."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Įjungti autom. sinchronizavimą?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="7312283529426636845">"Bet kokie paskyrų pakeitimai, kuriuos atliekate žiniatinklyje, bus automatiškai nukopijuoti į planšetinį kompiuterį.\n\nIš kai kurių paskyrų į žiniatinklį gali būti automatiškai kopijuojami visi planšetiniame kompiuteryje atlikti pakeitimai. Taip pat daroma ir „Google“ paskyroje.\n\nJei norite pasirinkti, kokią kiekvienos paskyros informaciją sinchronizuoti, eikite į „Nustatymai“ &gt; „Paskyros“."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="2374996799819303283">"Bet kokie paskyrų pakeitimai, kuriuos atliekate žiniatinklyje, bus automatiškai nukopijuoti į telefoną.\n\nIš kai kurių paskyrų į žiniatinklį gali būti automatiškai kopijuojami visi telefone atlikti pakeitimai. Taip pat daroma ir „Google“ paskyroje.\n\nJei norite pasirinkti, kokią kiekvienos paskyros informaciją sinchronizuoti, eikite į „Nustatymai“ &gt; „Paskyros“."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Išjungti autom. sinchronizavimą?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"Tai atlikus bus saikingai naudojami duomenys ir akumuliatoriaus energija, tačiau, jei norėsite surinkti naujausią informaciją, turėsite sinchronizuoti kiekvieną paskyrą rankiniu būdu. Be to, negausite pranešimų, kai atsiras naujinių."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Naudojimo ciklo nustatymo iš naujo data"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Kiekvieno mėnesio diena:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Nustatyti"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Nustatyti duomenų naudojimo įspėjimą"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Nustatyti duomenų naudojimo apribojimą"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Duomenų naudojimo ribojimas"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="3893348029612821262">"Mobiliųjų duomenų ryšys bus neleidžiamas, kai bus pasiektas nurodytas apribojimas.\n\nKadangi sunaudoti duomenys skaičiuojami planšetiniu kompiuteriu, o operatorius gali apskaičiuoti kitaip, apsvarstykite galimybę naudoti mažesnį apribojimą."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="7962145861903746827">"Mobiliųjų duomenų ryšys bus neleidžiamas, kai bus pasiektas nurodytas apribojimas.\n\nKadangi sunaudoti duomenys skaičiuojami telefonu, o operatorius gali apskaičiuoti kitaip, apsvarstykite galimybę naudoti mažesnį apribojimą."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Apriboti foninius duomenis?"</string>
    <string name="data_usage_restrict_background" msgid="8447934953579275363">"Jei apribosite mobiliojo ryšio fono duomenis, kai kurios programos ir paslaugos neveiks, nebent prisijungsite prie „Wi-Fi“ tinklo."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7132639594296036143">"Jei apribosite mobiliojo ryšio fono duomenis, kai kurios programos ir paslaugos neveiks, nebent prisijungsite prie „Wi-Fi“ tinklo.\n\nŠis nustatymas taikomas visiems šio planšetinio kompiuterio naudotojams."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="2642864376010074543">"Jei apribosite mobiliojo ryšio fono duomenis, kai kurios programos ir paslaugos neveiks, nebent prisijungsite prie „Wi-Fi“ tinklo.\n\nŠis nustatymas taikomas visiems šio telefono naudotojams."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"įspėjimas"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"apribojimas"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Pašalintos programos"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Pašalintos programos ir naudotojai"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"Gauta: <xliff:g id="RECEIVED">%1$s</xliff:g>, išsiųsta: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: sunaudota apie <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g>: planš. komp. apskaič., kad sunaud. <xliff:g id="TOTAL">%1$s</xliff:g>. Operat. duomenis gali apskaič. kitaip."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g>: telef. apskaič., kad sunaudota <xliff:g id="TOTAL">%1$s</xliff:g>. Oper. sunaud. duom. gali apskaič. kitaip."</string>
    <string name="data_usage_metered_title" msgid="6204750602856383278">"Mobil. vieš. inter. prieig. tšk."</string>
    <string name="data_usage_metered_body" msgid="4959032833706695848">"Pasirinkite „Wi-Fi“ tinklus, kurie yra mobiliojo ryšio viešosios interneto prieigos taškai. Programose galima apriboti šių tinklų naudojimą, kai jos veikia fone. Be to, programose gali būti įspėjama prieš naudojant šiuos tinklus dideliems kiekiams duomenų atsisiųsti."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobiliojo ryšio tinklai"</string>
    <string name="data_usage_metered_wifi" msgid="8540872226614404873">"„Wi-Fi“ tinklai"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="5502020778468643732">"Kad pasir. mob. ryšio vieš. intern. prieigos tašk., įj. „Wi-Fi“."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Skambutis pagalbos numeriu"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Grįžti prie skambučio"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Pavadinimas"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Tipas"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Serverio adresas"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"PPP šifruotė (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"L2TP paslaptis"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"„IPSec“ identifikatorius"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"„IPSec“ iš anksto bendrinamas raktas"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"„IPSec“ naudotojo sertifikatas"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"„IPSec“ CA sertifikatas"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"„IPSec“ serverio sertifikatas"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Rodyti išplėstines parinktis"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"DNS paieškos domenai"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"DNS serveriai (pvz., 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Persiuntimo maršrutai (pvz., 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Naudotojo vardas"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Slaptažodis"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Išsaugoti paskyros informaciją"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nenaudojama)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(nepatvirtinti serverio)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(gauta iš serverio)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Atšaukti"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Išsaugoti"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Prisijungti"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Redaguoti VPN profilį"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Prisijungti prie <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Pridėti VPN profilį"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Redaguoti profilį"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Ištrinti profilį"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Visada įjungtas VPN"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Pasirinkite VPN profilį, kad visada būtumėte prisijungę. Tinklo srautas bus leidžiamas, tik prisijungus prie šio VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Joks"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Norint, kad VPN būtų visada įjungtas, reikalingas serverio ir DNS IP adresas."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Šiuo metu nėra tinklo ryšio. Bandykite dar kartą vėliau."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Nėra sertifikato. Redaguokite profilį."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistema"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Naudotojas"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Neleisti"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Įgalinti"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Pašalinti"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Įgalinti sistemos CA sertifikatą?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Neleisti sistemos CA sertifikato?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Visam laikui pašalinti naudotojo CA sertifikatą?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Rašybos tikrinimas"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Čia įveskite visą dabartinį atsarginį slaptažodį"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Čia įveskite naują visų atsarginių kopijų slaptažodį"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Čia iš naujo įveskite visą atsarginį slaptažodį"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Nustatyti atsarginės kopijos slaptažodį"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Atšaukti"</string>
    <string name="percentage" msgid="5866131581207788624">"<xliff:g id="NUMBER">%d</xliff:g> %%"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Papildomi sistemos naujiniai"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Neleidžiama"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Negriežta"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Vykdoma"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Tinklas gali būti stebimas"</string>
    <string name="done_button" msgid="1991471253042622230">"Atlikta"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Tinklo stebėjimas"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"Šį įrenginį tvarko:\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nAdministratorius gali stebėti jūsų veiklą tinkle, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos, susisiekite su administratoriumi."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Trečioji šalis gali stebėti jūsų tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nVisa tai galima dėl įrenginyje įdiegtų patikimų prisijungimo duomenų."</string>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Tikrinti patikimus prisijungimo duomenis"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Naudotojai"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Naudotojai ir profiliai"</string>
    <string name="user_add_user_menu" msgid="3154537325132012954">"Pridėti naudotoją ar profilį"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Ribotas profilis"</string>
    <string name="user_need_lock_message" msgid="2596365678651842785">"Prieš kuriant apribotą profilį reikės nustatyti ekrano užraktą, kad apsaugotumėte programas ir asmeninius duomenis."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Nustatyti užraktą"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nenustatyta"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Nenustatytas – ribotas profilis"</string>
    <string name="user_owner" msgid="3879126011135546571">"Savininkas"</string>
    <string name="user_you" msgid="1639158809315025986">"Jūs (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Slapyvardis"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Pridėti"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Naudotojai turi savo programas ir turinį"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Galite apriboti prieigą prie paskyros programų ir turinio"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Naudotojas"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Ribotas profilis"</string>
    <string name="user_add_user_title" msgid="3961861593718285403">"Pridėti naują naudotoją"</string>
    <string name="user_add_user_message_long" msgid="3086244205384741788">"Galite bendrinti šį įrenginį su kitais žmonėmis sukurdami papildomų naudotojų. Kiekvienam naudotojui suteikiama atskira vieta, kurią jie gali tinkinti savo programomis, ekrano fonu ir pan. Be to, naudotojai gali koreguoti planšetinio kompiuterio nustatymus, pvz., „Wi-Fi“, kurie turi įtakos visiems.\n\nSukūrus naują naudotoją, tas asmuo turi įvykdyti sąrankos procesą.\n\nBet kuris naudotojas gali priimti atnaujintų programų leidimus visų kitų naudotojų vardu."</string>
    <string name="user_add_user_message_short" msgid="3310933423737035428">"Sukūrus naują naudotoją, tas asmuo turi įvykdyti sąrankos procesą.\n\nBet kuris naudotojas gali priimti atnaujintų programų leidimus visų kitų naudotojų vardu."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Nustatyti naudotoją dabar?"</string>
    <string name="user_setup_dialog_message" msgid="614037943337008555">"Įsitikinkite, kad asmuo gali naudoti planšetinį kompiuterį ir nustatyti savo vietą"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Nustatyti profilį dabar?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Nustatyti dabar"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ne dabar"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Tik planšetinio kompiuterio savininkas gali tvarkyti naudotojus."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Tik telefono savininkas gali tvarkyti naudotojus."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Apribotuose profiliuose negalima pridėti paskyrų"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Ištrinti <xliff:g id="USER_NAME">%1$s</xliff:g> iš šio įr."</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Naujas naudotojas"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Naujas profilis"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Ištrinti save?"</string>
    <string name="user_confirm_remove_title" msgid="3856148232937245711">"Pašalinti naudotoją?"</string>
    <string name="user_profile_confirm_remove_title" msgid="7399928935979459016">"Pašalinti profilį?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"Jūsų vieta ir duomenys dings iš šio planšetinio kompiuterio. Šio veiksmo anuliuoti negalima."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"Jūsų vieta ir duomenys dings iš šio telefono. Šio veiksmo anuliuoti negalima."</string>
    <string name="user_confirm_remove_message" product="tablet" msgid="4610106937214870034">"Šio naudotojo vieta ir duomenys dings iš šio planšetinio kompiuterio. Šio veiksmo anuliuoti negalima."</string>
    <string name="user_confirm_remove_message" product="default" msgid="8130264611683731142">"Šio naudotojo vieta ir duomenys dings iš šio telefono. Šio veiksmo anuliuoti negalima."</string>
    <string name="user_profile_confirm_remove_message" product="tablet" msgid="3071489858733409187">"Šio profilio vieta ir duomenys dings iš šio planšetinio kompiuterio. Šio veiksmo anuliuoti negalima."</string>
    <string name="user_profile_confirm_remove_message" product="default" msgid="7078238859138335893">"Šio profilio vieta ir duomenys dings iš šio telefono. Šio veiksmo anuliuoti negalima."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Pridedamas naujas naudotojas…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Ištrinti naudotoją"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Ištrinti"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Leisti programas ir turinį"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Programos su apribojimais"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Išplėsti programos nustatymus"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Pašalinti šią programą"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Pagrindinio ekrano nustatymai bus paslėpti, kol įdiegsite kitą programą, paleidžiamą spustelėjus pagrindinio ekrano mygtuką."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Šis nustatymas turi įtakos visiems šio planšetinio kompiuterio naudotojams."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Šis nustatymas turi įtakos visiems šio telefono naudotojams."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Keisti kalbą"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Keisti šrifto dydį"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Paliesti ir mokėti"</string>
    <string name="nfc_payment_no_apps" msgid="2481080809791416010">"Mokėkite tiesiog paliesdami"</string>
    <string name="nfc_payment_learn_more" msgid="5583407773744324447">"Sužinokite daugiau"</string>
    <string name="nfc_payment_menu_item_add_service" msgid="2885947408068969081">"Ieškoti programų"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Nustatyti kaip jūsų nuostatą?"</string>
    <string name="nfc_payment_set_default" msgid="8961120988148253016">"Visada naudoti „<xliff:g id="APP">%1$s</xliff:g>“, kai pasirenkama funkcija „Paliesti ir mokėti“?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="3803693771001226795">"Visada naudoti „<xliff:g id="APP_0">%1$s</xliff:g>“ vietoj „<xliff:g id="APP_1">%2$s</xliff:g>“, kai pasirenkama funkcija „Paliesti ir mokėti“?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Apribojimai"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Pašalinti apribojimus"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Keisti PIN kodą"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Rodyti pranešimus"</string>
    <string name="help_label" msgid="1107174367904110532">"Pagalba"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Turiniui skirta paskyra"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"Nuotraukos ID"</string>
    <string name="cell_broadcast_settings" msgid="8415582011920085222">"Tinklo transliacijos"</string>
    <string name="user_restrictions_title" msgid="7745810037152772035">"Programų ir turinio apribojimai"</string>
    <string name="user_rename" msgid="8523499513614655279">"PERVARDYTI"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Nustatykite programos apribojimus"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Kontroliuoja „<xliff:g id="APP">%1$s</xliff:g>“"</string>
    <string name="app_not_supported_in_limited" msgid="913035259626149121">"Ši programa nepalaikoma apribotuose profiliuose"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ši programa gali pasiekti jūsų paskyras"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"„Wi‑Fi“ ir mobilusis ryšys"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Leisti keisti „Wi‑Fi“ ir mobiliojo ryšio nustatymus"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Leisti keisti „Bluetooth“ susiejimą ir nustatymus"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"ALR"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Leisti keistis duomenimis, kai planšetinis kompiuteris aptinka kitą įrenginį"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Leisti keistis duomenimis, kai telefonas aptinka kitą įrenginį"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Vietovė"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Leisti programoms naudoti vietovės informaciją"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Atgal"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Kitas"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Užbaigti"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Fotografuoti"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Pasirinkti nuotrauką iš galerijos"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
</resources>
